您的位置: 首页  >  文章  >  《研磨struts2》第八章 Struts2的Taglib 之 8.3 控制标签

《研磨struts2》第八章 Struts2的Taglib 之 8.3 控制标签

分类: 文章 • 2024-05-31 14:04:04


8.3  控制标签

控制标签关注程序的运行流程，比如用if/else来进行分支控制，用iterator来进行循环控制。接下来就来学习Struts2的控制标签。

8.3.1 if、elseif与else标签

1：if标签的功能：

       类似于Java程序中的if，用来表达分支判断。

   else标签的功能：

       类似于Java程序中的else。

   elseif标签的功能：

       类似于Java程序中的else if。

2：属性：

       if标签和elseif标签都只有一个test属性，它本身是一个OGNL表达式，运算结果为一个boolean值，表示是否符合条件，必须设置。

       else标签没有属性。

3：示例：

       由于大家对于Java中的if-else是非常熟悉的，因此这里只需要看看，用标签如何来表达即可，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2. <%  
  3.     int length=15;  
  4.     request.setAttribute("len",length);  
  5. %>  
  6. <s:if test="#request['len']>=20">  
  7.     您输入的值大于等于20  
  8. </s:if>  
  9. <s:elseif test="#request['len']<=10">  
  10.     您输入的值小于等于10  
  11. </s:elseif>  
  12. <s:else>  
  13.     您输入的值在10与20之间  
  14. </s:else>  

8.3.2 iterator标签

1：功能：

       iterator标签用来处理循环，可以用它遍历数组、Set和List等集合对象。这个标签还支持在ActionContext中保持一个保存遍历状态的对象，通过这个变量可以得到当前循环的各种信息。

       iterator标签在遍历一组对象的时候，它把正在循环的对象放在值栈的栈顶，所以可以直接引用这个对象的方法或属性，后面给出示例。

2：属性：

       iterator标签的主要属性：

  • value：用来指明到底循环的是谁，这个属性的值是OGNL表达式，用来访问ActionContext和值栈中需要被循环的对象。
  • status：这个属性在ActionContext中保存一个对象，用来返回当前循环的各种信息，可以返回的信息有：

l         count：集合含有多少个对象。

l         index：正在循环的这一项的索引。

l         even：当前遍历到的对象是不是处于列表的偶数索引位置。

l         odd：当前遍历到的对象是不是处于列表的奇数索引位置。

l         first：正在循环的是不是第一个。

l         last：正在循环的是不是最后一个。

  • begin、end、step：指明了如果使用索引来进行循环时的开始、结束和步长。
  • var：变量名称，用来引用存放到值栈的被循环的对象。

3：示例：

       其实在Java中处理循环的时候，主要用的是for循环和while循环，do-while循环的应用相对少一些。接下来用iterator标签来实现类似于Java中循环的功能。

（1）实现类似于for循环的功能

       假如现在要求完全使用标签，来实现循环输出1到10的值，该如何实现呢？

       很明显，使用iterator标签的begin、end、step和var属性就可以了，示例代码如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2. <s:iterator var="i" begin="1" end="10" step="1">  
  3.     <s:property value="#i"/>  
  4. </s:iterator>  

上面的实现很类似于如下的Java代码：

 

java代码：
查看复制到剪贴板打印
  1. <%  
  2.     for(int i=1;i<=10;i++){  
  3.         out.println(i);  
  4.     }  
  5. %>  

有朋友可能会说

（2）实现类似于while循环的功能

       假如要循环输出一个List的值，那么就需要使用到var和value属性了，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ page import="java.util.*"%>  
  2. <%@ taglib prefix="s" uri="/struts-tags" %>  
  3. <%  
  4.     //准备点循环用的数据  
  5.     List<String> list = new ArrayList<String>();  
  6.     for(int i=1;i<=10;i++){  
  7.         list.add("str="+i);  
  8.     }  
  9.     request.setAttribute("list",list);  
  10. %>  
  11. <s:iterator var="v" value="#request['list']">  
  12.     <s:property value="#v"/>  
  13. </s:iterator>  

上面的实现很类似于如下的Java代码：

 

java代码：
查看复制到剪贴板打印
  1. <%  
  2.     //如果用Iterator来循环  
  3.     Iterator it = list.iterator();  
  4.     while(it.hasNext()){  
  5.         out.println(it.next());  
  6.     }  
  7.     //如果用加强的for循环  
  8.     for(String s : list){  
  9.         out.println(s);  
  10.     }  
  11. %>  

（3）访问复杂的对象

       如果List里面放的是复杂对象呢，比如前面用过的UserModel，里面有两个属性：userId、name。页面上该如何循环显示呢？

       示例代码如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ page import="java.util.*"%>  
  2. <%@page import="cn.javass.ognl.vo.UserModel" %>  
  3. <%@ taglib prefix="s" uri="/struts-tags" %>  
  4. <%  
  5.     //准备需要循环的数据  
  6.     List<UserModel> list = new ArrayList<UserModel>();  
  7.     UserModel um1 = new UserModel();  
  8.     um1.setUserId("userId1");  
  9.     um1.setName("张三");  
  10.     list.add(um1);  
  11.   
  12.     UserModel um2 = new UserModel();  
  13.     um2.setUserId("userId2");  
  14.     um2.setName("李四");  
  15.     list.add(um2);  
  16.       
  17.     request.setAttribute("users",list);  
  18. %>  
  19.   
  20. <s:iterator value="#request.users">  
  21.     userId=<s:property value="userId"/>,  
  22.     name=<s:property value="name"/><br>  
  23. </s:iterator>  

分析一下上面的代码，iterator标签的value属性指明了要循环谁，里面的OGNL表达式"#request.users"表明了要访问request的属性中名称为users的属性的值。

接下来iterator标签在循环的时候，把当前正在循环的对象放到值栈的栈顶，比如循环第一次的时候，它就会把List中的第一个对象放到值栈的栈顶，这时候，访问这个对象的getName方法，就可以直接用简单的“name”就可以了。

（4）使用status属性

       如果还想输出当前循环的索引，或者是想要把循环输出的数据用表格来展示，并按照奇数行和偶数行来设置不同的背景色，也就是我们熟悉的波浪纹或者是斑马纹背景，该如何实现呢？

这当然需要使用iterator标签的status属性，把一个保存循环状态的对象放到ActionContext中，然后在iterator标签内的property标签中，就可以引用这个保存循环状态的对象了。先来示例输出当前循环的索引，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <s:iterator value="#request.users" status="state">  
  2.     索引=<s:property value="#state.index"/>,  
  3.     userId=<s:property value="userId"/>,  
  4.     name=<s:property value="name"/><br>  
  5. </s:iterator>  

注意，<s:property>引用status属性名称的时候前面要加#号，status这个对象可以使用的属性在前面的属性列表中写明了，#state.index就表示在循环内引用循环状态信息中的索引，每次循环完一个对象，state的内部状态都会相应变化。

       如果要实现波浪纹或斑马纹背景的表格，该如何实现呢？

首先需要多添加点数据，才好看出效果，其次把循环的数据放置到表格中去，然后通过循环的状态对象来判断是奇数行还是偶数行，为这些行设置不同的背景颜色就可以了。示例代码如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ page import="java.util.*"%>  
  2. <%@page import="cn.javass.ognl.vo.UserModel" %>  
  3.   
  4. <%@ taglib prefix="s" uri="/struts-tags" %>  
  5. <%  
  6.     //准备需要循环的数据  
  7.     List<UserModel> list = new ArrayList<UserModel>();  
  8.     UserModel um1 = new UserModel();  
  9.     um1.setUserId("userId1");  
  10.     um1.setName("张三");  
  11.     list.add(um1);  
  12.   
  13.     UserModel um2 = new UserModel();  
  14.     um2.setUserId("userId2");  
  15.     um2.setName("李四");  
  16.     list.add(um2);  
  17.       
  18.     UserModel um3 = new UserModel();  
  19.     um3.setUserId("userId3");  
  20.     um3.setName("王五");  
  21.     list.add(um3);  
  22.       
  23.     UserModel um4 = new UserModel();  
  24.     um4.setUserId("userId4");  
  25.     um4.setName("马六");  
  26.     list.add(um4);  
  27.       
  28.     request.setAttribute("users",list);  
  29. %>  
  30. <table border=1>  
  31.     <tr>  
  32.         <td colspan="4" align="center">用户列表</td>  
  33.     </tr>  
  34.     <tr>  
  35.         <td>索引</td>  
  36.         <td>用户编号</td>  
  37.         <td>用户姓名</td>  
  38.         <td>操作</td>  
  39.     </tr>  
  40.       
  41.     <s:iterator value="#request.users" status="state">  
  42.         <tr   
  43.             <s:if test="#state.even">  
  44.                 bgcolor="#EFF8FF"  
  45.             </s:if>     
  46.             <s:else>  
  47.                 bgcolor="#B4CFF1"     
  48.             </s:else>           
  49.         >  
  50.             <td><s:property value="#state.index"/></td>  
  51.             <td><s:property value="userId"/></td>  
  52.             <td><s:property value="name"/></td>  
  53.             <td><a href="">修改</a>  <a href="">删除</a></td>  
  54.         </tr>  
  55.     </s:iterator>   
  56. </table>  

运行效果如下图

《研磨struts2》第八章 Struts2的Taglib 之 8.3 控制标签

图8.9  示例iterator标签

是不是看起来有点做列表页面的感觉，这就对了，以后用Struts2开发，一定少不了使用iterator标签的。

8.3.3 append与param标签

1：功能：

       append标签用于把几个已经存在的集合组合成一个大集合，param标签跟它连用，用来指定组合哪些集合。

2：属性：

       append标签的主要属性：

  • var：用来指定把组合后的大集合放到值栈里的变量名称。

3：示例：

       简单的示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2. <s:set value="{1,2,3}" var="list1"/>  
  3. <s:set value="{4,5,6}" var="list2"/>  
  4.   
  5. <s:append var="list3">  
  6.     <s:param value="#list1"/>  
  7.     <s:param value="#list2"/>  
  8. </s:append>  
  9.   
  10. <s:iterator value="#list3">  
  11.     <s:property/>  
  12. </s:iterator>  

首先用set标签来指定两个集合，对于<s:set value="{1,2,3}" var="list1"/>来说，var属性指定了这个集合被放进值栈的名字为list1，而value属性的值为{1,2,3}，本身是OGNL表达式，表示直接创建一个集合，里面有1、2、3三个值。

       然后，使用append标签来把list1和list2组合成一个大的集合，<s:append var="list3">中的var属性指定了组合后的大集合放进值栈的名字为list3，而param标签的value属性指定了被组合的集合。

       最后，用iterator标签来遍历并输出合并后的集合。

8.3.4generator标签

1：功能：

       generator标签用来切分字符串，并把切分的结果组成一个集合。

2：属性：

       generator标签的主要属性：

  • val：指定被切分的字符串，必须指定。
  • separator：指定切分字符串用的分隔符，必须指定。比如要用“,”来切分字符串“a,b,c,d”，最终的结果为包含a、b、c、d四个字符串的集合。
  • count：返回集合的最大长度。
  • converter：用于设置自定义的Converter，必须是org.apache.struts2.util.IteratorGenerator.Converter接口的实现类。
  • var：指定变量名称，用来访问放到值栈中的集合。

3：示例：

       来个简单的示例，把一个字符串分解成集合，然后循环输出。示例代码如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2. <s:generator separator="," val="'a,b,c,d'" var="myList"/>  
  3. <s:iterator value="#myList">  
  4.     <s:property/>  
  5. </s:iterator>  

上面的示例中，先使用generator标签将val的值，也就是字符串"'a,b,c,d'"用separator的值，也就是","来进行切分，把切分后的结果放入值栈，引用的名称为var属性的值arr。最后用iterator标签输出刚刚切分创建的集合。

       如果把iterator标签嵌套在generator标签内，就可以不用指定iterator标签的value属性，而直接使用generator标签拆分字符串的结果了。

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2. <s:generator separator="," val="'a,b,c,d'" var="myList">  
  3.     <s:iterator>  
  4.         <s:property/>  
  5.     </s:iterator>  
  6. </s:generator>  

8.3.5merge标签

1：功能：

       merge标签用来把几个已经存在的集合组合成一个大集合，与append标签的作用类似，只是原来集合中出现的各个元素出现在大集合中的顺序不同。

2：属性：

merge标签的主要属性：

  • var：用来指定把组合后的大集合放到值栈里的变量名称。

3：示例：

       沿用前面的例子，稍稍修改一下，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2. <s:set value="{1,2,3}" var="list1"/>  
  3. <s:set value="{4,5,6}" var="list2"/>  
  4.   
  5. <s:merge var="list3">  
  6.     <s:param value="#list1"/>  
  7.     <s:param value="#list2"/>  
  8. </s:merge>  
  9.   
  10. <s:iterator value="#list3">  
  11.     <s:property/>  
  12. </s:iterator>  

去运行测试一下，结果页面如下：

《研磨struts2》第八章 Struts2的Taglib 之 8.3 控制标签

图8.10  示例merge标签

通过上面的示例可以看出，使用merge标签的时候，先出现原来各个集合中的第一个元素，然后是原来各个集合中的第二个元素，以此类推，所以结果为“1,4,2,5,3,6”。

而以前在使用append标签的时候，原来集合中的元素出现在大集合中的顺序为第一个集合的所有元素都出现之后，再出现第二个集合的所有元素，结果为“1,2,3,4,5,6”。

这就看出merge标签和append标签的区别来了。

8.3.6sort标签

1：功能：

       利用设置的比较器，来对指定的集合进行排序。

2：属性：

sort标签的主要属性：

  • comparator：用来指定对集合排序使用的比较器的实例
  • source：需要排序的集合
  • var：变量名称，把集合排序后的结果存放到page context中的key值

3：包含基本数据类型的集合排序示例：

       还是通过示例来看sort的使用，先来示范对包含基本数据类型的集合的排序。

（1）先来准备比较器，就是实现java.util.Comparator接口的类，实现对整型数据进行升序排序，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. package cn.javass.tag;  
  2. public class MyComparator implements java.util.Comparator{  
  3.       
  4.     public int compare(Object o1, Object o2) {  
  5.         int a = Integer.parseInt(o1.toString());  
  6.         int b = Integer.parseInt(o2.toString());          
  7.         if(a>b){  
  8.             return 1;  
  9.         }else if(a<b){  
  10.             return -1;  
  11.         }  
  12.         return 0;  
  13.     }  
  14. }  

（2）在页面上直接准备集合数据，然后排序并输出，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2. <s:set value="{4,5,3}" var="list1"/>  
  3. <s:bean id="myComparator" name="cn.javass.tag.MyComparator" />  
  4.   
  5. <s:sort comparator="#myComparator" source="#list1">  
  6.      <s:iterator>  
  7.         <s:property/>  
  8.      </s:iterator>  
  9. </s:sort>  

注意，在sort标签的comparator属性里面，配置的是比较器的实例，这个实例怎么得到呢？因此在前面使用bean标签创建了一个比较器的实例，然后在comparator属性里面指定就可以了。

（3）运行测试一下，界面输出：“3，4，5”，是排好序了的。当然，你也可以修改比较器的实现，来实现其它的比较方式，比如降序排列等等。

       有朋友会说，这是对基本类型的处理，要是复杂对象怎么排序呢？

4：包含复杂数据类型的集合排序示例：

（1）先来准备要排序的对象，简单点，就使用UserModel吧，给他添加toString方法，后面排序输出的时候会用，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. public class UserModel {  
  2.     private String userId;  
  3.     private String name;  
  4.     public String getUserId() {  
  5.         return userId;  
  6.     }  
  7.     public void setUserId(String userId) {  
  8.         this.userId = userId;  
  9.     }  
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.     public void setName(String name) {  
  14.         this.name = name;  
  15.     }  
  16.       
  17.     public String toString(){  
  18.         return "userId="+userId+",name="+name;  
  19.     }  
  20. }  

（2）来准备比较器实现，很简单，按照用户编号来进行降序排列吧，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. public class MyComparator implements java.util.Comparator<UserModel>{  
  2.       
  3.     public int compare(UserModel o1, UserModel o2) {  
  4.         if(o1.getUserId().compareTo(o2.getUserId()) > 0){  
  5.             //注意是降序排列  
  6.             return -1;  
  7.         }else if(o1.getUserId().compareTo(o2.getUserId()) < 0){  
  8.             return 1;  
  9.         }  
  10.         return 0;  
  11.     }  
  12. }  

（3）在页面上直接准备集合数据，然后排序并输出，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@page import="cn.javass.tag.vo.UserModel"%>  
  2. <%@page import="java.util.*"%>  
  3. <%@ taglib prefix="s" uri="/struts-tags" %>  
  4. <%  
  5.     List<UserModel> list = new ArrayList<UserModel>();  
  6.   
  7.     UserModel um1 = new UserModel();  
  8.     um1.setUserId("user1");  
  9.     um1.setName("张三");    
  10.     list.add(um1);  
  11.       
  12.     UserModel um2 = new UserModel();  
  13.     um2.setUserId("user2");  
  14.     um2.setName("李四");    
  15.     list.add(um2);  
  16.       
  17.     UserModel um3 = new UserModel();  
  18.     um3.setUserId("user3");  
  19.     um3.setName("王五");    
  20.     list.add(um3);  
  21.       
  22.     request.setAttribute("list",list);    
  23. %>  
  24.   
  25. <s:bean id="myComparator" name="cn.javass.tag.MyComparator" />  
  26.   
  27. <s:sort comparator="#myComparator" source="#request['list']">  
  28.      <s:iterator>  
  29.         <s:property/>  
  30.      </s:iterator>  
  31. </s:sort>  

（4）运行测试一下，界面输出：“userId=user3,name=王五 userId=user2,name=李四 userId=user1,name=张三”，是按照用户编号降序排好序了的。

8.3.7subset标签

1：功能：

       用于获取指定集合的子集合。

2：属性：

subset标签的主要属性：

  • count：用于指定子集中元素的个数。
  • decider：用于指定实现过滤条件的对象，这个对象会按照过滤条件一一检测源集合中的元素是否应该被放到子集合中，指定过滤条件的类需要实现org.apache.struts2.util.SubsetIteratorFilter.Decider接口。
  • var：变量名称，就是将子集合保存在当前页的上下文pageContext中所指定的key值，以后可以通过这个key值来访问。
  • source：用于指定源集合。
  • start：用于指定从源集合的第几个元素开始截取，注意：0代表第一个元素。

3：示例简单截取：

       先来个简单的示例，准备一个集合，然后从第2个开始截取，一共截取2个元素，然后把子集合输出出来，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2.   
  3. <s:set var="list" value="{1,2,3,4,5}"></s:set>  
  4. <s:subset source="#list" count="2" start="2">  
  5.    <s:iterator>  
  6.      <s:property />  
  7.    </s:iterator>  
  8. </s:subset>  

运行测试一下，界面应该输出如下：“3 4”。因为从原集合索引为2的位置开始截取，索引是从0开始，2就是第3个位置了。

4：decider属性示例：

先写一个Decider，假如实现如下功能：用于检测源集合中的每一个元素转换为字符串后，长度是否为1，是1则通过，否则这个元素不会进入子集合。示例代码如下：

 

java代码：
查看复制到剪贴板打印
  1. public class StringLengthDecider implements Decider{  
  2.       
  3.     public boolean decide(Object item) throws Exception {  
  4.         String value = item.toString();  
  5.         if (value.length()==1){  
  6.             return true;  
  7.         }  
  8.         return false;  
  9.     }  
  10. }  

在页面上先准备一个集合，然后使用这个Decider来实现截取判断，示例如下：

 

java代码：
查看复制到剪贴板打印
  1. <%@ taglib prefix="s" uri="/struts-tags" %>  
  2. <s:bean name="cn.javass.tag.StringLengthDecider" var="decider1"/>  
  3. <s:set var="list" value="{'1','2','33','4','55','6'}"></s:set>  
  4.   
  5. <s:subset source="#list" start="1" count="2" decider="#decider1">  
  6.    <s:iterator>  
  7.      <s:property />  
  8.    </s:iterator>  
  9. </s:subset>  

在上面的代码中，首先使用bean标签创建了一个StringLengthDecider的实例，并把这个实例放到值栈上。然后用set标签创建了一个集合，也把这个集合放到值栈上。

然后使用subset标签，其source属性指定了源集合为值栈中名称为“list”的集合；其start属性为1说明了从索引1开始，即源集合的第一个元素’1’不会进入子集合；其count属性的值为2说明了子集合中最多有2个元素；其decider属性指定了字符串长度等于1的元素才能进入子集合。

综合以上各项条件，最终运行得到的结果应该是：“2   4”。

 

私塾在线网站原创《研磨struts2》系列

转自请注明出处：【http://sishuok.com/forum/blogPost/list/0/4079.html】

欢迎访问http://sishuok.com获取更多内容

相关推荐