javaweb回顾第八篇如何创建自定义标签

前言：在javaweb开发中自定义标签的用处还是挺多的。今天和大家一起看自定义标签是如何实现的。

1：什么是标签

标签是一种XML元素，通过标签可以使JSP页面变得简介易用，而且标签具有很好的复用性。

2：自定义标签的标签库主要的接口以及类的继承实现关系图

3:一步步实现自定义标签

3.1：Tag接口

我们先看一个标签<td></td>这个标签有开始标签和结束标签，而且还有<tr>这样的父标签，那么实现一个简单的标签需要什么呢

第一：开始标签第二：结束标签第三：资源释放3个方法，而且还有父标签，如果我们要得到这个JSP上的内容我们还需要一个PageContext那么现在我们应该清晰了实现一个标签需要的元素。ok我们来看看Tag接口都有哪些内容

3.1.1：int doStartTag() throws JspException;这个是开始执行的起始方法

3.1.2：int doEndTag() throws JspException;这个是即将结束的结束方法

3.1.3：void release();释放对象的资源

3.1.4：void setPageContext(PageContext pc);设置当前页的上下文对象

3.1.5： void setParent(Tag t);设置父标签

3.1.6：Tag getParent();获取父标签

通过上面的介绍我们现在应该知道怎么去写一个标签了，我们小试牛刀一下

public class HelloTag implements Tag{

    private PageContext pageContext;

    private Tag parent;

    public void setPageContext(PageContext pc) {

        this.pageContext=pc;//这个方法由jsp页面的实现对象调用

    }

    public void setParent(Tag t) {

        this.parent=t;

    }

    public Tag getParent() {

        return parent;

    }

    public int doStartTag() throws JspException {

        return SKIP_BODY;

    }

    public int doEndTag() throws JspException {

        //利用pageContext来获取jspWriter对象

        JspWriter out=pageContext.getOut();

        try {

            //利用JSPWriter向客户端输入信息

            out.print("Hello Tag");

        } catch (IOException e) {

            e.printStackTrace();

        }

        return SKIP_PAGE;

    }

    public void release() {

    }

其中SKIP_BODY表示忽略标签体内容，下面我们会说到。既然写完了一个标签体我们就开始配置了

首先在WEB-INFO创建一个tlds文件夹然后创建一个tld文件然后设置如下

       <tag>

        <name>hello</name>

        <tag-class>com.lp.tags.HelloTag</tag-class>

        <body-content>empty</body-content>//表示标签没有内容

      </tag>

然后我们在创建一个jsp文件然后在jsp文件头部加上Taglib指令元素<%@ taglib uri="/WEB-INF/tlds/CustomTaglib.tld" prefix="hello"%>

在jsp页面就可以直接引用HelloTag标签了比喻我的是<hello:hello></hello:hello>

启动运行结果如下

有人又问了如果<td>这样的标签都有属性啊，如果有属性我怎么办呢，这个也简单没有属性我们就加入属性。我们来实现一个加法的自定义标签。这个我使用TagSupport类，从上面图中我们可以看出这个类实现了Tag接口，它会使我们写标签更加简单

public class AddTag extends TagSupport{

    private int num1;

    private int num2;

    public int getNum2() {

        return num2;

    }

    public void setNum2(int num2) {

        this.num2 = num2;

    }

    public int getNum1() {

        return num1;

    }

    public void setNum1(int num1) {

        this.num1 = num1;

    }

    public int doEndTag() throws JspException

    {

        JspWriter out=pageContext.getOut();

        int num=num1+num2;

        try {

            out.print(num);

        } catch (IOException e) {

            e.printStackTrace();

        }

        return EVAL_PAGE;

    }

有人又问你为什么没有写doStartTag方法啊，其实TagSupport类已经帮我们实现了，它默认情况是忽略标签中的内容的。现在我们在此配置tld文件

<tag>

        <name>add</name>

        <tag-class>com.lp.tags.AddTag</tag-class>

        <attribute>//表示属性

            <name>num1</name>属性命名

            <required>true</required>是否必须输入

            <rtexprvalue>true</rtexprvalue>是否是可运行的表达式

        </attribute>

        <attribute>

            <name>num2</name>

            <required>true</required>

            <rtexprvalue>true</rtexprvalue>

        </attribute>

    </tag>

现在我们在jsp中加入以下代码

<%@ taglib uri="/WEB-INF/tlds/CustomTaglib.tld" prefix="addtaglib"%>
<body>

    自定义的标签：

    <%

    int num1 = Integer.parseInt(request.getParameter("num1"));

    int num2 = Integer.parseInt(request.getParameter("num2"));%>

    算法：

    <addtaglib:add num2="<%=num1 %>" num1="<%=num2 %>"></addtaglib:add>

</body>

再次运行我们看看结果

有人又说了，你这写的标签都没有标签内容，你能不能实现一个标签带有内容的呢，ok这个没问题，刚刚我们说了SKIP_BODY表示忽略标签内容那么有个相反的EVAL_BODY_INCLUDE表示带有标签中的内容，在这里我们一起实现一个Switch case default三个标签体联用的简单功能

我们先看SwitchTag标签

public class SwitchTag extends TagSupport{

    private static final long serialVersionUID = 1L;

    //用于判断子标签是否已执行

    private boolean childTagExec;

    public SwitchTag()

    {

        childTagExec=false;

    }

    public int doStartTag() throws JspException

    {

        //当遇到switch的起始标签的时候子标签还没执行

        childTagExec=false;

        return EVAL_BODY_INCLUDE;//此时开始执行Switch内部的Case标签了

    }

    /**

     * 由子标签处理器对象调用，用于判断是否可以执行自身的标签体

     * @return

     */

    public synchronized boolean isExec()

    {

        return (!childTagExec);

    }

    /**

     * 如果子标签任何一个满足条件就调用这个方法 通知父标签

     * 这样其他子标签就忽略他们自身标签体，从而实现Switch case

     */

    public synchronized void childTagSucceeded()

    {

        childTagExec=true;

    }

    public void release()

    {

        childTagExec=false;

    }

CaseTag

public class CaseTag extends TagSupport{

    private static final long serialVersionUID = 1L;

    private boolean cond;//表示条件（比喻case：1此类）

    public CaseTag()

    {

        cond=false;

    }

    public void setCond(boolean cond)

    {

        this.cond=cond;

    }

    public int doStartTag() throws JspException

    {

        Tag parent=getParent();//获取父标签

        //判断是否可以执行自身标签

        if(!((SwitchTag)parent).isExec())

        {

            return SKIP_BODY;

        }

        //如果条件为true，则通知父标签有一个子标签满足条件

        //否则忽略标签体

        if(cond)

        {

            ((SwitchTag)parent).childTagSucceeded();

            return EVAL_BODY_INCLUDE;

        }

        else {

            return SKIP_BODY;

        }

    }

    public void release()

    {

        cond=false;

    }

DefaultTag

public class DefaultTag extends TagSupport{

    private static final long serialVersionUID = 1L;

    public int doStartTag() throws JspException

    {

        Tag parent=getParent();

        if (!((SwitchTag)parent).isExec()) {

            return SKIP_BODY;

        }

        ((SwitchTag)parent).childTagSucceeded();//如果所有Case都不满足则执行Default标签

        return EVAL_BODY_INCLUDE;

    }

}

我们在次配置tld文件

<tag>

        <name>switch</name>

        <tag-class>com.lp.tags.SwitchTag</tag-class>

        <body-content>jsp</body-content>

    </tag>

    <tag>

        <name>case</name>

        <tag-class>com.lp.tags.CaseTag</tag-class>

        <body-content>jsp</body-content>

        <attribute>

            <name>cond</name>

            <required>true</required>

            <rtexprvalue>true</rtexprvalue>

        </attribute>

    </tag>

    <tag>

        <name>default</name>

        <tag-class>com.lp.tags.DefaultTag</tag-class>

        <body-content>jsp</body-content>

    </tag>

其中<body-content>jsp</body-content>中jsp表示支持jsp具有的一切功能（比喻jsp9种内置对象）

<body>

    <%

        String userName = request.getParameter("userName");

    %>

    <mytag:switch>

        <mytag:case cond='<%=userName.equals("zhangsan")%>'>

            <%out.print("张三");%>

        </mytag:case>

        <mytag:case cond='<%=userName.equals("lisi")%>'>

            <%out.print("李四");%>

        </mytag:case>

        <mytag:case cond='<%=userName.equals("wangwu")%>'>

            <%out.print("王五");%>

        </mytag:case>

        <mytag:default>

            <%out.print("无");%>

        </mytag:default>

    </mytag:switch>

</body>

现在开始执行效果如下

3.1：IterationTag接口

上面我们都一直说的标签内容都一次性完成，但是如果是循环标题体内容怎么办，那么就用到了IterationTag接口，此接口增加了一个方法

public int doAfterBody() throws JspException该方法表示每次对标签体处理之后被调用也就是说在doStartTag方法之后doEndTag方法之前被调用，如果没有的话就不执行。

新增加了一个常量EVAL_BODY_AGAIN表示再次执行标签体。现在我们实现一个获取多条用户信息展示的功能

public class UserBean implements Serializable{

    private static final long serialVersionUID = 1L;

    public UserBean(){}

    public UserBean(String userName,int age,String email)

    {

        this.age=age;

        this.email=email;

        this.userName=userName;

    }

    private String userName;

    private int age;

    private String email;

    public String getUserName() {

        return userName;

    }

    public void setUserName(String userName) {

        this.userName = userName;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getEmail() {

        return email;

    }

    public void setEmail(String email) {

        this.email = email;

    }

}

public class IterateTag extends TagSupport{

    private static final long serialVersionUID = 1L;

    private Iterator items;//获取集合

    private String itemId;//对象的标识

    private Object item;//迭代对象中的每一个对象

    public IterateTag()

    {

        items=null;

    }

    public void release()

    {

        items=null;

    }

    /**

     * 得到集合的迭代对象

     */

    public void setItems(Collection cl)

    {

        if(cl.size()>0)

            items=cl.iterator();

    }

    public void setVar(String var)

    {

        this.itemId=var;

    }

    public int doStartTag()throws JspException

    {

        if(items.hasNext())//首先被执行

        {

            item=items.next();

        }

        else{

            return SKIP_BODY;

        }

        saveItems();//把迭代的对象保存在pageContext中

        return EVAL_BODY_INCLUDE;

    }

    public int doAfterBody() throws JspException

    {

        if(items.hasNext())//直到把迭代对象中的每一项都放进pageContext中

        {

            item=items.next();

        }

        else{

            return SKIP_BODY;

        }

        saveItems();

        return EVAL_BODY_AGAIN;

    }

    public void saveItems()

    {

        if(item==null)

        {

            pageContext.removeAttribute(itemId,pageContext.PAGE_SCOPE);

        }

        else{

            pageContext.setAttribute(itemId, item);//如果加入相同的id会进行覆盖

        }

    }

}

<tag>

        <name>iterate</name>

        <tag-class>com.lp.tags.IterateTag</tag-class>

        <body-content>JSP</body-content>

        <attribute>

            <name>items</name>

            <required>true</required>

            <rtexprvalue>true</rtexprvalue>

        </attribute>

        <attribute>

            <name>var</name>

            <required>true</required>

            <rtexprvalue>false</rtexprvalue>

        </attribute>

    </tag>

<body>

    <%

        ArrayList al = new ArrayList();

        UserBean user1 = new UserBean("zhangsan", 25, "7808@outlook.com");

        UserBean user2 = new UserBean("lisi", 15, "16455@qq.com");

        UserBean user3 = new UserBean("wangwu", 35, "7808@outlook.com");

        al.add(user1);

        al.add(user2);

        al.add(user3);

    %>

    <table>

        <tr>

            <td>用户名</td>

            <td>年龄</td>

            <td>邮箱</td>

        </tr>

        <iterator:iterate items="<%=al%>" var="user">

        <jsp:useBean id="user" class="com.lp.beans.UserBean"></jsp:useBean>

            <tr>

                <td><jsp:getProperty property="userName" name="user" /></td>

                <td>${user.age}</td>

                <td>${user["email"]}</td>

            </tr>

        </iterator:iterate>

    </table>

</body>

效果如下

4：简单标签开发

为了简化自定义标签开发，JSP2.0加入了简单标签的开发实现的接口是SimpleTag，我们一起看下SimpleTag的主要方法

4.1: public void setJspContext( JspContext pc )该方法被容器调用，设置JspContext，JspContext 是PageContext的基类

4.2：public void setParent( JspTag parent );设置父标签

4.3：public JspTag getParent();获取父标签

4.4：public void setJspBody( JspFragment jspBody );该方法用于设置标签体标签体，标签体由JspFragment对象提供，可以把JspFragment看做是一个对象封装一段JSP代码，可以被多次执行。

4.5：public void doTag()，主要处理标签和标签体的业务逻辑

public class WelcomeSimpleTag extends SimpleTagSupport{

  private JspFragment jspFragment;

  private String name;

  public void setJspBody(JspFragment jspBody)

  {

      this.jspFragment=jspBody;

  }

  public void setName(String name)

  {

      this.name=name;

  }

  public void doTag() throws JspException, IOException

  {

      JspContext jspContext=getJspContext();

      JspWriter out=jspContext.getOut();

      out.print(name);

      jspFragment.invoke(null);

  }

然后在jsp页面之间调用即可。关于简单标签的开发，大家可以自行实践。