JSTL自定义标签

这节我们总结一下JSTL自定义标签相关内容。

1. 自定义标签简介

自定义标签主要用于移除JSP页面中的java代码。Jsp页面主要是用来显示给前台的，如果里面有过多的java代码的话，会显得很乱，但是没有java代码也无法获取相关数据或完成相关操作。那么这时候我们就可以自己定义一个标签，来完成需要用java代码完成的事情，这样Jsp页面就会清洁很多，可读性也更强。JSP中使用自定义标签移除只需要完成以下两个步骤：

1）编写一个实现Tag接口的java类（标签处理类）；

2）编写标签库描述符（tld）文件，在tld文件中对标签处理类进行描述。

2. 一个简单实例

我们写一个简单的实例来快速理解自定义标签：输出客户机的IP。按照上面描述的两个步骤，我们首先编写一个实现Tag接口的java类：

public class ViewIPTag implements Tag {

	private PageContext pageContext;
	@Override
	public int doStartTag() throws JspException {
		HttpServletRequest request = (HttpServletRequest)pageContext.getRequest(); //获取request
		JspWriter out = pageContext.getOut(); //获取out</span>

		String ip = request.getRemoteAddr(); //通过request获取客户机的ip
  		try {
			out.write(ip); //写到浏览器
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
		return 0;
	}
	@Override
	public int doEndTag() throws JspException {
		return 0;
	}
	@Override
	public Tag getParent() {
		return null;
	}
	@Override
	public void release() {
	}
	@Override
	public void setPageContext(PageContext arg0) {
		this.pageContext = arg0;
	}
	@Override
	public void setParent(Tag arg0) {
	}
}

写好了java类，我们来编写标签库描述符（tld）文件，在WEB-INF目录下新建一个tld文件，在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>/test</uri>  <!--为该标签配一个uri-->

    <tag>
	<name>viewIP</name> <!-- 为标签处理器类配一个标签名 -->
	<tag-class>web.tag.ViewIPTag</tag-class>
	<body-content>empty</body-content>
    </tag>

</taglib>

这样我们在JSP页面中就可以导入并使用自定义标签了：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="/test" prefix="test"%>  <!--uri与tld文件中配的uri相同-->

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>输出客户机的IP</title>
  </head>

  <body>
	您的IP是：<test:viewIP/>

	<!--该标签相当于执行下面脚本代码-->
	<%
		String ip = request.getRemoteAddr();
		out.write(ip);
	%>
  </body>
</html>

到这里，应该就能清楚了自定义标签的定义和配置了。我们来分析一下执行顺序：JSP引擎首先通过uri和viewIP标签名去找tld文件，在tld中通过viewIP找到ViewIPTag类，该类中，首先调用setPageContext方法把页面的pageContext传递进来，再调用setParent把父标签传递进来（没有则不传），至此完成了标签的初始化工作。然后调用doStartTag和doEndTag方法，开始和结束标签，最后调用release方法释放标签，运行时所占的资源。

3. 自定义标签功能扩展

开发人员在编写JSP页面时，经常还需要在页面中引入一些逻辑，如：

控制JSP页面某一部分内容是否执行；

控制整个JSP页面是否执行；

控制JSP页面内容重复执行；

修改JSP页面内容输出。

即：自定义标签除了可以移除JSP页面的java代码外，还可以实现以上功能。下面我们一个个来分析：

1）控制JSP页面某一部分内容是否执行

新建一个标签处理类TagDemo1继承TagSupport类（TagSupport类已经实现了Tag接口，不用直接去实现了），doStartTag方法中可以通过不同的返回值类控制标签体是否执行。返回Tag.EVAL_BODY_INCLUDE表示执行标签体内容，返回Tag.SKIP_BODY表示不执行。

//控制标签体是否执行
public class TagDemo1 extends TagSupport {

	@Override
	public int doStartTag() throws JspException {

//		return Tag.SKIP_BODY;//不执行标签体内容
		return Tag.EVAL_BODY_INCLUDE; //执行标签体内容
	}
}

然后在文件中配置好：

<tag>
	<name>demo1</name>
	<tag-class>web.tag.TagDemo1</tag-class>
	<body-content>JSP</body-content> <!--JSP表示标签体内容为JSP-->
</tag>

这样即可在JSP页面中可以根据标签处理类doStartTag方法的返回值控制标签体内容是否执行。

2）控制整个JSP页面是否执行

同样地，doEndTag方法中可以通过不同的返回值类控制下面的JSP页面是否执行。返回Tag.EVAL_PAGE表示执行下面的JSP页面内容，返回Tag.SKIP_PAGE表示不执行。如下：

//控制JSP页面是否执行
public class TagDemo2 extends TagSupport {

	@Override
	public int doEndTag() throws JspException {

//		return Tag.SKIP_PAGE;//不执行JSP页面
		return Tag.EVAL_PAGE;//执行JSP页面
	}
}

3）控制JSP页面内容重复执行

控制页面内容重复执行的话Tag接口就无法满足了，需要实现它的子接口IterationTag接口，该接口中有个doAfterBody方法来决定是否重复执行标签体内容。如果该方法返回IterationTag.EVAL_BODY_AGAIN则继续执行，如果返回IterationTag.SKIP_BODY则结束重复并跳转到doEndTag()方法执行了。不过不用直接去实现IterationTag接口，TagSupport类也实现了该接口，所以只要让标签处理类继承TagSupport类即可。需要注意的是除了覆盖doAfterBody方法外，还得覆盖doStartTag方法并返回Tag.EVAL_BODY_INCLUDE。因为只有允许标签体执行才能重复执行。如下：

//控制页面内容重复执行
public class TagDemo3 extends TagSupport {

	int i = 5;
	@Override
	public int doAfterBody() throws JspException {

		i--;
		if(i >= 0)
			return IterationTag.EVAL_BODY_AGAIN;
		else
			return IterationTag.SKIP_BODY;
	}

	@Override
	public int doStartTag() throws JspException {

		return Tag.EVAL_BODY_INCLUDE;
	}
}

4）修改JSP页面内容输出

修改JSP页面内容输出的话IterationTag接口就无法满足了，需要实现它的子接口BodyTag接口，该接口增加了两个方法：doInitBody()和setBodyContent(BodyContent b)方法。如果doStartTag方法返回BodyTag.EVAL_BODY_BUFFERED，则BodyContent对象就会被JSP翻译过后的Servlet创建，即得到标签体对象。在doEndTag方法里对标签内容进行修改，可以通过this.getBodyContent().getString()拿到转成String的标签体内容，然后对该内容进行修改，再将结果result通过this.pageContext().getOut().write(result)进行输出，在doEndTag方法里返回Tag.EVAL_PAGE。然后JSP翻译过的servlet再把该BodyContent对象传递给setBodyContent方法完成修改。所以我们只需要覆盖doStartTag和doEndTag方法即可。该接口已经有个默认实现类BodyTagSupport，编写标签处理类直接继承这个类即可。如下：

//修改标签内容
public class TagDemo4 extends BodyTagSupport {

	@Override
	public int doStartTag() throws JspException {

		return BodyTag.EVAL_BODY_BUFFERED;

	}

	@Override
	public int doEndTag() throws JspException {

		//拿到标签体
		String content = this.getBodyContent().getString();
		String result = content.toUpperCase();

		try {
			this.pageContext.getOut().write(result);
		} catch (IOException e) {
			throw new RuntimeException(e);
		}

		return Tag.EVAL_PAGE;
	}
}

注：以上扩展功能的知识点在JSP2.0后已经被淘汰掉了，会有一个新的简单标签（SimpleTag）接口可以更方便的实现。但是以上的知识点在Struts框架中还在使用。在学Struts框架的标签库会遇到。下面我们来看一看简单标签的相关内容。

4. 简单标签

简单标签接口SimpleTag与上面提到的标签接口不同，SimpleTag标签提供了一个简单的doTag()方法代替了doStartTag和doEndTag方法。所有标签的逻辑、迭代、计算等等都在这个方法中运行。因此SimpleTag接口也可以替代BodyTag接口。该接口中有以下方法：

void doTag()
JspTag getParent()
void setJspBody(JspFragment jspBody)：把标签体通过该方法传递进来，我们可以在doTag方法中拿到jspBody对象即拿到了标签体，然后可以对标签体做想做的事。包括上面所有功能
void setJspContext(JspContext pc)
void setParent(JspTag parent)

JspContext是pageContext的父类，执行顺序：JSP引擎首先通过uri和viewIP标签名去找tld文件，在tld中通过viewIP找到ViewIPTag类，该类中，首先调用setJspContext方法把页面的pageContext传递进来，再调用setParent把父标签传递进来(没有则不传)，然后再调用setJspBody方法，把代表标签体的jspFragment对象传递进去，至此完成了标签的初始化工作。然后开始执行标签，即调用doTag方法。下面我们使用简单标签扩展上面的功能。

1）控制JSP页面某一部分内容是否执行

//控制标签体是否执行
public class SimpleTagDemo1 extends SimpleTagSupport {

    //用简单标签使用这个方法完成所有业务逻辑
    @Override
    public void doTag() throws JspException, IOException {
        
        //得到代表标签体的JspFragment
        JspFragment jf = this.getJspBody();
        
//      PageContext pageContext = (PageContext)this.getJspContext();    //获得pageContext    
//      jf.invoke(pageContext.getOut());//将输出流放到invoke方法中，写给浏览器
        
        jf.invoke(null);//null默认写给浏览器。不调用该方法即不运行标签体
        
    }       
}<span style="font-family:Microsoft YaHei;">
</span>

在simple.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>/simpleitcast</uri>

    <tag>
        <name>demo1</name>
        <tag-class>web.simpletag.SimpleTagDemo1</tag-class>
        <body-content>scriptless</body-content>
    </tag>
</taglib>

2）控制整个JSP页面是否执行

public class SimpleTagDemo4 extends SimpleTagSupport {

    @Override
    public void doTag() throws JspException, IOException {

        throw new SkipPageException();//抛出个SkipPageException异常即不会执行下面的JSP页面，否则会执行
        
    }       
}

tld文件中的配置略，跟上面一样的……不再赘述。

3）控制JSP页面内容重复执行

//控制标签体执行10次
public class SimpleTagDemo<span style="font-family:Microsoft YaHei;">3</span> extends SimpleTagSupport {

	@Override
	public void doTag() throws JspException, IOException {

		JspFragment jf = this.getJspBody();

		for(int i = 0; i < 10; i++) {
			jf.invoke(null);
		}

	}
}

4）修改JSP页面内容输出

//将标签体内容改成大写
public class SimpleTagDemo3 extends SimpleTagSupport {

	@Override
	public void doTag() throws JspException, IOException {

		JspFragment jf = this.getJspBody();
		StringWriter sw = new StringWriter();
		jf.invoke(sw);//不要invoke到浏览器，先invoke到自己的流里，然后修改修改再输出

		String content = sw.getBuffer().toString();//获得标签体的String内容
		content = content.toUpperCase();

		PageContext pageContext = (PageContext)this.getJspContext();
		pageContext.getOut().write(content);//再将流输出给浏览器

	}
}

5. 带属性的标签

自定义标签可以定义一个或多个属性，这样在JSP页面中应用自定义标签时就可以设置这些属性的值，通过这些属性为标签处理器传递参数信息，从而提供标签的灵活性和复用性。想要让一个自定义标签具有属性，通常需要完成两个任务即可：

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

2）在tld文件中描述标签的属性

为自定义标签定义属性时，每个属性都必须按照javaBean的属性命名方式，在标签处理器中定义属性名对应的setter方法，用来接收JSP页面调用自定义标签时传递进来的属性值。例如属性url，在标签处理器类中就要定义相应的setUrl(String url)方法。在标签处理器中定义相应的set方法后，JSP引擎在解析执行开始标签前，也就是调用doStartTag方法前，会调用set属性方法，为标签设置属性。我们看下面的例子：

//通过属性控制标签体的执行次数
public class SimpleTagDemo5 extends SimpleTagSupport {

	public int count; //<itcast:demo5 count="6"

	public void setCount(int count) {//自动将属性传进来
		this.count = count;
	}

	@Override
	public void doTag() throws JspException, IOException {

		for(int i = 0; i < count; i++){
			this.getJspBody().invoke(null);
		}
	}
}

tld文件中配置如下：

<tag>
	<name>demo5</name>
	<tag-class>web.simpletag.SimpleTagDemo5</tag-class>
	<body-content>scriptless</body-content>
	<attribute>
		<name>count</name>
		<required>true</required>
		<rtexprvalue>true</rtexprvalue>  <!-- true的话jsp中该属性只可以为表达式，false只能为静态值 -->
		<type>java.lang.Integer</type>  <!-- 指明参数的类型 -->
	</attribute>
</tag>

在JSP页面中就可以使用标签

<itcast:demo5 count="4">
	xxxx
</itcast>

xxxx被输出4次

6. JSTL案例

我们来用自定义JSTL标签开发一个防盗链的标签：如果客户端直接访问http://localhost:8080/example/test.jsp，会被阻止，先跳转到主页index.jsp，再访问1.jsp

public class RefererTag extends SimpleTagSupport {

	private String site;
	private String page;

	public void setSite(String site) {
		this.site = site;
	}
	public void setPage(String page) {
		this.page = page;
	}

	@Override
	public void doTag() throws JspException, IOException {

		//看来访者是从哪个页面来的
		PageContext pageContext = (PageContext)this.getJspContext();
		HttpServletRequest request = (HttpServletRequest)pageContext.getRequest();

		String referer = request.getHeader("referer");//得到是从哪个页面来的

		//判断是否从自己的主页过来的
		if(referer == null || !referer.startsWith(site)) {

			HttpServletResponse response = (HttpServletResponse)pageContext.getResponse();
			String webroot = request.getContextPath(); //example
			if(page.startsWith(webroot))
				response.sendRedirect(page);
			else
				response.sendRedirect(webroot + page);

			//重定向后，控制保护的页面不要执行
			throw new SkipPageException();
		}
	}
}

看一下index.jsp页面：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP 'index.jsp' starting page</title>
  </head>
  <body>
    This is my JSP page. <br>
    <a href="${pageContext.request.contextPath }/test.jsp">内容</a> <!--掉转到1.jsp-->
  </body>
</html>

再看一下test.jsp：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="/simpleitcast" prefix="it"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<it:referer site="http://localhost:8080/" page="/index.jsp"/>
<html>
  <head>
    <title>防盗链</title>
  </head>
  <body>
	这是内容
  </body>
</html>

7.  打包标签库

既然我们可以自定义标签，那我们定义好的标签如何打包供其他工程使用呢？这在开发中是很重要的。我们按照下列步骤来打包自定义标签库：

a. 新建一个普通java project，将原来开发标签库工程的src目录下的标签处理类全部拷贝过来；

b. 在工程下新建一个lib目录，把jsp和servlet两个JAR包(jsp-api.jar和servlet-api.jar)拷贝进来(在tomcat目录\lib下)；

c. 选中这两个JAR包，右击->build path->Add to path，变成两个"奶瓶状"即可；

d. 在工程下新建一个META-INF目录，将标签的配置文件(tld文件)考进来；

e. 将整个工程导出：export->选择java->JAR File->next->右边的classpath和project不用打钩，然后选择导出目录即可导出。

这样标签库的JAR包就打包好了。

再新建一个web project，将刚刚打包好的JAR包拷贝到WEB-INF\lib下，这样在WEB-INF下新建一个JSP文件，在该文件里就可以通过taglib导入刚刚的JAR包了，然后使用自己开发的标签了。

8.  JSTL常用标签库

1）<c:out>

<c:out>标签用于输出一段文本内容到pageContext对象当前保存的"out"对象中，即：将内容输出给浏览器。该标签有三个属性可选，value属性指定要输出的内容；escapeXml指定是否将<、>、&、`等特殊字符进行html编码转换后再进行输出，默认为true；default属性指定如果value属性的值为null时所输出的默认值。该标签主要用于escapeXml属性和default属性

2）<c:set>

<c:set>标签用于把某一个对象存在指定的域范围内，或者设置web域中的java.util.Map类型的属性对象或javaBean类型的属性对象的属性。有如下属性：

value:用于指定属性的值；

scope：用于指定属性所在的web域；

var：用于指定要设置的web域属性的名称；

target：用于指定要设置属性的对象，这个对象必须是javaBean对象或者java.util.Map对象；

property：用于指定当前为对象设置的属性名称。

<!-- c:set标签 ：向web域中存数据，向map或Bean中存数据-->
<c:set var="data" value="xxx" scope="page"/>
${pageScope.data }

<%
    Map map = new HashMap();
    request.setAttribute("map", map);
%>
<c:set property="data" value="yyy" target="${map }" />
${map.data }

<c:set property="name" value="eson_15" target="${person }"/>
${person.name }

3） <c:remove>

<c:remove>标签用于删除各种web域中的属性：

<c:remove var="varName" [scope="{page|request|session|application}"]/>

4）<c:if>

<c:if>标签可以判断是否执行标签体

<c:if test="${user==null}" var="result" scope="page">
    xxx
</c:if>

如果test中的表达式为真则执行标签体，另外将test的值保存在page域中，保存参数为result，可以通过${result}获取保存的值。

5）<c:choose>

标签用于构造条件判断语句

<c:choose>
    <c:when test="${count == 0}">
        对不起，没有符合您要求的记录
    </c:when>
    <c:otherwise>
        符合您要求的记录共有${count}条
    </c:otherwise>
</c:choose>

6）<c:forEach>

<c:forEach>标签用于对一个集合对象中的元素进行循环迭代操作，或者按指定的次数重复迭代执行标签体中的内容。它有如下属性：

var属性：指定当前迭代到的元素保存到page域中的属性名称；

items属性：将要迭代的集合对象；

begin属性：如果指定items属性，就从集合中的第begin个元素开始迭代，begin的索引值从0开始编号;如果没有指定items属性，就从begin指定的值开始迭代，直到end值结束。

step属性：指定迭代的步长。

<!-- c:forEach标签 -->
<c:forEach var="num" begin="1" end="10" step="1">
${num }  <!-- 输出1-10 -->
</c:forEach> <br>

<%
    List list = Arrays.asList("1","2");
    request.setAttribute("list", list);
%>
<c:forEach var="index" begin="0" end="${fn.length(list) }">
${list[index] }
</c:forEach>

<c:forEach var="index" items="${list}">
${index}
</c:forEach>

7）<c:param>标签

在JSP页面进行url的相关操作时，经常用在url地址后面附加一些参数。<c:param>标签可以嵌套在<c:import>、<c:url>或<c:redirect>标签内，为这些标签所使用的url地址附加参数。<c:param>标签在为一个url地址附加参数时，将自动对参数值进行url编码，例如，如果传递的参数为“中国”，则将其转换为"%d6%d0%b9%fa"后再附加到url地址后面，这也就是使用<c:param>标签的最大好处。如：<c:param
name="name" value="value"/>

<c:url>标签用于在JSP页面中构造一个url地址，其主要目的是实现url重写。url重写就是将会话标识号以参数形式附加在url地址后面（关于url重写，在总结session技术的时候有写到）。它有如下属性：

value属性：指定要构造的url；

var属性：指定将构造出的url结果保存到web域中的属性名称

scope属性：指定将构造出的url结果保存到那个web域中

<!-- c:url标签(重点) -->
<a href="<c:url value="/servlet/servletDemo1"/>">点点</a>

<c:url value="/servlet/servletDemo2" var="servletdemo2"><!-- 如果没有var，则会把地址直接打给浏览器 -->
    <c:param name="name" value="中国"/> <!-- 中国两个字已经被url编码了 -->
    <c:param name="password" value="我是一个"></c:param>
</c:url>
<a href="${servletdemo2}">点点</a>

<c:redirect>标签用于实现请求重定向。

url属性：指定要转发或重定向到的目标资源的url地址；

context：当要使用相对路径重定向到同一个服务器下的其他web应用程序中的资源时，context属性指定其他web应用程序的名称。

关于JSTL部分的内容暂时就总结到这吧，如有错误之处，欢迎留言指正~

_____________________________________________________________________________________________________________________________________________________

-----乐于分享，共同进步！

-----更多文章请看：http://blog.csdn.net/eson_15

时间： 2024-10-04 10:21:21

JSTL自定义标签的相关文章

JSTL自定义标签（三）

上篇讲解的是JSTL常用的核心标签,本篇介绍JSTL自定义标签的使用.还记得在学js的时候,我们学习了JQuery框架,同时学习了构造自己的js库,再去调用自己的js库,这就如同根据自己的需要些一个内聚性强的函数一样,我们创建一个函数后,再去调用这个函数.在学习J2ee规范JSTL标签这一节的时候,同样我们可以根据自己的需要构造自己的标签库,再去使用自己定义的这个标签. JSTL自带的标签功能时非常强大的,但是不能完全满足我们的需要,开发标签首先是需要开发标签对应的功能类,就和写函数一样,这个函

自己封装JSTL 自定义标签

第一步,做一个类,派生自SimpleTagSupport,"alt+/"选重写doTag()方法. public class TestTag extends SimpleTagSupport { private String outerTagName="p"; public void setOuterTagName(String outerTagName) { this.outerTagName = outerTagName; } private int count

超全面的JavaWeb笔记day13&lt;JSTL&amp;自定义标签&gt;

1.JSTL标签库(重点) core out set remove url if choose when otherwise forEach fmt formatDate formatNumber 2.自定义标签(理解) 步骤 标签处理类 tld文件 jsp中<%@taglib%> 处理类 实现SimpleTag接口 继承SimpleTagSupport类 有标签体的标签 不执行下面内容的标签 带有属性的标签 3.MVC设计模式(重点中的重点) M:模型 V:视图 C:控制器 4.Java三层

JavaWeb学习之JSTL自定义标签库的使用、JSTL自定义函数库（7）

一.自定义标签,步骤 * 确定需求 * <my:date /> 输出当前系统的时间 yyyy-MM-dd hh:mm:ss:SSS * 编写Java类 新建包名:com.yxl.tag,新建类MyDateTag,实现SimpleTag接口 * 只要与此接口有关的实现类,javax.servlet.jsp.tagext.JspTag * 需要实现具体的接口 * javax.servlet.jsp.tagext.SimpleTag,简单标签,JSP2.0**,选择这个 * javax.servle

JSTL自定义标签库 (二)

要定义自己的标签,首先写个java类,extends TagSupport  或者 implements Tag ,然后在类体里实现自己想要的方法,或者覆盖父类的方法. 我定义的MyTag代码如下: package com.xll.util; import java.io.IOException; import javax.servlet.jsp.JspException; import javax.servlet.jsp.JspWriter; import javax.servlet.jsp.

JSTL自定义标签 实现forEach循环支持集合.数组

java代码实现 tld配置 JSP页面代码

jsp的标签库和自定义标签

1.jstl标签库 JSP标准标签库(JSTL)是一个JSP标签集合,它封装了JSP应用的通用核心功能. JSTL支持通用的.结构化的任务,比如迭代,条件判断,XML文档操作,国际化标签,SQL标签. 除了这些,它还提供了一个框架来使用集成JSTL的自定义标签. 根据JSTL标签所提供的功能,可以将其分为5个类别. 核心标签 格式化标签 SQL 标签(过时) XML 标签(过时) JSTL 函数 1.1使用taglib指令导入标签库 ,除了JSP动作标签外,使用其他第三方的标签库都需要:  <%

Javaweb学习笔记6—EL表达式与JSTL及自定义标签

 前几天博客被黑了,导致博客登陆不上,把前几天应该发的东西的东西重新发一遍 今天来讲javaweb的第六阶段学习. EL表达式与JSTL及自定义标签是对上篇文章介绍的JSP的扩展,不能说是很重要的东西,但是也要了解. 老规矩,首先先用一张思维导图来展现今天的博客内容. ps:我的思维是用的xMind画的,如果你对我的思维导图感兴趣并且想看到你们跟详细的备注信息,请点击下载 另外:如果图看不清的话请右击---在新窗口中打开会清楚很多. 一.EL表达式 1,EL简介 Expression Lan

jstl的自定义标签

1)作用:当jsp的内置标签或者jstl不满足我们,这时需要自定义标签2)三个步骤:  需求: 使用自定义标签输出客户的ip地址SimpleTag接口的方法:doTag():执行标签的方法,由web服务器调用getParent(): 得到父标签.setJspBody(JspFragment jspBody)传入标签主体内容.由web服务器调用setJspContext(JspContext pc)传入PageContext.由web服务器调用setParent(JspTag parent) 传入