jsp标签

自定义标签库开发

自定义标签主要用于移除Jsp页面中的java代码。

移除jsp页面中的java代码，只需要完成两个步骤：

编写一个实现Tag接口的Java类，并覆盖doStartTag方法，把jsp页面中的java代码写到doStartTag方法中。

编写标签库描述符（tld）文件，在tld文件中对自定义标签进行描述。

完成以上操作，即可在JSP页面中导入和使用自定义标签。

快速入门：使用自定义标签输出客户机IP

package cn.itcast.web.tag;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;

public class ViewIPTag extends TagSupport {

    @Override
    public int doStartTag() throws JspException {
        HttpServletRequest request=(HttpServletRequest) this.pageContext.getRequest();
        String strIP=request.getRemoteAddr();
        JspWriter out=this.pageContext.getOut();
        try {
            out.write("你的IP地址为"+strIP);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return super.doStartTag();
    }
}
//Itcast.tld
<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
    version="2.0">
    <description>A tag library exercising SimpleTag handlers.</description>
    <tlib-version>1.0</tlib-version>
    <short-name>SimpleTagLibrary</short-name>
    <uri>http://www.hgnc.net/jsp2-tag</uri>
    <tag>
        <description>show client IP</description>
        <name>viewIP</name>
        <tag-class>cn.itcast.web.tag.ViewIPTag</tag-class>
        <body-content>empty</body-content>
    </tag>
</taglib>
//web.xml  tld文件放在WEB-INF目录下，可不配置,可参看tomcat例子
    <jsp-config>    
        <taglib>
            <taglib-uri>
               http://www.hgnc.net/jsp2-tag
            </taglib-uri>
            <taglib-location>
               /WEB-INF/itcast.tld
            </taglib-location>
        </taglib>    
    </jsp-config>
<%@ page language="java"  pageEncoding="UTF-8"%>
<%@ taglib prefix="itcast" uri="http://www.hgnc.net/jsp2-tag"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>    
    <title>显示IP地址</title>
  </head>  
  <body>
       <%
    String strIP=request.getRemoteAddr();
    out.print("你的IP地址为"+strIP);
     %> <br>
     
     < itcast:viewIP/>
  </body>
</html>

Tag接口的执行流程

JSP引擎将遇到自定义标签时，首先创建标签处理器类的实例对象，然后按照JSP规范定义的通信规则依次调用它的方法。

1、public void setPageContext(PageContext pc)， JSP引擎实例化标签处理器后，将调用setPageContext方法将JSP页面的pageContext对象传递给标签处理器，标签处理器以后可以通过这个pageContext对象与JSP页面进行通信。

2、public void setParent(Tag t)，setPageContext方法执行完后，WEB容器接着调用的setParent方法将当前标签的父标签传递给当前标签处理器，如果当前标签没有父标签，则传递给setParent方法的参数值为null。

3、public int doStartTag()，调用了setPageContext方法和setParent方法之后，WEB容器执行到自定义标签的开始标记时，就会调用标签处理器的doStartTag方法。

4、public int doEndTag()，WEB容器执行完自定义标签的标签体后，就会接着去执行自定义标签的结束标记，此时，WEB容器会去调用标签处理器的doEndTag方法。

5、public void release()，通常WEB容器执行完自定义标签后，标签处理器会驻留在内存中，为其它请求服务器，直至停止web应用时，web容器才会调用release方法。

简单标签

由于传统标签使用三个标签接口来完成不同的功能，显得过于繁琐，不利于标签技术的推广， SUN公司为降低标签技术的学习难度，在JSP 2.0中定义了一个更为简单、便于编写和调用的SimpleTag接口来实现标签的功能。实现SimpleTag接口的标签通常称为简单标签。简单标签共定义了5个方法：

setJspContext方法

setParent和getParent方法

setJspBody方法

doTag方法

SimpleTag方法介绍

setJspContext方法

用于把JSP页面的pageContext对象传递给标签处理器对象

setParent方法

用于把父标签处理器对象传递给当前标签处理器对象

getParent方法

用于获得当前标签的父标签处理器对象

setJspBody方法

用于把代表标签体的JspFragment对象传递给标签处理器对象

doTag方法

用于完成所有的标签逻辑，包括输出、迭代、修改标签体内容等。在doTag方法中可以抛出javax.servlet.jsp.SkipPageException异常，用于通知WEB容器不再执行JSP页面中位于结束标记后面的内容，这等效于在传统标签的doEndTag方法中返回Tag.SKIP_PAGE常量的情况。

SimpleTag接口方法的执行顺序

当web容器开始执行标签时，会调用如下方法完成标签的初始化

WEB容器调用标签处理器对象的setJspContext方法，将代表JSP页面的pageContext对象传递给标签处理器对象。

WEB容器调用标签处理器对象的setParent方法，将父标签处理器对象传递给这个标签处理器对象。注意，只有在标签存在父标签的情况下，WEB容器才会调用这个方法。

如果调用标签时设置了属性，容器将调用每个属性对应的setter方法把属性值传递给标签处理器对象。如果标签的属性值是EL表达式或脚本表达式，则WEB容器首先计算表达式的值，然后把值传递给标签处理器对象。

如果简单标签有标签体，容器将调用setJspBody方法把代表标签体的JspFragment对象传递进来。

执行标签时：

容器调用标签处理器的doTag()方法，开发人员在方法体内通过操作JspFragment对象，就可以实现是否执行、迭代、修改标签体的目的。

JspFragment类

javax.servlet.jsp.tagext.JspFragment类是在JSP2.0中定义的，它的实例对象代表JSP页面中的一段符合JSP语法规范的JSP片段，这段JSP片段中不能包含JSP脚本元素。

WEB容器在处理简单标签的标签体时，会把标签体内容用一个JspFragment对象表示，并调用标签处理器对象的setJspBody方法把JspFragment对象传递给标签处理器对象。JspFragment类中只定义了两个方法，如下所示：

getJspContext方法

用于返回代表调用页面的JspContext对象.

public abstract void invoke(java.io.Writer out)

用于执行JspFragment对象所代表的JSP代码片段

参数out用于指定将JspFragment对象的执行结果写入到哪个输出流对象中，如果传递给参数out的值为null，则将执行结果写入到JspContext.getOut()方法返回的输出流对象中。(简而言之，可以理解为写给浏览器)

显示标签体
public class SimpleDemo1 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        JspFragment jf=this.getJspBody();
        jf.invoke(this.getJspContext().getOut());
        super.doTag();
    }
}
不显示标签体
public class SimpleDemo1 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
    
    }
}
//重复显示
public class SimpleDemo2 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        JspFragment jf=this.getJspBody();
        for(int i=0;i<5;i++)
            jf.invoke(this.getJspContext().getOut());
//与这个等价jf.invoke(null);
        super.doTag();
    }
}
//修改标签内容
public class SimpleDemo3 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        JspFragment jf=this.getJspBody();
        StringWriter sw=new StringWriter();    
        jf.invoke(sw);
        
        String content=sw.toString();
        content=content.toUpperCase();    
        
        this.getJspContext().getOut().write(content);        
    }
}
//停止显示标签后面文档内容
public class SimpleDemo4 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        throw new SkipPageException();    
    }
}
    <uri>http://www.hgnc.net/jsp2-tagSimple</uri>
    <tag>
        <name>showbody</name>
        <tag-class>cn.itcast.web.simpletag.SimpleDemo1</tag-class>
        <body-content>scriptless</body-content>
    </tag>
<%@ page language="java" pageEncoding="UTF-8"%>
<%@ taglib prefix="itcast" uri="http://www.hgnc.net/jsp2-tagSimple"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <head>
        <title>简单标签</title>
    </head>

    <body>
        <itcast:showbody>ssssssssssssss
        </itcast:showbody>
    </body>
</html>

传统标签执行完后，驻留在内存象servlet一样，简单标签，执行完一次后，就释放了。

invoke方法详解

JspFragment.invoke方法可以说是JspFragment最重要的方法，利用这个方法可以控制是否执行和输出标签体的内容、是否迭代执行标签体的内容或对标签体的执行结果进行修改后再输出。例如：

在标签处理器中如果没有调用JspFragment.invoke方法，其结果就相当于忽略标签体内容；

在标签处理器中重复调用JspFragment.invoke方法，则标签体内容将会被重复执行；

若想在标签处理器中修改标签体内容，只需在调用invoke方法时指定一个可取出结果数据的输出流对象（例如StringWriter），让标签体的执行结果输出到该输出流对象中，然后从该输出流对象中取出数据进行修改后再输出到目标设备，即可达到修改标签体的目的。

开发带属性的标签

自定义标签可以定义一个或多个属性，这样，在JSP页面中应用自定义标签时就可以设置这些属性的值，通过这些属性为标签处理器传递参数信息，从而提高标签的灵活性和复用性。

要想让一个自定义标签具有属性，通常需要完成两个任务：

在标签处理器中编写每个属性对应的setter方法

在TLD文件中描术标签的属性

为自定义标签定义属性时，每个属性都必须按照JavaBean的属性命名方式，在标签处理器中定义属性名对应的setter方法，用来接收JSP页面调用自定义标签时传递进来的属性值。例如属性url，在标签处理器类中就要定义相应的setUrl(String url)方法。

在标签处理器中定义相应的set方法后，JSP引擎在解析执行开始标签前，也就是调用doStartTag方法前，会调用set属性方法，为标签设置属性。

在TLD中描述标签属性

元素名	是否必须指定	描述
description	否	用于指定属性的描述信息。
name	是	用于指定属性的名称。属性名称是大小写敏感的，并且不能以jsp、_jsp、java和sun开头。
required	否	用于指定在JSP页面中调用自定义标签时是否必须设置这个属性。其取值包括true和false，默认值为false，true表示必须设置，否则可以设置也可以不设置该属性。
rtexprvalue	否	rtexprvalue是runtime expression value（运行时表达式）的英文简写，用于指定属性值是一个静态值或动态值。其取值包括true和false，默认值为false，false表示只能为该属性指定静态文本值，例如"123"；true表示可以为该属性指定一个JSP动态元素，动态元素的结果作为属性值，例如JSP表达式<%=value %>。
type	否	用于指定属性值的Java类型。


<%@ page language="java" pageEncoding="UTF-8"%>
<%@page import="java.util.Date"%>
<%@ taglib prefix="itcast" uri="http://www.hgnc.net/jsp2-tagSimple"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <head>
        <title>带属性标签</title>
    </head>
    <body>
        <itcast:prop times="5" date="<%=new Date()%>">kkkkkkkkkkkkl<br />
        </itcast:prop>
    </body>
</html>
    <tag>
        <name>prop</name>
        <tag-class>cn.itcast.web.simpletag.SimpleDemo5</tag-class>   
        <body-content>scriptless</body-content>     
        <attribute>
            <name>times</name>
            <required>yes</required>
        </attribute> 
        <attribute>
            <name>date</name>
            <required>yes</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute> 
    </tag>  
package cn.itcast.web.simpletag;

import java.io.IOException;
import java.io.StringWriter;
import java.util.Date;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.SkipPageException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class SimpleDemo5 extends SimpleTagSupport {
    private int times;
    private Date date;
    
    public void setTimes(int times) {
        this.times = times;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    @Override
    public void doTag() throws JspException, IOException {
        this.getJspContext().getOut().write(date.toString());
        for (int i=0;i<times;i++)
            this.getJspBody().invoke(null);
        //throw new SkipPageException();    
    }
}

开发防盗链标签

<%@ page language="java"  pageEncoding="UTF-8"%>
<%@taglib  uri ="/jsp2-tagexample" prefix="fix"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<fix:referer site="http://localhost" page="/index.jsp"></fix:referer>
<html>
  <head>    
    <title>My JSP '1.jsp' starting page</title>
  </head>
  
  <body>
    This is my JSP page. <br>
  </body>
</html>
package cn.itcast.web.tag.eaxmple;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.SkipPageException;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class RefererTag extends SimpleTagSupport {
    private String page;
    private String site;
    public void setPage(String page) {
        this.page = page;
    }
    public void setSite(String site) {
        this.site = site;
    }
    @Override
    public void doTag() throws JspException, IOException {
        PageContext pageContext=(PageContext) this.getJspContext();
        HttpServletRequest request=(HttpServletRequest) pageContext.getRequest();
        HttpServletResponse response= (HttpServletResponse) pageContext.getResponse();
        String referer=request.getHeader("referer");
        
        if(referer==null || !referer.startsWith(site)){
            String cp=request.getContextPath();
            if(page.startsWith(cp))
            {    response.sendRedirect(page);
            }else if (page.startsWith("/")) {
                response.sendRedirect(cp+page);
            }else
            {
                response.sendRedirect(cp+"/"+page);
            }
            throw new SkipPageException();
        }        
        else
            super.doTag();
    }
    
}
<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
    version="2.0">
    <description>A tag library exercising SimpleTag handlers.</description>
    <tlib-version>1.0</tlib-version>
    <short-name>SimpleTagLibrary</short-name>
    <uri>/jsp2-tagexample</uri>
 
    <tag>
        <name>referer</name>
        <tag-class>cn.itcast.web.tag.eaxmple.RefererTag</tag-class>   
        <body-content>empty</body-content>     
        <attribute>
            <name>site</name>
            <required>yes</required>
        </attribute> 
        <attribute>
            <name>page</name>
            <required>yes</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute> 
    </tag>  
</taglib>

开发<c:if>标签

public class IfTag extends SimpleTagSupport {
	private boolean test;

	public void setTest(boolean test) {
		this.test = test;
	}

	@Override
	public void doTag() throws JspException, IOException {
		// TODO Auto-generated method stub
		if(test)
			this.getJspBody().invoke(null);
		else
			super.doTag();
		
	}
}
  <body> 
 <% session.setAttribute("user","mmmm") ;%>
  <fix:if test="${user==null }">
    未登陆. <br>
    </fix:if>
      <fix:if test="${user!=null }">
   welcome用户已经登录. <br>
    </fix:if>
    
    ssss
  </body>
    <tag>
        <description>Outputs Hello, World</description>
        <name>if</name>
        <tag-class>cn.itcast.web.tag.example.IfTag</tag-class>
        <body-content>scriptless</body-content>
        <attribute>
        	<name>test</name>
        	<required>true</required>
        	<rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

开发<c:if><c:else>标签

<fix:choose>
    <fix:when test="${user==null }">
                                          未登陆. <br>
    </fix:when>
    <fix:otherwith>
              welcome用户已经登录. <br>
    </fix:otherwith>
</fix:choose>
<fix:choose>
    <fix:when test="${2==2}">
        2==2<br>
    </fix:when>
    <fix:otherwith>
            2!=2<br>
    </fix:otherwith>
</fix:choose>

<fix:choose>
    <fix:when test="${1==1}">
         1==1 <br>
    </fix:when>
    <fix:otherwith>
             1<>1 <br>
    </fix:otherwith>
</fix:choose>
public class Choose extends SimpleTagSupport {
    private boolean isDo;
    public boolean isDo() {
        return isDo;
    }
    public void setDo(boolean isDo) {
        this.isDo = isDo;
    }
    @Override
    public void doTag() throws JspException, IOException {
        this.getJspBody().invoke(null);
    }
}
public class WhenTag extends SimpleTagSupport {

    private boolean test;
    
    public void setTest(boolean test) {
        this.test = test;
    }

    @Override
    public void doTag() throws JspException, IOException {
        Choose parent=(Choose) this.getParent();
        if(test && !parent.isDo())
        {
            this.getJspBody().invoke(null);
            parent.setDo(true);
        }        
    }
}
public class OtherwithTag extends SimpleTagSupport {

    @Override
    public void doTag() throws JspException, IOException {
        Choose parent=(Choose) this.getParent();
        if(!parent.isDo())
        {
            this.getJspBody().invoke(null);
            parent.setDo(true);
        }        
    }
}

开发迭代标签

<%@ page language="java"  pageEncoding="UTF-8" isELIgnored="false"%>
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@taglib  uri ="/jsp2-tagexample" prefix="cc"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>    
    <title>My JSP '1.jsp' starting page</title>
  </head>
  
<body>
<%
    List list=new ArrayList();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    request.setAttribute("list",list);
 %>
 <cc:foreach items="${list}" var="str">
 ${str }
 </cc:foreach>

</body>
</html>
<tag>
    <name>foreach</name>
    <tag-class>cn.itcast.web.tag.eaxmple.ForeachTag</tag-class>   
    <body-content>scriptless</body-content> 
    <attribute>
        <name>items</name>
        <required>true</required>
        <rtexprvalue>true</rtexprvalue>
    </attribute>
    <attribute>
        <name>var</name>
        <required>true</required>
        <rtexprvalue>true</rtexprvalue>
    </attribute>
</tag>  
package cn.itcast.web.tag.eaxmple;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class ForeachTag extends SimpleTagSupport {

    private String var;
    private Object items;

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

    public void setItems(Object items) {
        this.items = items;
    }

    @Override
    public void doTag() throws JspException, IOException {
        List list= (List) items;
        Iterator it=list.iterator();
        while(it.hasNext()){
            String value=(String) it.next();
            this.getJspContext().setAttribute(var, value);
            this.getJspBody().invoke(null);
        }
    }
}

<%@ page language="java"  pageEncoding="UTF-8" isELIgnored="false"%>
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@taglib  uri ="/jsp2-tagexample" prefix="cc"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>    
    <title>My JSP '1.jsp' starting page</title>
  </head>
  
<body>
______list_____<br>
<%
    List list=new ArrayList();
    list.add("nnn");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    request.setAttribute("list",list);
 %>
 <cc:foreach2 items="${list}" var="str">
 ${str }<br/>
 </cc:foreach2>

  ______map_____<br>
 <%
     Map map=new HashMap();
     map.put("aa","111");
     map.put("bb","222");
     map.put("cc","333");
     request.setAttribute("map",map);
  %>
<cc:foreach2 items="${map}" var="entry">
  ${entry.key } :${entry.value }<br/>
</cc:foreach2>

  
______Integer_____<br>
  <%
      Integer num[]={1,2,3,4};
      request.setAttribute("num",num);
   %>
<cc:foreach2 items="${num}" var="i">
${i }<br/>
</cc:foreach2>

______String_____<br>
  <%
      String strs[]={"sss","mmm"};
      request.setAttribute("strs",strs);
   %>
<cc:foreach2 items="${strs}" var="str">
${str }<br/>
</cc:foreach2>
______int_____<br>
  <%
      int num2[]={11,22,33,44};
      request.setAttribute("num2",num2);
   %>
<cc:foreach2 items="${num2}" var="i">
${i }
</cc:foreach2>
</body>
</html>
package cn.itcast.web.tag.eaxmple;

import java.io.IOException;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class ForeachTag2 extends SimpleTagSupport {

    private String var;
    private Object items;
    private Collection collection;
    public void setVar(String var) {
        this.var = var;
    }

    public void setItems(Object items) {
        this.items = items;
        if(items==null)
            collection=null;
        if(items instanceof Collection)
        {
            collection=(Collection) items;
        }
        if(items instanceof Map){
            Map map=(Map)items;
            collection=map.entrySet();
        }
        if(items.getClass().isArray()){
            this.collection=new ArrayList();
            int len=Array.getLength(items);
            for(int i=0;i<len;i++)
                this.collection.add(Array.get(items, i));
        }
        
/*        if(items instanceof Object[]){
            Object obj[]=(Object[]) items;
            collection=Arrays.asList(obj);        
        }
        if(items instanceof int[]){
            int arr[]=(int[])items;
            this.collection=new ArrayList();
            for(int i:arr){
                this.collection.add(i);
            }
        }*/
    }

    @Override
    public void doTag() throws JspException, IOException {
        if( collection==null) return;
        Iterator it=collection.iterator();
        while(it.hasNext()){
            Object value=it.next();
            this.getJspContext().setAttribute(var, value);
            this.getJspBody().invoke(null);
        }
    }
}

开发html转义标签

<fix:htmlFilter>
    <a href="a  发 a a">超链接的写法</a>
</fix:htmlFilter>
package cn.itcast.web.tag.example;

import java.io.IOException;
import java.io.StringWriter;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class HtmlFilter extends SimpleTagSupport {

    @Override
    public void doTag() throws JspException, IOException {
        JspFragment jf=this.getJspBody();
        StringWriter sw=new StringWriter();
        jf.invoke(sw);
        String content=sw.getBuffer().toString();
        content=filter(content);
        this.getJspContext().getOut().write(content);        
    }
    /*C:\\Tomcat 7.0\\webapps\\examples\\WEB-INF\\classes\\util\\HTMLFilter.java*/
    public static String filter(String message) {

        if (message == null)
            return (null);
        char content[] = new char[message.length()];
        message.getChars(0, message.length(), content, 0);
        StringBuilder result = new StringBuilder(content.length + 50);
        for (int i = 0; i < content.length; i++) {
            switch (content[i]) {
            case '<':
                result.append("&lt;");
                break;
            case '>':
                result.append("&gt;");
                break;
            case '&':
                result.append("&amp;");
                break;
            case '"':
                result.append("&quot;");
                break;
            default:
                result.append(content[i]);
            }
        }
        return (result.toString());
    }
}

打包标签库

1) 新建一java工程，把src目录下的东西的代码拷进来，再在工程目录下建立META-INF目录,把配置文件拷进来，点工程右键属性 export/Java/JAR file,next在上面两个框中，左框中选中要导出的工程，去掉右框中eclipse的配置，在点brower按钮，输入导出的文件名，点finish.

posted @ 2018-05-15 11:56 邓不利多阅读(127) 评论(0) 编辑收藏举报

刷新页面返回顶部

邓不利多