Struts2自定义标签2自定义一个按班级id查询出该班级下的学生，存放进值栈，并遍历出来。

Struts2自定义标签的流程概念：

（1）需要两个类：标签类（继承相应的tag类），基本类（继承Component）。标签类专门负责从客户端取得用户输入的一些属性，这个普通的jsp自定义标签一样，取出来以后，需要把取出的属性值赋给基本类。从而可以看到基本类里面的属性也跟tag里面差不多。

（2）tag类里面，需要定义你客户端传来的属性。私有化。并相应的set get。

　　　　 必须的两个方法是public Component getBean(ValueStack stack,HttpServletRequest req, HttpServletResponse res)；

　　　　　　　　　　　　 protected void populateParams()；

　　　　第一个方法就是获得一个基本类的对象。在基本类里面需要有传入ValueStack的构造函数，如果基本类逻辑里面需要request或者response，那么需要有传入ValueStack stack, HttpServletRequest req, HttpServletResponse res的构造函数；

　　　　第二个方法是用来将客户端传来的值赋给基本类。这里是继承来的，所以首先调用super的相应方法。我理解上面第一个方法返回的对象就是全局的一个Component对象，也就是第二个方法里面使用的对象。上面这些就是在准备参数。

（3）所有的逻辑都放到了基本类里面了，基本类里面有两个方法是需要覆盖的，当然这是常用的两个方法，还有很多其它的方法，那些继承自jsp里面的 BodyContentTag（好像是）里面的一些方法。简单说说这两个方法是一个是public boolean start(Writer writer)；public boolean end(Writer writer)；顾名思义，start是标签开始时的输出，end是标签结束时的输出。这里都必须执行父类里面的方法，因为很多的输出Struts2都做 好了，所以要继承过来。然后再将自己需要输出的逻辑通过writer输出字符串就可以了。

　　　　这里面需要注意start的返回值，如果是true表示将标签内的body内容显示出来，否则不显示。end好像无所谓。

第一步：建立tld文件，str.tld在项目根目录webroot/web-inf下（类似web.xml项目启动时，读取tld文件，利用反射，实例化标签对应的java类）

<?xml version="1.0" encoding="UTF-8"?>  
    <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">  
    <taglib>     <!-- 自定义库标签的根 -->  
    <tlibversion>1.2</tlibversion>     <!-- 版本号 -->  
    <jspversion>1.1</jspversion>       <!-- JSP版本号 -->  
    <shortname>stu</shortname>        <!-- prefix="stu"标签名称-->  
    <uri>StudentTags</uri>   <!-- uri="StudentTags" 外界导入标签时，认识的名字，很重要。-->  
      
    <tag>  
     <name>selectAll</name>                            <!-- 标签名称 -->  
     <tagclass>com.bjsxt.sxf.tag.SeclectAllSt</tagclass>          <!-- 对应的java类的全路径 -->  
    </tag>  
      
    <!-- 有属性的标签，可以有多个属性  <attribute>并列 -->  
      <tag>  
           <name>selectBySex</name>  <!-- 标签名称 -->
            <tagclass>com.bjsxt.sxf.tag.SeclectStBySex</tagclass> 
            <attribute>   <!-- 对应标签的属性。 -->  
                 <name>sex</name>  
                 <required>true</required>  <!-- 是必需写的属性，即没有写属性标签不能被正常使用 -->  
            </attribute>         
       </tag>  
      <!-- 按班级学生id查询出班级集合，存放到属性var指定的变量中，然后利用s标签的迭代标签，将var指定的变量存放的学生集合遍历出来 -->
       <tag>
               <name>selectByClassId</name> <!-- 标签名称 --> 
               <tagclass>com.bjsxt.sxf.tag.MyTag</tagclass> <!-- 对应的java类的全路径 -->  
               <body-content>JSP</body-content><!-- 如果不需要标签体则设置empty，反之设定jsp，内部可以运行jsp所有的语法 -->
               <attribute>
                   <name>classId</name><!--指定属性名 和标签java类一致-->
                   <required>true</required><!--该属性是否是必须，如果非必须没设置则为空。 -->
                   <rtexprvalue>true</rtexprvalue><!-- 该属性能不能动态使用表达式为该属性赋值 true可以  false不可以  使用脚本和EL表达式来获取动态的值 -->
               </attribute>
               <attribute>
                   <name>var</name>
                   <required>true</required>
                   <rtexprvalue>false</rtexprvalue>
               </attribute>
               <attribute>
                   <name>num</name>
                   <required>false</required>
                   <rtexprvalue>false</rtexprvalue>
               </attribute>
       </tag>
       
    </taglib>  

第二步：建立标签类MyTag.java继承ComponentTagSupport类

 

package com.bjsxt.sxf.tag;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.components.Component;
import org.apache.struts2.views.jsp.ComponentTagSupport;

import com.opensymphony.xwork2.util.ValueStack;
/**
 * 标签体，传递标签的参数
* @ClassName: MyTag 
* @Description: TODO(这里用一句话描述这个类的作用) 
* @author 尚晓飞
* @date 2014-10-21 下午5:07:16 
*
 */
public class MyTag extends ComponentTagSupport {
    private String classId;//标签属性
    private String num;//标签属性
    private String var;//标签属性
    
    
    //继承ComponentTagSupport类是为了获得标签中的属性值，并包装成Component对象。继承Component类是为了从Struts2中的ValueStack中获得相对应的值。
    @Override
    public Component getBean(ValueStack valueStack, HttpServletRequest req,
            HttpServletResponse resp) {
        System.out.println("MyTag.getBean()");//标签运行第一站
        return new StuComponent(valueStack, req, resp);//返回标签业务逻辑类的对象
    }
    
    //将标签传递过来的值，赋值给标签业务逻辑类中的属性，业务处理逻辑会用到
    @Override
    protected void populateParams() {
        super.populateParams();
        System.out.println("MyTag.populateParams()");//标签运行第三站
        StuComponent stuComponent=(StuComponent) getComponent();
        stuComponent.setVar(var);//将前台传来的存放结果集合的变量名，赋值给逻辑类的父类中一个属性。个人理解，值栈中的一个存放结果集的集合引用。
        stuComponent.setClassId(classId);
        stuComponent.setNum(num);
        //stuComponent.setVard(var);将储存数据的变量传递到标签逻辑类中
        
    }

    public String getClassId() {
        return classId;
    }

    public void setClassId(String classId) {
        this.classId = classId;
    }

    
    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    public String getVar() {
        return var;
    }

    public void setVar(String var) {
        this.var = var;
    }
    
    

}

 

 

 

第三步：建立标签业务逻辑类StuComponent.java类继承ContextBean类

package com.bjsxt.sxf.tag;

import java.io.Writer;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


import org.apache.struts2.ServletActionContext;

import org.apache.struts2.components.ContextBean;
import org.apache.struts2.views.annotations.StrutsTag;
import org.apache.struts2.views.annotations.StrutsTagAttribute;

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;



import com.bjsxt.sxf.dao.StudentDao;
import com.bjsxt.sxf.po.Student;
import com.opensymphony.xwork2.util.ValueStack;

/**
 * MyTag标签的业务逻辑
* @ClassName: StuComponent 
* @Description: TODO(这里用一句话描述这个类的作用) 
* @author 尚晓飞
* @date 2014-10-21 下午5:12:31 
*
 */
//注解现在还不清楚什么意思，就当时描述作用，没有也行。
@StrutsTag(name="selectByClassId", tldBodyContent="JSP", tldTagClass="com.bjsxt.sxf.tag.MyTag", description="sxf zdy")
public class StuComponent extends ContextBean {
    protected  String classId;
    protected  String callBack="data";
    protected  String num;
    protected String vard;
    //标签进来，先运行该方法
    public StuComponent(ValueStack stack,HttpServletRequest req, HttpServletResponse res) {
        super(stack);
        System.out.println("StuComponent.StuComponent()");//标签运行第二站
        //下面可以直接获取，也可以通过标签体中的populateParams()方法，给该对象中的属性赋值set方法
//        classId=req.getParameter("classId");
//        num=req.getParameter("num");
                
    }
    
    
    
    
    


    //业务逻辑开始
    @Override
    public boolean start(Writer writer) {
        //班级id
        System.out.println("StuComponent.start()");//标签运行第四站
        Integer classIds=Integer.valueOf(classId);
        //查询出该班级的集合
        //ssh框架获取spring的ioc容器，从而获取与数据库交互的dao对象
        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
        //获取与数据库交互的dao
        StudentDao dao=(StudentDao) app.getBean("StudentDao");
        List<Student> students=dao.queryByClassId(classIds);
        //获取标签的储存属性名
        String varString=getVar();//此方法是继承ContextBean才有的，返回的是存储数据的变量名
        if(varString!=null){
            callBack=varString;
        }
        //将得到的数据库数据集合，存放入集合。
        //应该是struts2中的值栈，用来存放显示层要去的从数据库查询出来的值
        ValueStack stack=getStack();
        Map<String, Object> listMap=stack.getContext();
        
        //标签逻辑类继承ContextBean类时，该类里有getVar()方法返回引用数据的变量
        listMap.put(callBack, students);
        
        //标签类继承Component类时，该类里没有getVar()方法，但可以从标签类中，将引用数据的变量通过 populateParams()
        //传递到逻辑类里，直接存放到值栈的map中
        //说白了，标签中取出的数据，都是从值栈的map中取，只要值栈的map<key:vlaue>中有key,就能得到value
        //listMap.put(vard, students);
        
        return true;//retrun true则执行标签体内的jsp页面内容，return false则跳过标签体内容，执行标签后面的内容
    }

    @Override
    public boolean end(Writer writer, String body) {
        System.out.println("StuComponent.end()");//标签运行第五站
        //清空引用，可以使垃圾回收机制，回收没用的对象，减轻内存压力
        getStack().getContext().remove(vard);
        
        return false;//return false 或true意思暂时不明确
    }


    
    public String getClassId() {
        return classId;
    }
    @StrutsTagAttribute(description="classId",required=true)//必须有
    public void setClassId(String classId) {
        this.classId = classId;
    }
    public String getCallBack() {
        return callBack;
    }
    public void setCallBack(String callBack) {
        this.callBack = callBack;
    }
    public String getNum() {
        return num;
    }
    @StrutsTagAttribute(description="num",required=false)//非必须
    public void setNum(String num) {
        this.num = num;
    }







    public String getVard() {
        return vard;
    }







    public void setVard(String vard) {
        this.vard = vard;
    }

    
    
    
    

}

 

第四步：页面测试代码

 

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="StudentTags" prefix="stu" %>
<%@ taglib uri="/struts-tags" prefix="s"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
  </head>
  
  <body>
    This is my JSP page. <br>
    <a href="<%=request.getContextPath()%>/StudentAction!reportStudent.action">班级表单下载</a>
    <!-- 查询出所有学生 -->
       <stu:selectAll></stu:selectAll>
       <!-- 查询出指定性别的学生 -->
       <stu:selectBySex sex="男"></stu:selectBySex>
       <!-- 查询出指定班级的学生 -->
       <stu:selectByClassId var="students" classId="1" >
           <table border="2">
               <tr>
                   <td>id</td>
                   <td>姓名</td>
                   <td>性别</td>
                   <td>班级</td>
               </tr>
               <s:iterator value="#students" var="stu">
                   <tr>
                       <td><s:property value="#stu.id"/></td>
                       <td><s:property value="#stu.name"/></td>
                       <td><s:property value="#stu.sex"/></td>
                       <td><s:property value="#stu.classRoom.name"/></td>
                   </tr>
               </s:iterator>
           </table>
       </stu:selectByClassId>
       
       <h1>我是中国人</h1>
  </body>
  

 

第五步：效果图（只截图了最后一个自定义标签的效果图）

 

 

 

 

struts2自定义标签编写tld文件时。<body-content>的意思

 

body-content的值有下面4种：

<xsd:enumeration value="tagdependent"/>

    <xsd:enumeration value="JSP"/>

    <xsd:enumeration value="empty"/>

    <xsd:enumeration value="scriptless"/>

 

 

tagdependent：标签体内容直接被写入BodyContent，由自定义标签类来进行处理，而不被JSP容器解释，

如下：

<test:myList>

select name,age from users

</test:myList>

 

JSP：接受所有JSP语法，如定制的或内部的tag、scripts、静态HTML、脚本元素、JSP指令和动作。如：

<my:test>

    <%=request.getProtocol()%>      // ②

</my:test>

具体可参考后面附源码。

 

empty：空标记，即起始标记和结束标记之间没有内容。

下面几种写法都是有效的，

<test:mytag />

<test:mytag uname="Tom" />

<test:mytag></test:mytag>

 

scriptless：接受文本、EL和JSP动作。如上述②使用<body-content> scriptless </body-content>则报错，具体可参考后面附源码。