首页 > 其他分享> > EL与JSTL

EL与JSTL

2022-06-24 20:37:23 作者：互联网

一、EL

（一）知识点1： EL表达式的功能

1．什么是EL表达式

Expression Language 表达式语言

2．EL使用场合

在JSP使用,服务器会对其进行解析翻译，生成相应的Java代码.

3．EL的作用

在JSP页面输出动态内容，可以替代JSP中的表达式元素<%=%>

（二）知识点2： EL表达式的一般格式

以${开始，以}结束
${EL表达式}

（三）知识点3： EL表达式的内置对象

为了能够方便地输出数据，EL提供了11个内置对象

2个内置对象为了方便输出请求参数： param/paramValues；
4个内置对象为了方便输出各个范围的属性： pageScope/ requestScope /sessionScope /applicationScope【使用较多，知识点4单独学习】
2个与请求头有关的内置对象：header/headerValues
2个其他内置对象：cookie/initParam
1个特殊的内置对象pageContext

1．内置对象param

（1）语法

用来输出请求参数的值，格式为${param.请求参数名字}

（2）例子

使用表达式：<%=request.getParameter("name")%><br>
使用EL：${param.name}<br>
结论:使用EL简单

（3）课堂练习

①目标：使用param
②步骤
- 1）创建jsp
- 2）在jsp使用EL接收请求参数
- 3）在浏览器地址栏给jsp传递请求参数

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        输出表达式：<%=request.getParameter("name")%><br>
        el表达式：${param.name}<br>
    </body>
</html>

2．内置对象paramValues：用来获取一对多的参数值，返回一个数组

（1）语法

${paramValues.请求参数名称[索引]}
取得同名参数的某一个索引的值

（2）例子:

比如某请求参数是通过checkbox传递的，名字为hobbies，要输出所有hobbies值中的第一个值，可以使用如下两种方式：
使用表达式：<%=request.getParameterValues("hobbies")[0]%>
使用EL：${paramValues.hobbies[0]}

（3）课堂练习

①目标：${paramValues.请求参数名称[索引]}取得同名参数的值

②步骤

1）jsp form checkbox hobbies

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <form action="el/get_hobby.jsp">
            爱好:
            <input type="checkbox" name="hobbies" value="吃"/>吃
            <input type="checkbox" name="hobbies" value="喝"/>喝
            <input type="checkbox" name="hobbies" value="玩"/>玩
            <input type="checkbox" name="hobbies" value="乐"/>乐<br/>
            <input type="submit" value="提交"/>
        </form>
    </body>
</html>

2）提交到另一个jsp,接收同名的请求参数

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        使用java脚本表达式接收:<%=request.getParameterValues("hobbies")[0]%><br/>
        使用EL接收:${paramValues.hobbies[1]}
    </body>
</html>

3．内置对象header：用来输出某一个请求头的值，

${header.请求头名字}

4．内置对象headerValues

如果某个请求头的值有多个，则使用headerValues返回一个数组
${headerValues.请求头名字[index]}

5．内置对象cookie：用来获取cookie的值

${cookie.名字.value} 取得是cookie的值
${cookie.名字.name} 取得是cookie的名字

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        header.accept：${header.accept}<br>
        headerValues.cookie[0]：${headerValues.cookie[0]}<br>
        cookie.JSESSIONID.value：${cookie.JSESSIONID.value}<br>
        cookie.JSESSIONID.name：${cookie.JSESSIONID.name}<br>
    </body>
</html>

6．内置对象initParam：用来输出上下文参数

${initParam.上下文参数的名字}

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>name</param-name>
        <param-value>kelly</param-value>
    </context-param>
</web-app>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        获取上下文参数(initParam.name)：${initParam.name}<br>
    </body>
</html>

获取上下文参数(initParam.name)：kelly

7．内置对象pageContext

（1）语义

EL中的pageContext对象可以调用PageContext类中所有符合规范的getXxx方法

（2）语法

${pageContext.xxx} xxx代表PageContext类的getXxx()方法将首字母小写的名字
表示调用pageContext对象的getXxx()方法
${pageContext.request.contextPath}取得工程的路径
<base href="${pageContext.request.contextPath}/">设置jsp的基准路径

（3）例子

如PageContext类中有如下方法：public abstract ServletRequest getRequest(), 可以通过如下EL调用该方法：
${pageContext.request}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        获取上下文路径(输出表达式)：<%=request.getContextPath()%><br>
        获取上下文路径(el)：${pageContext.request.contextPath}<br>
        获取请求对象：${pageContext.request}<br/>
        获取请求的地址：${pageContext.request.remoteAddr}<br/>
    </body>
</html>

（四）知识点4： EL表示式获取数据的作用域检索顺序

1．获取属性有关的内置对象有4个

pageScope：页面范围

requestScope：请求范围

sessionScope：会话范围

applicationScope：上下文范围

2．不写范围

（1）语法

${变量名.属性名}

（2）检索顺序

默认的访问顺序：pageScope→requestScope→sessionScope→applicationScope
当不指定范围时，例如，${user.pwd}，将自动从pageScope开始查找，直到applicationScope，
如果在某一范围找到,直接显示,不再找了
如果没查到，则什么也不显示

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <%
            pageContext.setAttribute("name", "a");
            request.setAttribute("name", "b");
            session.setAttribute("name", "c");
            application.setAttribute("name", "d");
        %>
        ${name} <br/>
        ${age}
    </body>
</html>

（五）知识点5：强制使用某个作用域的属性

1．写范围

精确定位,使用pageScope/requestScope/sessionScope/applicationScope中的某一个内置对象获取属性时，则是强制使用该作用域的属性

（1）语法

${范围.变量名.属性名}

范围是指下面的其中的一个

pageScope：页面范围

requestScope：请求范围

sessionScope：会话范围

applicationScope：上下文范围

（2）检索顺序

精确定位指定范围的属性的值

如果查到显示

如果没查到，则什么也不显示

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/"/>
    </head>
    <body>
        <%
            //四个域中同一属性名，四个不同的属性值
            pageContext.setAttribute("name", "zs");
            request.setAttribute("name", "lis");
            session.setAttribute("name", "wangwu");
            //application.setAttribute("name","zhaoliu");
        %>
        <%--没有指定域，查找顺序：pageContext->request->session->application--%>
        ${name}<br/>
        ${age}<br/>
        session域中获取name值：${sessionScope.name}<br/>
        <%--指定域中查找，如果找不到就显示空--%>
        application域中获取name值：${applicationScope.name}<br/>
    </body>
</html>

（六）知识点6： EL运算符

1．算术运算符

+，实现加法运算；

- 实现减法运算；

* 实现乘法运算；

/或div实现除法运算；

%或mod实现求模运算

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        ${10+2} ${10-2}${10*2}${10/2}${10%3}
    </body>
</html>

12 8 20 5.0 1

2．比较运算符(6种)

有6种比较运算符，可以对值进行比较，返回值为true或fasle

== 或eq表示等于

!= 或ne表示不等于

< 或lt表示小于

> 或gt表示大于

<= 或le表示小于等于

>= 或ge表示大于等于

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        ${10==2} ${10!=2} ${10>2} ${10<2} ${10>=2} ${10<=2} ${10 eq 2}
    </body>
</html>

false true true false true false false

3．逻辑运算符

EL中提供了3个逻辑运算符，可以对boolean类型的值进行运算，返回值为true或false。

（1）&&或and表示交集，两个值都是true才返回true。

（2）||或or表示并集，两个值只要有一个是true，即返回true。

（3）!或not表示非

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        ${1==2 && 2==3} ${1==2 || 2==3} ${!true}
    </body>
</html>

false false false

4．其他运算符

（七）知识点7： EL表达式的集合运算符等特殊运算符

1．集合运算符

使用[]指定索引的方式可以获取数组或List中的元素

（1）语法

${范围.集合变量[index].属性名}

返回请求范围内商品列表集合的第一个商品的名称：${requestScope.productsList[0].productName}

（2）课堂练习

①目标

使用EL取得集合中的某一元素

②步骤

1）创建一个集合

2）将集合放到request作用域

3）在页面使用EL取得集合中第2个元素的值

<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="com.tjetc.entity.User" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <%
            //创建一个集合
            List<User> users = new ArrayList<>();
            //将数据放入集合
            users.add(new User(1L, "a", "111"));
            users.add(new User(2L, "b", "222"));
            users.add(new User(3L, "c", "333"));
            users.add(new User(4L, "d", "444"));
            //将集合放到request作用域
            request.setAttribute("lists", users);
        %>
        <%--在页面使用EL取得集合中第2个元素的值 --%>
        ${lists[1].username}
        <div>${empty lists}</div>
        <%--true--%>
        <div>${empty a}</div>
        <%--三目运算符输出结果--%>
        <div>${2>1?"大于":"不大于"}</div>
        <%--()改变优先级--%>
        <div>${(1+2)*(2+3)}</div>
    </body>
</html>

2．empty运算符：

（1）${empty 普通变量名}语法

从pageScope->requestScope->sessionScope->applicationScope找,如果找到值!=null说明不空,返回false,值为null或者””,返回true

如果找不到,说明没有该变量,值为null,返回true.

判断值是否为null，如果是null，返回true，否则返回false。

（2）${empty 集合变量名}

从pageScope->requestScope->sessionScope->applicationScope找,如果找到

如果集合.size()==0,集合没有元素,认为是空的,返回true
如果集合.size()>0,集合有元素,认为是非空的,返回false

如果找不到,说明没有该变量,值为null,返回true.

3．关系运算符(三目)：

${A?B:C}如果A为true，则执行B，如果A为false，则执行C。

4．()运算符：

通过（）可改变优先级

（八）总结

2.什么是EL?

Expression Language 表达式语言

3.EL使用场合

JSP,服务器解析翻译生成java代码

4.EL作用?

在JSP页面输出动态内容,代替java脚本表达式

5.EL语法格式

${EL表达式}

6.EL内置对象?

EL有11个内置对象

param paramValues

pageScope requestScope sessionScope applicationScope

header headerValues

cookie initParam

pageContext

1.param

1.语法:${param.请求参数名}

2.例子:${param.name}

2.paramValues

1.语法:${paramValues.请求参数名[index]}

2例子:${paramValues.hobbies[0]}

3.header 输出某一个请求头的值

1.语法:${header.请求头名字}

2.例子:${header.accept}

4.headerValues

1.语法:${headerValues.请求头名字[index]}

2.例子:${headerValues.cookie[0]}

5.cookie

1.语法:${cookie.名字.value}

2.例子:${cookie.JSESSIONID.value}

6.initParam

1.语法:${initParam.上下文参数的名字}

2.例子:${initParam.name}

<context-param>

<param-name>name</param-name>

<param-value>wangwu</param-value>

</context-param>

7.pageContext

1.${pageContext.request.contextPath}得到工程路径

8~11 4大作用域

pageScope

requestScope

sessionScope

applicationScope

1.不写作用域

语法:${变量名.属性名}

从pageScope->requestScope->sessionScope->applicationScope找

1.在某一范围找到,就直接显示,不再找了

2.如果没找到,就什么都不显示

2.强制使用某一范围

语法:${范围.变量名.属性名}

1.精确使用某一范围找

1.在某一范围找到,就直接显示

2.如果没找到,就什么都不显示

7.EL运算符

1.算术运算符 5中

+-*/%

2.比较运算符 6种

1.== eq

2.!= ne

3.> gt

4.< lt

5.>= ge

6.<= le

3.逻辑运算符

1.与 && and

2.或 || or

3.非 ! not

4.集合和特殊运算符

1.${范围.集合变量名[index].属性名}

2.empty

1.${empty 普通变量}

1.从作用域找变量,找到变量值!=null ,返回 false,否则返回true

2.没找到返回true

2.${empty 集合变量}

1.如果作用域未找到,返回true

2.否则集合没有值返回true 否则返回false

3.关系运算符(三目)

${A?B:C}

4.优先级

${(1>2) || (3<2)}

二、JSTL

1.1.什么是JSTL

JSTL :Jsp Standard Tag Library Jsp 标准标签库.

1.2.JSTL标签库的作用

用java类实现动态的功能.

包含:标签库处理器类+tld文件:

简化jsp文件,不用写大量的java脚本
标签可以重复使用,利于维护

1.3.JSTL结构

标签处理器类

标签描述符文件:tld文件

tld:Tag Library Descriptor 标签库描述符

（一）课堂练习

1.4.使用JSTL标签

1、Maven的xml加入依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

2、jsp引入taglib指令左手按Alt不放,右手在jsp文件要引入的地方连续按2次/

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

3、<c:标签名属性名=”值”>

4、案例

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <%
            int a = 10;
            request.setAttribute("a", a);
        %>
        ${a}<br/>
        <c:out value="${a}"></c:out>
    </body>
</html>

1.5.属性相关的标签

1.<c:set var=”属性名” value=”属性值” scope=”page|request|session|application”>

作用向指定作用域范围设置属性值
相当于<%request.setAttribute(“属性名”,属性值);%>
scope属性是可省略的,如果不设置scope属性默认的作用域是page页面作用域

2.<c:remove var=”属性名”>

从指定的作用域删除属性

指定scope属性,从指定的作用域删除属性.

scope属性是可省略的,如果不设置scope属性它会从小到大:pageScope->requestScope->sessionScope->applicationScope找属性,找到就删除,直到把找到的全部删除.

案例:

(1)不设置scope属性，把找到的全部删除 <c:remove var="age"/>

(2)设置scope属性 <c:remove var="age"/ scope="request">

1.6.3.if标签

1、语法:

<c:if test=”条件表达式”>

标签体

</c:if>

2、说明: if标签的test属性里的条件表达式结果是true或者是false的布尔值,根据布尔值确定是否执行标签体

1. 如果条件表达式结果是true,则执行标签体
2. 否则不执行标签体

3、案例:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <c:if test="${not empty a}">
            <c:out value="${a}"></c:out>
        </c:if>
    </body>
</html>

1.7.choose when otherwise标签

1、语法:

<c:choose>

          <c:when test=”条件表达式1”>

                     标签体

          </c:when>

        <c:when test=”条件表达式2”>

                     标签体

          </c:when>

<c:when test=”条件表达式3”>

                     标签体

     </c:when>

...

<c:otherwise>

     标签体

</c:otherwise>

</c:choose>

说明: 每个when标签的test属性里的条件表达式结果是true或者是false的布尔值,根据布尔值确定是否执行标签体,相当于if/else if/else结构,更像switch case
1. 如果条件表达式结果是true,则执行标签体
2. 否则不执行标签体
课堂练习案例:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <%--<c:if test="${not empty a}">
            <c:out value="${a}"></c:out>
        </c:if>--%>
        <%--把请求参数score的值放到pagecontext作用域里 --%>
        <c:set var="score" value="${param.score}"></c:set>
        ${score}
        <%--根据分数显示级别A~E级,如果不在0~100范围,提示分数错误 --%>
        <c:choose>
            <c:when test="${empty score}">分数为空</c:when>
            <c:when test="${score<0 || score>100}">分数错误</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>
    </body>
</html>

1.8.forEach标签

语法: 替代java的循环如：for(String s:strs){}

<c:forEach items=”${集合变量名}” var=”临时变量名” begin=”索引” end=”索引” step=”步长” varStatus=”状态变量名”>

标签体:${ 临时变量名}

</c: forEach >

说明:
1. items放的是集合,可以从四大作用域之一取得,即可以使用EL表达式,${存储在作用域的集合变量名}
2. var=”临时变量名”, forEach标签处理器会循环遍历集合,对于遍历到的当前项会存储到pageContext作用域的属性名字是var的临时变量名,值是遍历到的当前项
3. 标签体取得就是临时变量名所存储的遍历到的当前项值.
4. begin从哪个索引位置开始循环,索引是从0开始
5. end到哪个索引位置结束循环,索引是从0开始
6. step:步长,代表每次走几个
7. varStatus:状态变量,属性有:
  1. index:迭代的索引,是从0开始
  2. count:迭代的次数,是从1开始
  3. first:当前是否是第一项 true fasle
  4. last:当前是否是最后一项 true false
  5. current:当前项

案例1:

package com.tjetc.entity;
public class User {
    private Long id;private String username;private String password;
    public User(Long id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
    public Long getId() {return id; }
    public void setId(Long id) {this.id = id;}
    public String getUsername() { return username;}
    public void setUsername(String username) {this.username = username; }
    public String getPassword() {return password; }
    public void setPassword(String password) {this.password = password;}
}

package com.tjetc.controller;
import com.tjetc.entity.User;
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 java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@WebServlet("/user/list")
public class UserListServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        List<User> users = new ArrayList<>();
        users.add(new User(1L, "a", "111"));
        users.add(new User(2L, "b", "222"));
        users.add(new User(3L, "c", "333"));
        users.add(new User(4L, "d", "444"));
        req.setAttribute("users", users);
        req.getRequestDispatcher("/jstl/user_list.jsp").forward(req, resp);
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
       <table border="1" cellspacing="0" cellpadding="1">
           <tr>
               <td>编号</td>
               <td>用户名</td>
               <td>密码</td>
           </tr>
           <%--遍历request域中的users 生成表格--%>
           <c:forEach items="${users}" var="user">
               <tr>
                   <td>${user.id}</td>
                   <td>${user.username}</td>
                   <td>${user.password}</td>
               </tr>
           </c:forEach>
       </table>
    </body>
</html>

案例2:

<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <%
            List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            pageContext.setAttribute("list", list);
            pageContext.setAttribute("s", "b");
        %>
        <c:forEach items="${list}" var="s">
            ${s}
        </c:forEach>
    </body>
</html>

<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <%
            List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            pageContext.setAttribute("list", list);
            pageContext.setAttribute("s", "b");
        %>
        <c:forEach items="${list}" var="s" begin="0" end="3" step="1" varStatus="st">
                ${st.index}--${st.count}--${st.first}--${st.last}--${st.current}-- ${s}  <br/>
        </c:forEach>
    </body>
</html>

1.8.1课堂案例:forEach

从请求参数设置页码:url?pages=17,用forEach实现分页页码的展示:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

实现效果:

<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <c:forEach begin="1" end="${param.pages}" var="p">${p} </c:forEach>
    </body>
</html>

<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <c:forEach begin="0" end="${param.pages}" var="p" step="5" >
            ${p}
        </c:forEach>
    </body>
</html>

1.9.forTokens标签

语法:

<c:forTokens items=”${字符串变量名}” delims=”分隔符” var=”临时变量名”>

标签体:${ 临时变量名}

</c:foTokens>

说明:
1. items放的是字符串变量名, 也可以直接写字符串,可以从四大作用域之一取得,即可以使用EL表达式,${存储在作用域的字符串变量名}
2. var=”临时变量名”, forToken标签处理器会循环遍历用分隔符分割出来的数组集合,对于遍历到的当前项会存储到pageContext作用域的属性名字是var的临时变量名,值是遍历到的当前项
3. 标签体取得就是临时变量名所存储的遍历到的当前项值.
案例:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <%
            pageContext.setAttribute("s", "a,b,c,d,e,f");
           /* String s="a,b,c,d";
           String[] ss=s.split(",");
           pageContext.setAttribute("token","b");
           */
        %>
        <c:forTokens items="${s}" delims="," var="str">
            ${str}
        </c:forTokens>
    </body>
</html>

格式化fmt标签

语法:

<fmt:formatDate value=”${日期变量}” pattern=”日期时间模式字符串”></ fmt:formatDate>

说明:
1. 日期变量可以从作用域取得
2. 日期时间模式字符串按照Java的模式字符串标准
3. <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
案例:

<%@ page import="java.util.Date" %>
<%@ page import="java.time.LocalDateTime" %>
<%@ page import="java.time.LocalDate" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<html>
    <head>
        <title>Title</title>
        <base href="<%=request.getContextPath()%>/">
    </head>
    <body>
        <%
            Date now = new Date();
            request.setAttribute("now",now);
            Date date=new Date();
            pageContext.setAttribute("date", date);
        %>
        <fmt:formatDate value="${date}" pattern="yyyy-MM-dd"/>
        <fmt:formatDate value="${now}" pattern="yyyy/MM/dd"/>
    </body>
</html>

总结

1.什么是JSTL

Jsp Standard Tag Library Jsp标准标签库

2.JSTL的作用

0.用java类实现动态的功能.

1.简化jsp文件,不用写大量的java脚本

2.标签可以重复使用,利于维护

3.JSTL结构

1.标签库描述文件.tld

2.标签处理器类

4.tld文件的结构

1.uri:tld文件的唯一标识

2.tag 标签元素

1.name:标签的名称

2.tag-class:标签处理器类

3.body-content:标签体内容

4.attribute标签的属性

1.name:属性名称

2.required:属性是否省略,true:不能省略 false:可以省略

3.rtexprvalue:是否使用动态表达式,true:可以使用 false:不可以使用

5.使用jstl标签的步骤

1.mavn的pom

2.<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

3.<c:标签名属性名="值"/>

4.<c:out value="${a}"></c:out>

6.set标签

1.语法:

<c:set var="属性名" value="属性值" scope="page|request|session|application"/>

2.作用:

向作用域添加属性名和值

3.scope

1.指定scope,会向指定的作用域添加属性名和值

2.如果省略scope,默认会向page作用域添加属性和值

7.remove标签

1.语法:

<c:remove var="属性名" scope="page|request|session|application"/>

2.作用:

从作用域删除属性

3.scope

1.指定scope,会从指定的作用域删除属性

2.如果省略scope,会从4个作用域从小到大依次寻找,找到就删除,直到全部删除为止.

8.if

1.语法:

<c:if test="条件表达式"/>

if标签体

</c:if>

2.作用:

1.当条件表达式是true,则执行if标签体

2.否则,就不执行if标签体

3.例子:

1.<c:if test="true">

if标签体

</c:if>

2.<c:if test="${1==1}">

if标签体

</c:if>

<c:set var="a" value="1"></c:set>

<c:if test="${not empty a}">

if标签体

</c:if>

9.choose when otherwise

1.语法:

<c:choose>

<c:when test="条件表达式">

标签体

</c:when>

<c:when test="条件表达式">

标签体

</c:when>

<c:when test="条件表达式">

标签体

</c:when>

...

<c:otherwise>

标签体

</c:otherwise>

</c:choose>

2.if else if else switch case

10.forEach

1.语法

<c:forEach items="${集合变量名}" var="临时变量名" begin="索引" end="索引" step="步长" varStatus="状态变量">

${临时变量名}

</c:forEach>

2.说明:

1.items:${集合变量名}取得存储在作用域里的集合值,可以对集合进行遍历

2.对于遍历的每一项放到页面作用域的属性名为临时变量名的属性中

3.可以通过在标签体使用${临时变量名}从页面作用域里取得当前循环遍历到的值,显示在页面上

4.begin:循环从哪个索引开始取数据,索引从0开始

5.end:循环到哪个索引结束,索引从0开始

6.step:步长,每次走几个,默认是1,可以设置多个

7.varStatus:状态变量,有5个属性

1.index:代表迭代的索引,从0开始

2.count:代表迭代的次数,从1开始

3.first:当前是否是第一项,是true,否则false

4.last:当前是否是最后一项,是true,否则是false

5.current:当前项

11.forTokens

1.语法

<c:forTokens items="${变量名}" delims="分隔符" var="临时变量名">

${临时变量名}

</c:forTokens>

2.说明:

a)items放的是字符串变量名, 也可以直接写字符串,可以从四大作用域之一取得,即可以使用EL表达式,${存储在作用域的字符串变量名}

b)var=”临时变量名”, forToken标签处理器会循环遍历用分隔符分割出来的数组集合,对于遍历到的当前项会存储到pageContext作用域的属性名字是var的临时变量名,值是遍历到的当前项

c)标签体取得就是临时变量名所存储的遍历到的当前项值.

3.例子

request.setAttribute("s","a,b,c,d");

<c:forTokens items="${s}" delims="," var="token">

${token}

</c:forTokens>

12.fmt:formatDate

1.语法

<fmt:formatDate value="${d}" pattern="yyyy-MM-dd HH:mm:ss">

2.说明:

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

2.pattern使用java的日期时间模式字符串

3.例子

Date d=new Date();

request.setAttribute("d",d);

<fmt:formatDate value="${d}" pattern="yyyy-MM-dd HH:mm:ss">

标签：EL,作用域,标签,JSTL,变量名,true,属性
来源： https://www.cnblogs.com/seventeen9588/p/16381511.html

EL与JSTL

一、EL

（一）知识点1： EL表达式的功能

1．什么是EL表达式

2．EL使用场合

3．EL的作用

（二）知识点2： EL表达式的一般格式

（三）知识点3： EL表达式的内置对象

1．内置对象param

（1）语法

（2）例子

（3）课堂练习

2．内置对象paramValues：用来获取一对多的参数值，返回一个数组

（1）语法

（2）例子:

（3）课堂练习

3．内置对象header：用来输出某一个请求头的值，

4．内置对象headerValues

5．内置对象cookie：用来获取cookie的值

6．内置对象initParam：用来输出上下文参数

7．内置对象pageContext

（1）语义

（2）语法

（3）例子

（四）知识点4： EL表示式获取数据的作用域检索顺序

1．获取属性有关的内置对象有4个

2．不写范围

（1）语法

（2）检索顺序

（五）知识点5： 强制使用某个作用域的属性

1．写范围

（1）语法

（2）检索顺序

（六）知识点6： EL运算符

1．算术运算符

2．比较运算符(6种)

3．逻辑运算符

（1）&&或and表示交集，两个值都是true才返回true。

（2）||或or表示并集，两个值只要有一个是true，即返回true。

（3）!或not表示非

4．其他运算符

（七）知识点7： EL表达式的集合运算符等特殊运算符

1．集合运算符

（1）语法

（2）课堂练习

①目标

②步骤

1）创建一个集合

2）将集合放到request作用域

3）在页面使用EL取得集合中第2个元素的值

2．empty运算符：

（1）${empty 普通变量名}语法

（2）${empty 集合变量名}

3．关系运算符(三目)：

4．()运算符：

（八）总结

二、JSTL

1.1.什么是JSTL

1.2.JSTL标签库的作用

1.3.JSTL结构

（一）课堂练习

1.4.使用JSTL标签

1.5.属性相关的标签

1.6.3.if标签

1.7.choose when otherwise标签

1.8.forEach标签

1.9.forTokens标签

（五）知识点5：强制使用某个作用域的属性