struts1的bean标签库

<bean:header>

<bean:header>标记用于检索HTTP请求中的Header信息。以下是一个HTTP请求的Header的例子，这个请求就是用户在访问本网页时向服务器发出的请求：

accept	image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/msword, application/vnd.ms-excel, application/vnd.ms-powerpoint, */*
referer	http://localhost:8080/struts/index.jsp
accept-language	zh-cn
ua-cpu	x86
accept-encoding	gzip, deflate
user-agent	Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Maxthon)
host	localhost:8080
connection	Keep-Alive
cookie	JSESSIONID=D800F1B5CADDFA2D39EFEDC3DB5FD6F3

可以看出，Header其实就是一个个的"名/值"对，<bean:header>标签的功能也就是根据Header的名称，把它的值取出来放在一个自定义的String型的变量中。以下是一段示例代码：

<bean:header id="explorer" name="user-agent"/>
你所使用的浏览器是：<bean:write name="explorer"/>

在上面的代码中，使用了<bean:header>标记的两个属性：

name属性：用于指定标记要读取的Header名称，比如此处指定了该标记要读取的Header名称为"user-agent"，也就是用户所使用的浏览器的信息。

id属性：在<bean:header>标记将name属性中所指定的Header取出后，保存在id属性所命名的变量中，这个变量存放在pageContext 内。

以下是上面代码的运行效果：

你所使用的浏览器是：Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Maxthon)

同样，可以使用下面的程序从pageContext中读出已经存入的变量。在上面的标记中，已经将user-agent这个Header放在了名为explorer 的变量中：

<%
    String test = "";
    test = (String) pageContext.getAttribute("explorer");
    out.println("您所使用的浏览器是:"+test);
%>

以下是运行效果：

您所使用的浏览器是:Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Maxthon)

<bean:parameter>

<bean:parameter>标记用于读取HTTP请求中的参数。先看以下代码：

<html:link page="/bean-parameter.jsp?testString=a+new+string&testInt=10000">
  点击此处添加请求参数
</html:link>

在上面的代码中，使用了<html:link>标记来向本页面发送请求，在请求后面跟上了两个参数testString和testInt。

以下是<bean:parameter>标记的代码示例：

<bean:parameter id="test1" name="testString" value=""/>
请求参数testString的值为：<bean:write name="test1"/>

<bean:parameter id="test2" name="testInt" value=""/>
请求参数testInt的值为：<bean:write name="test2"/>

上面的代码中用到了<bean:parameter>标记的三个属性。

name属性：用于指定页面请求中的参数名，如在上面的示例中，先后指定的请求参数名为testString和testInt。

id属性：在<bean:parameter>标记将name属性中所指定的请求参数取出后，保存在id属性所命名的变量中，这个变量存放在pageContext内。

value属性：该属性指定请求参数的默认值。当HTTP请求中不包含name属性所指定的参数时，倘若不为该参数指定一个默认值，则后台将报错。因此，通常情况下都应为请求参数指定一个默认值。在上例中为请求参数testString和testInt指定的默认值均为一个空串。

以下是运行结果代码的运行结果。用户可以通过点击"添加参数"按钮来为本页面加入请求参数。在用户点击后，应该能看到请求参数在页面上显示出来了，同时在地址栏上可以看到相应的请求参数。

添加参数

请求参数testString的值为：this is a test
请求参数testInt的值为：10000

如果在请求参数中包含多个同名的请求参数，那么，<bean:parameter>标记将读出第一个参数的值。例如有下面的链接：

<html:link page="/bean-parameter.jsp?testValue=10000&testValue=20000&testValue=30000">添加参数</html:link>

那么，当用户使用<bean:parameter>标记将testValue的值读出来时，将只显示第一个testValue的值，也就是10000。以下是运行效果，用户点击下面"添加参数"的链接来为testValue请求参数赋值

添加参数

testValue的值是：

如果想要把所有和参数名匹配的请求参数的值都显示出来，可以使用<bean:parameter>标记的multiple属性。示例代码如下：

<bean:parameter id="testArray" name="testValue" value="" multiple="yes"/>
参数列表如下：
<%
  for (int i=0;i     out.println("参数"+i+" : " + testArray[i]);
    out.println("<br>");
  }
%>

在上面的代码中，使用了<bean:parameter>标记的multiple属性，在这种情况下，id属性所定义的就不是一个String型的对象了而是变成了一个String[]型，也就是字符串数组，它用以存放同名请求参数的所有的值。然后，可以使用for语句将其打印出来。

以下就是运行效果，请求的URL为：

<html:link page="/bean-parameter.jsp?testValue=10000&testValue=20000&testValue=30000">添加参数</html:link>

参数列表如下：
参数0 :

<bean:cookie>

Cookie是Web服务器留在客户端用于识别客户身份的一种方式。它是在用户访问服务器时，服务器创建并保存在客户端的。待到用户下一次登录时，服务器可以根据Cookie所保留的信息来"认出"客户。这种技术在如今大量使用浏览器的电子商务应用中得到相当广泛的应用。虽然使用Cookie以后Web服务器端可以很方便的识别用户，但这也带来了很大的安全问题。因此，大多数的浏览器都可以选择是否允许保存Cookie。

每个Cookie其实就是一个"名/值"对，通常，在java中使用javax.servlet.http.Cookie来构造一个Cookie对象。以下是一段Cookie 代码示例：

<bean:cookie id="testcookie" name="/taglib1/bean-cookie" value="emptyValue" /> <%
    if (testcookie.getValue().equals("emptyValue")){
    javax.servlet.http.Cookie newcookie = new javax.servlet.http.Cookie("/taglib1/bean-cookie","Taglib1 Cookie Value");
    newcookie.setComment("This is a new cookie by Taglib1.");
    newcookie.setMaxAge(3600);
    response.addCookie(newcookie);
    }
%>
新添加的Cookie的值是：<bean:write name="testcookie" property="value"/>

上面代码的第一句使用到了<bean:cookie>标记，使用它来查找一个Cookie。此处，使用到了<bean:cookie>标记的几个属性：

name属性：<bean:cookie>使用name属性来指定Cookie的名字。

id属性：在<bean:cookie>标记将name属性中所指定的Cookie读出后，保存在id属性所命名的对象中，这个对象的类型为 javax.servlet.http.Cookie。

value属性：倘若name属性所指定的Cookie不存在，就使用该value属性的值做为其默认值。

这样，上面代码的第一句的含义就很清楚了，它是在查找一个名为/taglib1/bean-cookie的Cookie，如果它存在，就把它赋给一个名为testcookie的Cookie对象。倘若它不存在，就将默认的value属性的值设为testcookie的value。

在接下来的页面代码中，程序首先把testcookie的值取出来进行判断，倘若它等于"emptyValue"，则说明还没有为该用户正式创建过 Cookie。于是便为用户创建Cookie。程序调用javax.servlet.http.Cookie类的构造函数来构造一个name为/taglib1/bean-cookie，value 为"Taglib1 Cookie Value"的Cookie。同时为其设定注释和最大过期时间，在上面的代码中最大过期时间设置为3600秒。然后将创建好的新 Cookie写入服务器返回对象中，在客户端进行保存。当用户第一次访问该页面时，由于Cookie还未建立，所以会调用Cookie的构造函数来创建一个新的Cookie，但当用户关闭浏览器再次访问时，就会看到新添加的Cookie的值始终不变了，除非已经超过了它的最大过期时间。

以下是代码的运行效果，用户可以尝试关闭该浏览器然后再次打开以观察Cookie的使用效果。

新添加的Cookie的值是：emptyValue

<bean:cookie>标签还有一个multiple属性，此时，可以读出所有和Cookie的name相匹配的Cookie对象，当然，此时id属性所指定的就不再是一个Cookie对象了，而是一个Cookie的对象数组。这一点与<bean:parameter>的multiple属性很相似。读者可以自行揣摩。

<bean:page>

<bean:page>标记用于获取JSP内建对象。常用的内建对象包括application、config、request、response还有session。

<bean:page>标记的使用很简单，以下是一段示例代码：

<bean:page id="session_dup" property="session"/>
<%
out.println("<table>");
out.println("<tr>");
out.println("<td>");
out.println("Session的创建时间");
out.println("</td>");
out.println("<td>");
out.println(session_dup.getCreationTime());
out.println("</td>");
out.println("</tr>");

out.println("<tr>");
out.println("<td>");
out.println("Session的ID");
out.println("</td>");
out.println("<td>");
out.println(session_dup.getId());
out.println("</td>");
out.println("</tr>");

out.println("<tr>");
out.println("<td>");
out.println("Session的失效时间");
out.println("</td>");
out.println("<td>");
out.println(session_dup.getMaxInactiveInterval());
out.println("</td>");
out.println("</tr>");

out.println("<tr>");
out.println("<td>");
out.println("Session上次访问时间");
out.println("</td>");
out.println("<td>");
out.println(session_dup.getLastAccessedTime());
out.println("</td>");
out.println("</tr>");

out.println("</table>");
%>

上面的代码第一行使用了<bean:page>标记，它有两个属性：

property属性：指定了要使用的内建对象的名称。如request,session,application等。例如在上面的代码中就引用了session对象。

id属性：将property属性所指定的内建对象赋值给id属性所指定的对象，然后在页面上就可以引用它了。例如在上面的代码里就将session 对象赋给了一个叫session_dup的对象，接下来的代码就从session_dup中读取出了session中的信息并显示出来。

上面的程序运行效果如下所示

 

Session的创建时间	1216445271937
Session的ID	D800F1B5CADDFA2D39EFEDC3DB5FD6F3
Session的失效时间	1800
Session上次访问时间	1216446318484

这里和session时间相关的值都是long型的整数，它们代表从1970年1月1日到现在的毫秒数。当不停的刷新页面时，会发现最后一个 "上次访问时间"后的整数不停的在变化。

<bean:include>

<bean:include>标记用来将其它的Web资源包含入当前的页面中，比如它可以包含某个网页进入当前的网页中。它与JSP页面中的标签<jsp:include>的功能很相似。但它们之间还是有一定区别的。<bean:include>标记将其它Web资源放入一个对象中，而不是像<jsp:include>标签那样直接将其显示在网页上。当需要将<bean:include>标签所包含入的Web资源显示出来时可以使用 <bean:write>标记。

<bean:include>标记常用的有以下几个属性：

id属性：该属性指定了通过其它属性所引用的Web资源在本页面内的对象名。

page属性：该属性指定了相对于当前应用的一个URI，比如要将当前Web应用的首页当作一个资源引入当前页面中，可以使用"/index.jsp" 这样的方式。注意，page属性的值必须以"/"开头。

forward属性：该属性指定了全局的转发路径，它和struts-config.xml文件中设置全局转发的元素相匹配。

href属性：指定一个完整的URL链接。

以下是一些该标记的使用方法。

<bean:include id="indexpage" page="/index.jsp"/>
<bean:write name="indexpage" filter="false"/>

上面的代码将taglib1应用的主页做为了外部资源引入，并保存在对象indexpage中，然后使用了<bean:write>标记将其显示在本网页上。

<bean:include id="forwardpage" forward="index"/>
<bean:write name="forwardpage" filter="false"/>

上面的代码将taglib1应用中的全局转发项"index"做为了外部资源引入，查询struts-config.xml文件可以得知，名称为"index"的全局转发项就是链接到了主页，因此，以上代码的作用也是将主页作为了资源引入当前页面，并使用<bean:write>标记将之显示出来。

<bean:message>

<bean:message>用来显示资源文件中的消息文本。该标签有一个bundle属性，它和struts-config.xml文件中message-resources 标记内的key属性相对应。例如，在taglib1应用的struts-config.xml文件中有以下代码：

<message-resources parameter="message2" key="beanmessage"/>

当用户希望使用这个资源文件中的消息文本时，只需要将<bean:message>标记的bundle设为"beanmessage"就可以了。下面是 message2的资源文件中的内容：

beanmessage1=This is bean message No.1 beanmessage2=This is bean message No.2 beanmessage3=This is bean message with arg,{0}.

使用<bean:message>标记从资源文件中指定消息文本有以下三种方式：

第一种，直接在<bean:message>标记中使用key属性指定对应的资源文件中的消息文本。例如，若要显示key=beanmessage1的消息文本，可以使用下面的语句：

<bean:message bundle="beanmessage" key="beanmessage1"/>

以下是实际效果：

This is bean message No.1

第二种，使用<bean:message>标记的name属性指定一个字符串类型的变量，以该变量的值作为消息文本的key值。示例代码如下：

<%
    String test = "beanmessage1";
    pageContext.setAttribute("messagekey",test);
%>
<bean:message bundle="beanmessage" name="messagekey"/>

上面的代码首先定义了一个字符串，该串就是资源文件内消息文本的key值，然后将之存储于pageContext对象内，并命名为messagekey，再由标记的name属性指定pageContext对象内的messagekey。以下是运行效果，可以看到，依然能读出key为beanmessage1的消息文本。

This is bean message No.1

第三种方法是使用一个已经存在的JavaBean对象名做为name属性的值，再将其中某个属性做为property属性的值，以该JavaBean对象中的这一属性所存入的字符串值作为消息文本的key。示例代码如下所示：

<%
    TestPageBean bean1 = new TestPageBean("beanmessage1","empty");
    pageContext.setAttribute("testbean",bean1);
%>
<bean:message bundle="beanmessage" name="testbean" property="name"/>

在上面的代码中首先初始化了一个TestPageBean类型的对象bean1，这个bean1有两个属性，一个是name属性，一个是value属性，都是字符串类型，在构造函数中已经分别为其初始化了，其中，将name属性的值设为beanmessage1，也就是消息文本的key值。然后，将这个bean1存入 pageContext对象中，命名为testbean。在<bean:message>标记中name属性指定了pageContext对象内的testbean，property属性指定了这个testbean的name属性。运行结果如下，可以看到，依然能从资源文件中读出相应的消息文本。

有些时候，资源文件中的消息文本带有一些参数，如下面的形式：

beanmessage3=This is bean message with arg,{0}.

可以使用<bean:message>标记的arg0等属性来指定参数的值。比如arg0代表第一个参数，arg1代表第二个参数，依此类推，一直到 arg4。以下是代码示例：

<bean:message bundle="beanmessage" key="beanmessage3" arg0="HELLOWORLD"/>

运行效果如下所示：

This is bean message with arg,HELLOWORLD.

<bean:resource>

<bean:resource>标记用于指定Web资源的实际内容，如网页的源代码等。它常用的有以下三个个属性：

id属性：该属性和Struts BEAN标记库的其它标记中的id属性一样，它定义了一个对象来表示Web资源的内容。

name属性：用于指定Web资源路径。

input属性：如果没有设置input属性，则id属性默认的是一个字符串类型的对象。如果给input赋了值，比如"yes"，则id属性所定义的对象类型就为java.io.InputStream。

以下是一段示例代码：

<bean:resource id="indexpage" name="/index.jsp"/>
<bean:write name="indexpage" filter="false"/>

上面的代码将首页作为资源引入了页面，并且为其命名为indexpage，由于未设置input属性，因此，indexpage实际上就是一个字符串。它的内容应该是index.jsp的源代码.

<bean:struts>

<bean:struts>标记用于获取Struts框架内的一些对象，如ActionForm，ActionForward等。<bean:struts>标记有以下几个主要属性：

id属性：将获取到的Struts框架内部对象赋给由id所指定的对象。

formbean属性：该属性指定了ActionFormBean对象，它与struts-config.xml中的<form-bean>元素对应。

forward属性：该属性指定了ActionForward对象，它与struts-config.xml中的<global-forward>元素中的<forward>子元素对应。

mapping属性：该属性指定了ActionMapping对象，它与struts-config.xml中的<action>元素对应。

以下是一段示例代码：

<bean:struts id="indexpage" forward="index"/>
<bean:write name="indexpage" property="path"/>

上面的代码将使用了forward属性，它将全局转发中name为index的项赋给了indexpage，然后将其转发路径用<bean:write> 标记显示出来。以下是运行效果。

/index.jsp

<bean:define>

<bean:define>标记用于定义一个变量。它的id属性用来指定变量的名称，toScope属性用于指定变量存放的范围。一般情况下若不指定toScope属性，则默认的是存放在页面范围内。

通常，定义变量有以下三种方式：

第一种是通过value属性直接设置变量的值，在这种情况下id属性所指定的变量是一个String类型。以下是示例代码：

<bean:define id="testString1" value="This is a test string"/>
<bean:write name="testString1"/>

运行效果如下所示:

This is a test string

第二种方式是通过name属性和property属性共同指定一个变量来赋给id属性所定义的变量,此时id属性所定义的变量可以是任何类型。以下是示例代码：

<%
Date d = new Date();
pageContext.setAttribute("currDate",d);
%>
<bean:define id="milliseconds" name="currDate" property="time"/>
当前时间距离1970年1月1日的毫秒数为：<bean:write name="milliseconds"/>

上面的代码中将当前时间的Date型对象放入了pageContext对象中，然后使用<bean:define>标记定义了一个名为milliseconds的变量，标记的name属性指定了Date型对象，property指定了Date型对象的time属性。因此，通过id定义的milliseconds属性的类型应为long 型，它的值代表是1970年1月1日到现在的毫秒数。以下是代码的运行效果：

当前时间距离1970年1月1日的毫秒数为：1216446879484

第三种方式是通过type属性和name属性联合指定id所定义的变量的类型。type属性是id所定义变量的完整类型，name属性指定了已经存在的某个JavaBean。以下是一段代码示例：

<%
    pageContext.setAttribute("session",request.getSession());
%>
<bean:define id="session_dup" name="session" type="javax.servlet.http.HttpSession"/>
session的上次访问时间：<bean:write name="session_dup" property="creationTime"/>

在上面的代码中，首先将session对象存入pageContext对象中，然后使用<bean:define>标记的id属性定义的变量session_dup来引用它，type属性设定为javax.servlet.http.HttpSession。以下是运行的实际效果，显示的是session的上次访问时间。

session的上次访问时间：1216446876937

<bean:size>

<bean:size>标记用于获取集合对象或数组对象的长度。它的id属性定义一个整型变量，它的值就是集合对象的长度，name属性指定已经存在的集合对象或数组对象的名称。常用的集合对象有HashMap，ArrayList等。以下是一段示例代码：

<%
    ArrayList testlist = new ArrayList();
    testlist.add(new Integer(1));
    testlist.add(new Integer(2));
    testlist.add(new Integer(3));
pageContext.setAttribute("listforcount",testlist);
%>
<bean:size id="size" name="listforcount"/>
长度为：<bean:write name="size"/>

在上面的代码中，首先定义了一个ArrayList型的对象，然后为其添加三个成员，再将它存入pageContext对象中，并命名为listforcount。接下来使用<bean:size>标记把这个ArrayList型的对象的长度取出放在一个叫size的int型整数中，并将它显示出来。以下是代码的运行效果：

长度为：3

<bean:write>

<bean:write>标记用于在网页上转出内容。除了java的基本类型外，它可以输出各种类型的对象，有点类似于System.out.println() 的功能。通常情况下，若所要输出的对象实现了toString()方法，它就会调用对象的toString()方法并输出相应字符串。若对象未实现 toString()方法，则会调用Object类的toString()方法输出一个相应的字符串。

以下是一些简单的使用<bean:write>标记的例子。

<%
    String a = "string for test1";
    pageContext.setAttribute("test1",a);
%>
<bean:write name="test1"/>

上面的代码首先将一个字符串变量存于pageContext对象中，再用<bean:write>标记将其显示出来。以下是运行效果：

string for test1

---

<%
    TestPageBean t = new TestPageBean("string for test2","emptyvalue");
    pageContext.setAttribute("test2",t);
%>
<bean:write name="test2" property="name"/>

上面的代码创建了一个TestPageBean型的对象，该对象有两个属性，分别是name和value。在构造函数中将其name属性赋值为 "string for test2"，然后将这个TestPageBean型的对象放入pageContext对象中，再用<bean:write>标记将其显示出来。以下是运行效果：

string for test2

---

<%
Date currTime = new Date();
pageContext.setAttribute("currTime",currTime);
%>
当前的时间是：<bean:write format="yyyy-MM-dd hh:mm:ss" name="currTime"/>

上面的代码中，首先定义了一个Date型对象，然后将其存储于pageContext对象中，命名为currTime。在使用<bean:write>标记时，用到了它的format属性将输出日期的格式设为"yyyy-MM-dd hh:mm:ss"，然后把存于currTime对象按照相应的日期格式输了出来。其实，这里的操作有点类似于使用java.text.SimpleDateFormat类来格式化日期的输出一样。以下是运行的结果

当前的时间是：2008-07-19 02:17:40

---

<bean:write>标记还有一个filter属性，当其为true时，将把输出内容中涉及到HTML符号的地方作为普通字符输出，而当其为false时，则将输出内容中涉及到HTML符号的都转义为HTML文本输出。如下面的例子：

<%
String filterstring = "<hr>";
pageContext.setAttribute("filterstring",filterstring);
%>
这是filter为true的输出效果：<bean:write name="filterstring" filter="true"/> 这是filter为false的输出效果：<bean:write name="filterstring" filter="false"/>

在上面的代码中，定义了一个字符串filterstring，它的内容是"<hr>"，在HTML符号中<hr>应该是一个水平线。接下来使用<bean:write>标记输出这个字符串，分别使用了filter="true"和filter="false"两种不同的情况。输出的结果如下所示：

这是filter为true的输出效果：<hr>
这是filter为false的输出效果：