jstl 订阅
JSTL(Java server pages standarded tag library,即JSP标准标签库)是由JCP(Java community Proces)所制定的标准规范,它主要提供给Java Web开发人员一个标准通用的标签库,并由Apache的Jakarta小组来维护。开发人员可以利用这些标签取代JSP页面上的Java代码,从而提高程序的可读性,降低程序的维护难度。 展开全文
JSTL(Java server pages standarded tag library,即JSP标准标签库)是由JCP(Java community Proces)所制定的标准规范,它主要提供给Java Web开发人员一个标准通用的标签库,并由Apache的Jakarta小组来维护。开发人员可以利用这些标签取代JSP页面上的Java代码,从而提高程序的可读性,降低程序的维护难度。
信息
功    能
为JSP Web开发人员提供一个标准通用的标签库
外文名
JSP Standard Tag Library
简    称
JSTL
所属领域
计算机科学技术
中文名
JSP标准标签库
制定者
JCP
JSTL简介
JSTL的英文全称是JavaServer Pages Standard Tag Library,中文全称是JSP标准标识库。JSTL技术标准是由JCP(lava Community Process)组织的JSR052专家组发布,Apache组织将其列入Jakarta项目,Sun公司将JSTL的程序包加入互联网服务开发工具包内(Web Services Developer Pack(WSDP)),作为JSP技术应用的一个标准。JSTL标签是基于JSP页面的,这些标签可以插入在JSP代码中,本质上JSTL也是提前定义好的一组标签,这些标签封装了不同的功能,在页面上调用标签时,就等于调用了封装起来的功能。JSTL的目标是简化JSP页面的设计。对于页面设计人员来说,使用脚本语言操作动态数据是比较困难的,而采用标签和表达式语言则相对容易,JSTL的使用为页面设计人员和程序开发人员的分工协作提供了便利。JSTL标识库的作用是减少JSP文件的Java代码,使Java代码与HTML代码分离,所以JSTL标识库符合MVC设计理念。MVC设计理念的优势是将动作控制、数据处理、结果显示三者分离。
收起全文
精华内容
下载资源
问答
  • jstl

    2020-03-12 19:55:34
    jstl:jsp标准标签库 1:jstl使用: 导包:jstl.jar和standard.jar 导入标签库:<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“c” %> 2:jstl中常用标签: 通用标签,选择标签(if,choose),循环...

    jstl:jsp标准标签库

    1:jstl使用:

    导包:jstl.jar和standard.jar
    导入标签库:<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“c” %>

    2:jstl中常用标签:

    通用标签,选择标签(if,choose),循环标签(for)

    3:jstl的函数库:

    <%@ taglib uri=“http://java.sun.com/jsp/jstl/functions” prefix=“fn” %>

    4:jstl的格式化标签库:

    <%@ taglib uri=“http://java.sun.com/jsp/jstl/fmt” prefix=“fmt” %>

    展开全文
  • JSTL

    千次阅读 2019-02-03 21:19:55
    1.jstl是什么 java standard tag lib java标准标签库 由apche开发的 jsp标签,捐献给了sun公司。sun命名为jstl。 2.如何使用jstl (1)将jstl相关的jar文件拷贝到WEB-INF\lib下。 注:如果使用javaee5.0(包含...

    1.jstl是什么

    java standard tag lib  java标准标签库

    由apche开发的 jsp标签,捐献给了sun公司。sun命名为jstl。

    2.如何使用jstl

    (1)将jstl相关的jar文件拷贝到WEB-INF\lib下。

    注:如果使用javaee5.0(包含了jstl相关的jar文件)一般不需要再拷贝。

    若容器中没有自带包会报500错误。

    (2)使用taglib指令导入相应的标签。

    <%@taglib uri="http://www.jiaqi.com.cn/tag" prefix="c"%>

    uri是一个命名空间。

    prefix是命名空间的前缀(别名)。

    注:命名空间(namespace)是为了区分同名元素而设置的一个字符串。包名也是这个作用。

    3.jstl几个核心的标签

    (1)if标签,等价于java语言中if(){},类似于c语言中的 ifdef___endif

    <c:if test:=" " var="flag" scope="request"> 

    标签体

    </c:if>

    当test属性值为true时,容器会执行标签体的内容。

    test属性可以使用el表达式来计算。·用的较多。

    var属性用来指定绑定名称。用的较少。

    scope属性用来指定绑定的范围。可以是requset,session,applicaton, page(pagecontext)。用的较少。

    上文中则相当于执行了  request.setAttribute("flag")="test属性中el表达式的值";

    (2)choose标签,等价于java语言中的if()...elseif()...elseif()...语句

    <c:choose>

        <c:when test=" ">

        </c:when>

        <c:otherwise>

        </c:otherweise>

    </c:choose>

    when可以出现1次或者多次,表示一个分支,当test属性值为true时,会执行该分支。

    otherwise可以出现0次或1次,表示例外。

    (3)forEach标签,用来遍历集合或数组

    <c:forEach items=“” var=“ ” varStatus=" ">

    </c:forEach>

    items属性:用来指定要遍历的集合或者数组,可以使用el表达式。

    var属性:用来指定一个绑定名,绑定范围固定是pageContext。

    注:每次从集合或者数组中取一个元素,然后将其绑定到pageContext上,绑定名有var属性来指定。

    varStatus属性:用来指定一个绑定名称。绑定范围固定是pageContext,绑定值是一个特殊的对象,可获得当前遍历状态。该对象的属性有index(下标,从0开始),count(第几次遍历从1开始)。

    该对象提供了一些方法,用来获得当前遍历的状态。

    getIndex():获得当前遍历的元素的下标。

    getCount()获得当前是第几次遍历。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • jstl jstl jstl

    2011-05-15 17:12:57
    jstl jstl jstl jstl jstl
  • JSTL 标签大全详解

    万次阅读 多人点赞 2016-11-23 21:21:39
    (尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/53311722 ...一、JSTL标签介绍 1、什么是JSTL? 2、JSTL标签库: 3、使用taglib指令导入标签库: 4、core标签库常用标签:...

    (尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/53311722  冷血之心的博客)

    关注微信公众号(文强的技术小屋),学习更多技术知识,一起遨游知识海洋~

    目录

    一、JSTL标签介绍

    1、什么是JSTL?

    2、JSTL标签库:

    3、使用taglib指令导入标签库:

    4、core标签库常用标签:

    (1)out和set标签

    (2)remove标签

    (3)url标签:该标签会在需要重写URL时添加。

    (4)if标签:

    (5)choose标签:

    (6)forEach标签:

    5、fmt标签库常用标签:

    二、自定义标签

    1、自定义标签

    1.1步骤:

    1.2 SimpleTag接口介绍:

    标签的生命周期:

    1.3 标签库描述文件(TLD)

    1.4 使用标签

    2、自定义标签进阶

    2.1 继承SimpleTagSupport

    2.2 有标签体的标签

    2.3 不执行标签下面的页面内容

    2.4 带有属性的标签


    一、JSTL标签介绍

    1、什么是JSTL?

            JSTL是apache对EL表达式的扩展(也就是说JSTL依赖EL),JSTL是标签语言!JSTL标签使用以来非常方便,它与JSP动作标签一样,只不过它不是JSP内置的标签,需要我们自己导包,以及指定标签库而已!

           如果你使用MyEclipse开发JavaWeb,那么在把项目发布到Tomcat时,你会发现,MyEclipse会在lib目录下存放jstl的Jar包!如果你没有使用MyEclipse开发那么需要自己来导入这个JSTL的Jar包:jstl-1.2.jar。

    2、JSTL标签库:

    JSTL一共包含四大标签库:

    • core:核心标签库,我们学习的重点;
    • fmt:格式化标签库,只需要学习两个标签即可;
    • sql:数据库标签库,不需要学习了,它过时了;
    • xml:xml标签库,不需要学习了,它过时了。

    3、使用taglib指令导入标签库:

    除了JSP动作标签外,使用其他第三方的标签库都需要:

    • 导包;
    • 在使用标签的JSP页面中使用taglib指令导入标签库;

    下面是导入JSTL的core标签库:

    <%@ taglib prefix="c"uri="http://java.sun.com/jstl/core" %>
    • prefix="c":指定标签库的前缀,这个前缀可以随便给值,但大家都会在使用core标签库时指定前缀为c;
    • uri="http://java.sun.com/jstl/core":指定标签库的uri,它不一定是真实存在的网址,但它可以让JSP找到标签库的描述文件;

    4、core标签库常用标签:

    (1)out和set标签

    <c:out value=”aaa”/>

    输出aaa字符串常量

    <c:out value=”${aaa}”/>

    与${aaa}相同

    <c:out value=”${aaa}” default=”xxx”/>

    当${aaa}不存在时,输出xxx字符串

    <%

    request.setAttribute("a","<script>alert('hello');</script>");

    %>

    <c:out value="${a }" default="xxx" escapeXml="false" />

    当escapeXml为false,不会转换“<”、“>”。这可能会受到JavaScript攻击。

    <c:set var=”a” value=”hello”/>

        在pageContext中添加name为a,value为hello的数据。

    <c:set var=”a” value=”hello” scope=”session”/>

    在session中添加name为a,value为hello的数据。

    (2)remove标签

    <%

                       pageContext.setAttribute("a","pageContext");

                       request.setAttribute("a","session");

                       session.setAttribute("a","session");

                       application.setAttribute("a","application");

      %>

        <c: remove var="a"/>

        <c: out value="${a}" default="none"/>

    删除所有域中name为a的数据!
    <c:remove var="a" scope=”page”/>删除pageContext中name为a的数据 

    (3)url标签:该标签会在需要重写URL时添加。

    <c:url value="/"/>

         输出上下文路径:/项目名/

    <c:url value="/" var="a" scope="request"/>

        把本该输出的结果赋给变量a。范围为request

    <c:url value="/AServlet"/>

         输出:/项目名/AServlet

    <c:url value="/AServlet">

    <c:param name="username" value="abc"/>

    <c:param name="password" value="123"/>                   

         输出:/项目名/AServlet?username=abc&password=123

         如果参数中包含中文,那么会自动使用URL编码!                       

    (4)if标签:

    if标签的test属性必须是一个boolean类型的值,如果test的值为true,那么执行if标签的内容,否则不执行。

    <c:set var="a" value="hello"/>
    <c:if test="${not empty a }">
    	<c:out value="${a }"/>
    </c:if>
    

    (5)choose标签:

    choose标签对应Java中的if/else if/else结构。when标签的test为true时,会执行这个when的内容。当所有when标签的test都为false时,才会执行otherwise标签的内容。

    <c:set var="score" value="${param.score }"/>
    <c:choose>
    	<c:when test="${score > 100 || score < 0}">错误的分数:${score }</c:when>
    	<c:when test="${score >= 90 }">A级</c:when>
    	<c:when test="${score >= 80 }">B级</c:when>
    	<c:when test="${score >= 70 }">C级</c:when>
    	<c:when test="${score >= 60 }">D级</c:when>
    	<c:otherwise>E级</c:otherwise>
    </c:choose>
    

    (6)forEach标签:

    forEach当前就是循环标签了,forEach标签有多种两种使用方式:

    • 使用循环变量,指定开始和结束值,类似for(int i = 1; i <= 10; i++) {};
    • 循环遍历集合,类似for(Object o : 集合);

    循环变量:

    <c:set var="sum" value="0" /> 
    <c:forEach var="i" begin="1" end="10"> 
    	<c:set var="sum" value="${sum + i}" /> 
    </c:forEach>
    <c:out value="sum = ${sum }"/>
    <c:set var="sum" value="0" />
    <c:forEach var="i" begin="1" end="10" step ="2">
    	<c:set var="sum" value="${sum + i}" />
    </c:forEach>
    <c:out value="sum = ${sum }"/>
    

    遍历集合或数组方式:

    <%
    String[] names = {"zhangSan", "liSi", "wangWu", "zhaoLiu"};
    pageContext.setAttribute("ns", names);
    %>
    <c:forEach var="item" items="${ns }">
    	<c:out value="name: ${item }"/><br/>
    </c:forEach>
    

    遍历List:

    <%
    	List<String> names = new ArrayList<String>();
    	names.add("zhangSan");
    	names.add("liSi");
    	names.add("wangWu");
    	names.add("zhaoLiu");
    	pageContext.setAttribute("ns", names);
    %>
    <c:forEach var="item" items="${ns }">
    	<c:out value="name: ${item }"/><br/>
    </c:forEach>

    遍历Map:

    <%
    	Map<String,String> stu = new LinkedHashMap<String,String>();
    	stu.put("number", "N_1001");
    	stu.put("name", "zhangSan");
    	stu.put("age", "23");
    	stu.put("sex", "male");
    	pageContext.setAttribute("stu", stu);
    %>
    <c:forEach var="item" items="${stu }">
    	<c:out value="${item.key }: ${item.value }"/><br/>
    </c:forEach>
    

    forEach标签还有一个属性:varStatus,这个属性用来指定接收“循环状态”的变量名,例如:<forEach varStatus=”vs” …/>,这时就可以使用vs这个变量来获取循环的状态了。

    • count:int类型,当前以遍历元素的个数;
    • index:int类型,当前元素的下标;
    • first:boolean类型,是否为第一个元素;
    • last:boolean类型,是否为最后一个元素;
    • current:Object类型,表示当前项目。
    <c:forEach var="item" items="${ns }" varStatus="vs">
    	<c:if test="${vs.first }">第一行:</c:if>
    	<c:if test="${vs.last }">最后一行:</c:if>
    	<c:out value="第${vs.count }行: "/>
    	<c:out value="[${vs.index }]: "/>
    	<c:out value="name: ${vs.current }"/><br/>
    </c:forEach>
    

    5、fmt标签库常用标签:

          fmt标签库是用来格式化输出的,通常需要格式化的有时间和数字。

    格式化时间:

    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
    ......
    <%
    	Date date = new Date();
    	pageContext.setAttribute("d", date);
    %>
    <fmt:formatDate value="${d }" pattern="yyyy-MM-dd HH:mm:ss"/>
    

    格式化数字:

    <%
    	double d1 = 3.5;
    	double d2 = 4.4; 
    	pageContext.setAttribute("d1", d1);
    	pageContext.setAttribute("d2", d2);
    %>
    <fmt:formatNumber value="${d1 }" pattern="0.00"/><br/>
    <fmt:formatNumber value="${d2 }" pattern="#.##"/>
    

    介绍了JSTL中的常用标签,那可以定义自己的标签吗?

    答案是:可以。

     

    二、自定义标签

    1、自定义标签

    1.1步骤:

    其实我们在JSP页面中使用标签就等于调用某个对象的某个方法一样,例如:<c:if test=””>,这就是在调用对象的方法一样。自定义标签其实就是自定义类一样!

    • 定义标签处理类:必须是Tag或SimpleTag的实现类;
    • 编写标签库描述符文件(TLD);

      SimpleTag接口是JSP2.0中新给出的接口,用来简化自定义标签,所以现在我们基本上都是使用SimpleTag。

    Tag是老的,传统的自定义标签时使用的接口,现在不建议使用它了。

    1.2 SimpleTag接口介绍:

    SimpleTag接口内容如下:

    • void doTag():标签执行方法;
    • JspTag getParent():获取父标签;
    • void setParent(JspTag parent):设置父标签
    • void setJspContext(JspContext context):设置PageContext
    • void setJspBody(JspFragment jspBody):设置标签体对象;

    请记住,万物皆对象!在JSP页面中的标签也是对象!你可以通过查看JSP的源码,清楚的知道,所有标签都会变成对象的方法调用。标签对应的类我们称之为“标签处理类”!

    标签的生命周期:

    1、当容器(Tomcat)第一次执行到某个标签时,会创建标签处理类的实例;

    2、然后调用setJspContext(JspContext)方法,把当前JSP页面的pageContext对象传递给这个方法;

    3、如果当前标签有父标签,那么使用父标签的标签处理类对象调用setParent(JspTag)方法;

    4、如果标签有标签体,那么把标签体转换成JspFragment对象,然后调用setJspBody()方法;

    5、每次执行标签时,都调用doTag()方法,它是标签处理方法

    HelloTag.java

    public class HelloTag implements SimpleTag {
    	private JspTag parent;
    	private PageContext pageContext;
    	private JspFragment jspBody;
    	
    	public void doTag() throws JspException, IOException {
    		pageContext.getOut().print("Hello Tag!!!");
    	}
    	public void setParent(JspTag parent) {
    		this.parent = parent;
    	}
    	public JspTag getParent() {
    		return this.parent;
    	}
    	public void setJspContext(JspContext pc) {
    		this.pageContext = (PageContext) pc;
    	}
    	public void setJspBody(JspFragment jspBody) {
    		this.jspBody = jspBody;
    	}
    }
    

    1.3 标签库描述文件(TLD)

    标签库描述文件是用来描述当前标签库中的标签的!标签库描述文件的扩展名为tld,你可以把它放到WEB-INF下,这样就不会被客户端直接访问到了。

    hello.tld

    <?xml version="1.0" encoding="UTF-8"?>
    <taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
    	xmlns:xml="http://www.w3.org/XML/1998/namespace" 
    	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 ">
    
    	<tlib-version>1.0</tlib-version>
    	<short-name>ywq</short-name>
    	<uri>http://www.ywq.cn/tags</uri>
    	<tag>
    		<name>hello</name>
    		<tag-class>cn.ywq.tag.HelloTag</tag-class>
    		<body-content>empty</body-content>
    	</tag>
    </taglib>
    

    1.4 使用标签

    在页面中使用标签分为两步:

    • 使用taglib导入标签库;
    • 使用标签;
    <%@ taglib prefix="it" uri="/WEB-INF/hello.tld" %>
    ......
    <it:hello/>
    

    2、自定义标签进阶

    2.1 继承SimpleTagSupport

      继承SimpleTagSuppport要比实现SimpleTag接口方便太多了,现在你只需要重写doTag()方法,其他方法都已经被SimpleTagSuppport完成了。

    public class HelloTag extends SimpleTagSupport {
    	public void doTag() throws JspException, IOException {
    		this.getJspContext().getOut().write("<p>Hello SimpleTag!</p>");
    	}
    }
    

    2.2 有标签体的标签

    我们先来看看标签体内容的可选值:

    <body-content>元素的可选值有:

    • empty:无标签体。
    • JSP:传统标签支持它,SimpleTag已经不再支持使用<body-content>JSP</body-content>。标签体内容可以是任何东西:EL、JSTL、<%=%>、<%%>,以及html;
    • scriptless:标签体内容不能是Java脚本,但可以是EL、JSTL等。在SimpleTag中,如果需要有标签体,那么就使用该选项
    • tagdependent:标签体内容不做运算,由标签处理类自行处理,无论标签体内容是EL、JSP、JSTL,都不会做运算。这个选项几乎没有人会使用!

    自定义有标签体的标签需要:

    • 获取标签体对象:JspFragment jspBody = getJspBody();;
    • 把标签体内容输出到页面:jspBody.invoke(null);
    • tld中指定标签内容类型:scriptless。
    public class HelloTag extends SimpleTagSupport {
    	public void doTag() throws JspException, IOException {
    		PageContext pc = (PageContext) this.getJspContext();
    		HttpServletRequest req = (HttpServletRequest) pc.getRequest();
    		String s = req.getParameter("exec");
    		if(s != null && s.endsWith("true")) {
    			JspFragment body = this.getJspBody();
    			body.invoke(null);
    		}
    	}
    }
    

     

    <tag>
    		<name>hello</name>
    		<tag-class>cn.ywq.tags.HelloTag</tag-class>
    		<body-content>scriptless</body-content>
    	</tag>
    

     

     <itcast:hello>
         	<h1>哈哈哈~</h1>
        </itcast:hello>
    

    2.3 不执行标签下面的页面内容

      如果希望在执行了自定义标签后,不再执行JSP页面下面的东西,那么就需要在doTag()方法中使用SkipPageException。

    public class SkipTag extends SimpleTagSupport {
    	public void doTag() throws JspException, IOException {
    		this.getJspContext().getOut().print("<h1>只能看到我!</h1>");
    		throw new SkipPageException();
    	}
    }
    

     

    	<tag>
    		<name>skip</name>
    		<tag-class>cn.ywq.tags.SkipTag</tag-class>
    		<body-content>empty</body-content>
    	</tag>
      <itcast:skip/>
      <h1>看不见我!</h1>
    

    2.4 带有属性的标签

    一般标签都会带有属性,例如<c:iftest=””>,其中test就是一个boolean类型的属性。完成带有属性的标签需要:

    • 在处理类中给出JavaBean属性(提供get/set方法);
    • 在TLD中部属相关属性。
    public class IfTag extends SimpleTagSupport {
    	private boolean test;
    	public boolean isTest() {
    		return test;
    	}
    	public void setTest(boolean test) {
    		this.test = test;
    	}
    	@Override
    	public void doTag() throws JspException, IOException {
    		if(test) {
    			this.getJspBody().invoke(null);
    		}
    	}
    }
    

     

    <tag> 
    		<name>if</name> 
    		<tag-class>cn.ywq.IfTag</tag-class> 
    		<body-content>scriptless</body-content>
    		<attribute>
    			<name>test</name>
    			<required>true</required>
    			<rtexprvalue>true</rtexprvalue>
    		</attribute> 
    	</tag>
    

     

    <%
    	pageContext.setAttribute("one", true);
    	pageContext.setAttribute("two", false);
    %>
    <it:if test="${one }">xixi</it:if>
    <it:if test="${two }">haha</it:if>
    <it:if test="true">hehe</it:if>
    

           关于JSTL标签相关内容就到这里了,如果对你有帮助,记得点赞哦~欢迎大家关注我的博客,可以进群366533258一起交流学习哦~

     

    关注微信公众号(文强的技术小屋),学习更多技术知识,一起遨游知识海洋~

    展开全文
  • jstl and standard.zip
  • jstl-1.2.1 jar

    千次下载 热门讨论 2013-07-20 22:39:26
    jstl-1.2.1,之前的版本需要在服务器中配置一下,而且它分成了两个jar(jstl.jar和standard.jar)还有一个tld文件,而1.2已经不用配置了,直接把javax.servlet.jsp.jstl-1.2.1.jar和javax.servlet.jsp.jstl-api-1.2.1...
  • jstl jstl api jstl-api jstl-api.jar
  • jstl 遍历使用taglib标记 展示各项数据到select下拉框中
  • jstl-api jstlJSTL stands for JSP Standard Tag Library. JSTL is the standard tag library that provides tags to control the JSP page behavior. JSTL tags can be used for iteration and control statements,...

    jstl-api jstl

    JSTL stands for JSP Standard Tag Library. JSTL is the standard tag library that provides tags to control the JSP page behavior. JSTL tags can be used for iteration and control statements, internationalization, SQL etc. We will look into JSTL Tags in detail in this JSTL tutorial.

    JSTL代表JSP标准标记库 。 JSTL是标准的标记库,它提供用于控制JSP页面行为的标记。 JSTL标签可用于迭代和控制语句,国际化,SQL等。我们将在此JSTL教程中详细研究JSTL标签。

    Earlier we saw how we can use JSP EL and JSP Action Tags to write JSP code like HTML but their functionality is very limited. For example, we can’t loop through a collection using EL or action elements and we can’t escape HTML tags to show them like text in client side. This is where JSTL tags comes handy because we can do much more from JSTL tags.

    前面我们看到了如何使用JSP ELJSP动作标签来编写HTML之类的JSP代码,但是它们的功能非常有限。 例如,我们不能使用EL或action元素遍历一个集合,也不能逃脱HTML标签以在客户端将其显示为文本。 这是JSTL标签派上用场的地方,因为我们可以从JSTL标签做更多的事情。

    JSTL (JSTL)

    JSTL is part of the Java EE API and included in most servlet containers. But to use JSTL in our JSP pages, we need to download the JSTL jars for your servlet container. Most of the times, you can find them in the example projects of server download and you can use them. You need to include these libraries in your web application project WEB-INF/lib directory.

    JSTL是Java EE API的一部分,并包含在大多数Servlet容器中。 但是要在我们的JSP页面中使用JSTL,我们需要为您的servlet容器下载JSTL jar。 大多数时候,您可以在服务器下载的示例项目中找到它们,并可以使用它们。 您需要将这些库包含在Web应用程序项目WEB-INF / lib目录中。

    JSTL罐子 (JSTL jars)

    JSTL jars are container specific, for example in Tomcat, we need to include jstl.jar and standard.jar jar files in project build path. If they are not present in the container lib directory, you should include them into your application. If you have maven project, below dependencies should be added in pom.xml file or else you will get following error in JSP pages – eclipse Can not find the tag library descriptor for "https://java.sun.com/jsp/jstl/ core"

    JSTL jar是特定于容器的,例如在Tomcat中,我们需要在项目构建路径中包括jstl.jarstandard.jar jar文件。 如果它们在容器lib目录中不存在,则应将它们包含在应用程序中。 如果您有Maven项目,则应在pom.xml文件中添加以下依赖项,否则您将在JSP页面中收到以下错误-eclipse eclipse Can not find the tag library descriptor for "https://java.sun.com/jsp/jstl/ core"

    <dependency>
    	<groupId>jstl</groupId>
    	<artifactId>jstl</artifactId>
    	<version>1.2</version>
    </dependency>
    <dependency>
    	<groupId>taglibs</groupId>
    	<artifactId>standard</artifactId>
    	<version>1.1.2</version>
    </dependency>

    JSTL标签 (JSTL Tags)

    Based on the JSTL functions, they are categorized into five types.

    基于JSTL函数,它们分为五种类型。

    1. JSTL Core Tags: JSTL Core tags provide support for iteration, conditional logic, catch exception, url, forward or redirect response etc. To use JSTL core tags, we should include it in the JSP page like below.
      <%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>

      In this article, we will look into important JSTL core tags.

      JSTL核心标签 :JSTL核心标签提供对迭代,条件逻辑,捕获异常,URL,转发或重定向响应等的支持。要使用JSTL核心标签,我们应将其包括在JSP页面中,如下所示。

      在本文中,我们将研究重要的JSTL核心标签。

    2. JSTL Formatting and Localisation Tags: JSTL Formatting tags are provided for formatting of Numbers, Dates and i18n support through locales and resource bundles. We can include these jstl tags in JSP with below syntax:
      <%@ taglib uri="https://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>

      JSTL格式和本地化标签 :提供JSTL格式标签,用于通过语言环境和资源包格式化数字,日期和i18n支持。 我们可以使用以下语法在JSP中包含这些jstl标记:
    3. JSTL SQL Tags: JSTL SQL Tags provide support for interaction with relational databases such as Oracle, MySql etc. Using JSTL SQL tags we can run database queries, we include these JSTL tags in JSP with below syntax:
      <%@ taglib uri="https://java.sun.com/jsp/jstl/sql" prefix="sql" %>

      JSTL SQL标记 :JSTL SQL标记提供了与关系数据库(例如Oracle,MySql等)交互的支持。使用JSTL SQL标记,我们可以运行数据库查询,我们在JSP中将这些JSTL标记包括以下语法:
    4. JSTL XML Tags: JSTL XML tags are used to work with XML documents such as parsing XML, transforming XML data and XPath expressions evaluation. Syntax to include JSTL XML tags in JSP page is:
      <%@ taglib uri="https://java.sun.com/jsp/jstl/xml" prefix="x" %>

      JSTL XML标签 :JSTL XML标签用于处理XML文档,例如解析XML,转换XML数据和XPath表达式求值。 在JSP页面中包含JSTL XML标签的语法是:
    5. JSTL Functions Tags: JSTL tags provide a number of functions that we can use to perform common operation, most of them are for String manipulation such as String Concatenation, Split String etc. Syntax to include JSTL functions in JSP page is:
      <%@ taglib uri="https://java.sun.com/jsp/jstl/functions" prefix="fn" %>

      JSTL函数标签 :JSTL标签提供了许多我们可以用来执行常见操作的函数,其中大多数用于字符串操作,例如字符串连接,拆分字符串等。在JSP页面中包括JSTL函数的语法是:

    Note that all the JSTL standard tags URI starts with https://java.sun.com/jsp/jstl/ and we can use any prefix we want but it’s best practice to use the prefix defined above because everybody uses them, so it will not create any confusion.

    请注意,所有JSTL标准标签URI均以https://java.sun.com/jsp/jstl/开头,我们可以使用所需的任何前缀,但是最佳做法是使用上面定义的前缀,因为每个人都使用它们,因此它将不会造成任何混乱。

    JSTL核心标签 (JSTL Core Tags)

    JSTL Core Tags are listed in the below table.

    下表列出了JSTL核心标记。

    JSTL Core TagDescription
    <c:out>To write something in JSP page, we can use EL also with this tag
    <c:import>Same as <jsp:include> or include directive
    <c:redirect>redirect request to another resource
    <c:set>To set the variable value in given scope.
    <c:remove>To remove the variable from given scope
    <c:catch>To catch the exception and wrap it into an object.
    <c:if>Simple conditional logic, used with EL and we can use it to process the exception from <c:catch>
    <c:choose>Simple conditional tag that establishes a context for mutually exclusive conditional operations, marked by <c:when> and <c:otherwise>
    <c:when>Subtag of <c:choose> that includes its body if its condition evalutes to ‘true’.
    <c:otherwise>Subtag of <c:choose> that includes its body if its condition evalutes to ‘false’.
    <c:forEach>for iteration over a collection
    <c:forTokens>for iteration over tokens separated by a delimiter.
    <c:param>used with <c:import> to pass parameters
    <c:url>to create a URL with optional query string parameters
    JSTL核心标签 描述
    <c:out> 要在JSP页面中编写内容,我们也可以将此EL与该标签一起使用
    <c:import> 与<jsp:include>相同或包含指令
    <c:重定向> 将请求重定向到另一个资源
    <c:set> 在给定范围内设置变量值。
    <c:删除> 从给定范围中删除变量
    <c:catch> 捕获异常并将其包装到一个对象中。
    <c:if> 与EL一起使用的简单条件逻辑,我们可以使用它来处理<c:catch>中的异常
    <c:选择> 简单的条件标签,为互斥条件操作建立上下文,用<c:when>和<c:otherwise>标记
    <c:何时> <c:choose>的子标签,如果其条件评估为'true',则包括其主体。
    <c:否则> <c:choose>的子标签,如果其条件评估为'false',则包括其主体。
    <c:forEach> 用于集合的迭代
    <c:forTokens> 用于由定界符分隔的令牌的迭代。
    <c:param> 与<c:import>一起使用以传递参数
    <c:url> 创建带有可选查询字符串参数的URL

    JSTL教程 (JSTL Tutorial)

    Let’s see some of the JSTL core tags usages in a simple web application. Our project will include a Java Bean and we will create a list of objects and set some attributes that will be used in the JSP. JSP page will show how to iterate over a collection, using conditional logic with EL and some other common usage.

    让我们看看一个简单的Web应用程序中的一些JSTL核心标记用法。 我们的项目将包括一个Java Bean,我们将创建一个对象列表并设置一些将在JSP中使用的属性。 JSP页面将显示如何使用带有EL的条件逻辑和其他一些常见用法对集合进行迭代。

    JSTL教程– Java Bean类 (JSTL Tutorial – Java Bean Class)

    package com.journaldev.model;
    
    public class Employee {
    
    	private int id;
    	private String name;
    	private String role;
    	public Employee() {
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getRole() {
    		return role;
    	}
    	public void setRole(String role) {
    		this.role = role;
    	}
    
    }

    JSTL教程– Servlet类 (JSTL Tutorial – Servlet Class)

    package com.journaldev.servlet;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.servlet.RequestDispatcher;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import com.journaldev.model.Employee;
    
    @WebServlet("/HomeServlet")
    public class HomeServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
           
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		List<Employee> empList = new ArrayList<Employee>();
    		Employee emp1 = new Employee();
    		emp1.setId(1); emp1.setName("Pankaj");emp1.setRole("Developer");
    		Employee emp2 = new Employee();
    		emp2.setId(2); emp2.setName("Meghna");emp2.setRole("Manager");
    		empList.add(emp1);empList.add(emp2);
    		request.setAttribute("empList", empList);
    		
    		request.setAttribute("htmlTagData", "<br/> creates a new line.");
    		request.setAttribute("url", "https://www.journaldev.com");
    		RequestDispatcher rd = getServletContext().getRequestDispatcher("/home.jsp");
    		rd.forward(request, response);
    	}
    
    }

    JSTL教程– JSP页面 (JSTL Tutorial – JSP Page)

    home.jsp code:

    home.jsp代码:

    <%@ page language="java" contentType="text/html; charset=US-ASCII"
        pageEncoding="US-ASCII"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
    <title>Home Page</title>
    <%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c" %>
    <style>
    table,th,td
    {
    border:1px solid black;
    }
    </style>
    </head>
    <body>
    <%-- Using JSTL forEach and out to loop a list and display items in table --%>
    <table>
    <tbody>
    <tr><th>ID</th><th>Name</th><th>Role</th></tr>
    <c:forEach items="${requestScope.empList}" var="emp">
    <tr><td><c:out value="${emp.id}"></c:out></td>
    <td><c:out value="${emp.name}"></c:out></td>
    <td><c:out value="${emp.role}"></c:out></td></tr>
    </c:forEach>
    </tbody>
    </table>
    <br><br>
    <%-- simple c:if and c:out example with HTML escaping --%>
    <c:if test="${requestScope.htmlTagData ne null }">
    <c:out value="${requestScope.htmlTagData}" escapeXml="true"></c:out>
    </c:if>
    <br><br>
    <%-- c:set example to set variable value --%>
    <c:set var="id" value="5" scope="request"></c:set>
    <c:out value="${requestScope.id }" ></c:out>
    <br><br>
    <%-- c:catch example --%>
    <c:catch var ="exception">
       <% int x = 5/0;%>
    </c:catch>
    
    <c:if test = "${exception ne null}">
       <p>Exception is : ${exception} <br>
       Exception Message: ${exception.message}</p>
    </c:if>
    <br><br>
    <%-- c:url example --%>
    <a href="<c:url value="${requestScope.url }"></c:url>">JournalDev</a>
    </body>
    </html>

    Now when we run application with URL https://localhost:8080/JSTLExample/HomeServlet, we get response as in below image.

    现在,当我们使用URL https://localhost:8080/JSTLExample/HomeServlet运行应用程序时,我们将收到如下图所示的响应。

    In above JSTL example, we are using c:catch to catch the exception within the JSP service method, it’s different from the JSP Exception Handling with error pages configurations.

    在上面的JSTL示例中,我们使用c:catch来捕获JSP服务方法中的异常,这与具有错误页面配置的JSP异常处理不同。

    That’s all for a quick roundup of JSTL tags and example of JSTL core tags usage.

    这就是快速汇总JSTL标签和JSTL核心标签用法的示例。

    Reference: JSTL Wikipedia Page

    参考: JSTL Wikipedia页面

    翻译自: https://www.journaldev.com/2090/jstl-tutorial-jstl-tags-example

    jstl-api jstl

    展开全文
  • JSTL函数JSTL函数

    2009-11-20 02:57:30
    JSTL函数JSTL函数JSTL函数JSTL函数JSTL函数JSTL函数JSTL函数JSTL函数
  • JSTL标签JSTL标签

    2009-05-19 10:25:06
    JSTL标签JSTL标签JSTL标签JSTL标签JSTL标签JSTL标签JSTL标签JSTL标签JSTL标签JSTL标签JSTL标签JSTL标签
  • jstl

    2015-09-10 23:39:22
    jstl
  • jstl标签详解jstl标签详解jstl标签详解jstl标签详解jstl标签详解jstl标签详解jstl标签详解
  • JSTL常用标签

    万次阅读 2020-05-31 20:44:42
    JSTL标签库,是一个展示后台传输过来数据的标签库 jar包版本:jstl.jar jsp页面引入; <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> <%@ taglib prefix="fmt" uri=...
  • JSTL 标签

    2014-10-07 21:07:52
    JSTL标签
  • 由于上传资源只能提供1个压缩包文件,所以把两套版本的jar包放在一起了,包括jdk8+tomcat9版本以下使用JSTL包和高版本的1.2版JSTL包,可以根据自己需要选择
  • JSTL表达式

    2018-03-07 14:22:37
    jstl描述及其标签列表及其应用。。。。。。。。。。。。。
  • 自定义JSTL

    2016-08-08 00:13:13
    自定义jstl,打jar包使用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 129,086
精华内容 51,634
关键字:

jstl