13-JSP 2.3(EL+JSPL)

最新推荐文章于 2022-12-01 14:28:37 发布

头秃人菜

最新推荐文章于 2022-12-01 14:28:37 发布

阅读量767

点赞数

分类专栏： JavaEE 文章标签： jsp el jstl

本文链接：https://blog.csdn.net/qq_37834488/article/details/89444788

版权

JavaEE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

JSP

Java Server Pages，java服务器页面。

和Servlet一样，是sun公司定义的一种动态网页开发技术。基于html模版，可以在html模版嵌入java代码和jsp中的标签。

tomcat可以包含的资源：
静态技术：
    html:静态页面。
    CSS:修饰美化html页面。
    JavaScript:动态修改html页面和css样式。
动态技术:
    Servlet：运行在服务器上的java小程序。适合编写java代码，写网页困难，适合业务处理
    Servlet三个用途:1.接受浏览器发送的数据  2.负责调用业务层   3.转发重定向
    JSP:适合编写动态内容，不适合写java代码，主要用于显示页面。

Jsp优点：

服务器调用的是已经编译好的JSP文件（Tomcat_8_0_39_0422web\work\Catalina\localhost\项目名...）。
JSP可以与处理业务逻辑的Servlet一起使用，该模式被Java Servlet模版引擎所支持。

1 与纯Servlet相比：JSP可以很方便的编写或者修改HTML网页而不用去面对大量的println语句
2 与JavaScript相比：虽然JavaScript可以在客户端动态生成HTML，但是很难与服务器交互，因此不能提供复杂的服务，比如访问数据库和图像处理等等。
3 与静态HTML相比：静态HTML不包含动态信息

JSP语法

JSP页面中可以包含指令，Java语句、变量、方法或表达式、静态内容(html、css、javascript)

指令：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

脚本：
<% java代码 %> <% int i=10;%> <%=2+3%>

声明：
<%!定义方法%>

静态资源：HTML、CSS、JS

JSP注释：
<%-- 网页注释 --%>：安全，省流量，在class文件中就已经不存在了
//网页注释：存在于class文件中，但不会发送给浏览器
<!-- 网页注释 -->：不安全，耗流量，存在于class文件中，并且会发送给浏览器

案例：

<%--指令，页面的设置--%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" %>
    <%--1、模板元素 --%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>第一个JSP页面</title>
</head>
<body>
<%--我是jsp特有的注释 --%>
<!--我是HTML的注释  -->
<a href="http://www.baidu.com">百度一下</a>
<%--jsp脚本 --%>
<% int c=10; %>
</body>
</html>

  <%--声明属性(成员变量)--%>
  <%! private int count;%>
  <%--定义方法--%>
  <%!
    public String handlerString(String s){
      String s2 = s.toUpperCase();
      return s2;
    }
  %>

  <%
    //java脚本
    Date date = new Date();
    int num = 100;//局部变量
    for (int i = 0; i < 10; i++) {
      out.println("<h3>好好学习</h3>");
    }
  %>
  <%=date%><br/>
  <%=num%><br/>

  <%--调用方法--%>
  <%=handlerString("hello")%>
  <%=handlerString("world")%>

  <% count++; %>
  <h3>访问次数：<%=count%></h3>

通过查看源码，发现所有的jsp页面都变成类，(文件名_jsp.java)，类继承HttpJspBase，HttpJsbBase又继承HttpServlet，所有的jsp页面都是Servlet。

JSP指令

告诉JSP引擎如何解析jsp文件中的内容
语法：<%@ 指令名称 属性名称1＝“属性值1” 属性名称2＝“属性值2” ...%>
示例：<%@ page language="java" contentType="text/html; charset=UTF-8"  pageEncoding="UTF-8"%>

page指令：

用于定义JSP页面的各种属性。

import:和java代码的含义一样
    <%@ page import="java.util.Date,java.util.List"%>
        或者：<%@ page import="java.util.Date"%>
             <%@ page import="java.util.List"%>
session:是否会自动创建session对象，默认值为true;
buffer:JSP中有java.servlet.jsp.JspWriter输出字符流。设置输出数据的缓存大小。默认8kb.
errorPage:如果页面中有错误，跳转到指定的资源 errorPage="/uri" 如果写“/”则代表当前应用的目录下（绝对路径）。  如果不写“/”则代表相对路径
isErrorPage:是否创建throwable对象。默认是false
contentType:等同于response.setContentType("text/html;charset=utf-8");服务器发送客户端的内容编码
pageEncoding: Jsp文件本身的编码
isELIgnored: 是否支持EL表达式。 默认是false支持表达式；true表示不支持表达式
        ${1+1};false输出结果2   true按照原样输出

//isErrorPage为true时：
java.lang.Throwable exception = org.apache.jasper.runtime.JspRuntimeLibrary.getThrowable(request);
注意：errorPage的设置并不会创建 throwable 对象

示例：
    <%
        int n = 10/0;
    %>
    设置 isErrorPage 跳转到设置的 uri 页面，未设置跳转到 500 页面
    异常页面配置（web.xml）：
    <error-page>
        <error-code>404</error-code>
        <location>/error/404.html</location>
    </error-page>
    <error-page>
        <error-code>500</error-code>
        <location>/error/500.jsp</location>
    </error-page>
    <error-page>
        <location>/error/error.jsp</location>
    </error-page>
    在异常页面中编写：
<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
<html>
<head>
    <title>500</title>
</head>
<body>
    <h3>对不起，服务器出现异常</h3><br/>
    <%
        byte[] bytes = exception.getMessage().getBytes("gbk");
        String msg = new String(bytes,"utf-8");
        System.out.println(msg);
    %>
</body>
</html>
注意：isErrorPage="true" 必须写，不写就不会创建 throwable 的对象 exception，
同时这个 exception 信息的编码为 gbk，class文件中编码正常，在发送给浏览器之前会出现乱码（因为编码为 gbk），
以上方式可以解决输出到页面的异常信息的乱码问题，但不能解决中文标点的乱码问题。

include指令：

静态包含：把其它资源包含到当前页面中  <%@ include file="header.jsp" %>
动态包含： <jsp:include page=“header.jsp"></jsp:include>
两者的区别：翻译的时间段不同(可在tomcat工作目录下查看)
        静态包含：在翻译时就把两个文件进行合并，运行时效率高。
        动态包含：不会合并文件，当代码执行到include时，才包含另一个文件的内容。

taglib指令：

作用：在JSP页面中导入JSTL标签库。JSTL替换jsp中的java代码片段。
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

JSP的6个动作标签

使用标签的形式表示一段java代码：

jsp:include 动态包含 （与pageContext.include("sub.jsp")作用相同）
jsp:forward 请求转发 
            （相当于request.getRequestDispatcher("login.jsp").forward(request,response)
                        或pageContext.forward("login.jsp")）
jsp:param 请求设置参数
jsp:useBean 创建一个对象
jsp:setProperty 给指定的对象属性赋值
jsp:getProperty 取出指定的对象属值

include：

<jsp:include page="sub.jsp"></jsp:include>

forward + param：

index.jsp页面：

注意：主页面中设置编码类型utf-8 jsp:param的value属性才可以使用中文，不然会乱码，不过有解决方式。

    <%
      //乱码解决方式
      request.setCharacterEncoding("utf-8");
    %>
    <jsp:forward page="login.jsp?name=张三&age=20">
      <jsp:param name="email" value="张三@qq.com"></jsp:param>
      <jsp:param name="phone" value="12345678901"></jsp:param>
    </jsp:forward>

    <%
        String name = request.getParameter("name");
        out.println(name+"<br/>");
        String age = request.getParameter("age");
        out.println(age+"<br/>");
        String email = request.getParameter("email");
        out.println(email+"<br/>");
        String phone = request.getParameter("phone");
        out.println(phone+"<br/>");
    %>

运行结果：

useBean + getProperty + getProperty：

//创建Student类
public class Student {
    private String stuNo;
    private String stuName;
    private String address;
    ...
}

    <h3>useBean标签</h3>
    <jsp:useBean id="stu" class="domain.Student"></jsp:useBean><!--调用了Student的无参构造方法初始化对象-->

    <h3>setProperty</h3>
    <jsp:setProperty name="stu" property="stuNo" value="s1001"></jsp:setProperty>
    <jsp:setProperty name="stu" property="stuName" value="小明"></jsp:setProperty>
    <jsp:setProperty name="stu" property="address" value="北京"></jsp:setProperty>

    <h3>getProperty</h3>
    <jsp:getProperty name="stu" property="stuNo"></jsp:getProperty>
    <jsp:getProperty name="stu" property="stuName"></jsp:getProperty>
    <jsp:getProperty name="stu" property="address"></jsp:getProperty>

运行结果：

//    <jsp:useBean id="stu" class="com.qf.domain.Student"></jsp:useBean>
//源码：

    domain.Student stu = null;
    stu = (domain.Student) _jspx_page_context.getAttribute("stu", javax.servlet.jsp.PageContext.PAGE_SCOPE);
    if (stu == null){
        stu = new domain.Student();
        _jspx_page_context.setAttribute("stu", stu, javax.servlet.jsp.PageContext.PAGE_SCOPE);
    }
//使源码第二行生效，不再执行条件语句：
    <%
      Student student = new Student("s1001","小明","北京");
      pageContext.setAttribute("stu",student);
    %>

JSP内置对象

Servlet中内置对象：request 、response、session、application、out(PrintWriter)

Jsp本质是Servlet，包含九个内置对象（r r s a c e o p p ）

对象名	类型	说明
request	javax.servlet.http.HttpServletRequest
response	javax.servlet.http.HttpServletResponse
session	javax.servlet.http.HttpSession	由session=“true”开关
application	javax.servlet.ServletContext
config	javax.servlet.ServletConfig
exception	java.lang.Throwable	由isErrorPage=“false”开关
out	javax.servlet.jsp.JspWriter	javax.servlet.jsp.JspWriter
pageContext	javax.servlet.jsp.PageContext
page	java.lang.Object当前对象this	当前servlet实例

案例：

    <h3>out对象</h3>
    <%
        out.write("jsp内置对象之一out<br/>");
        out.println("helloworld<br/>");
        out.flush();//调用flush放入response中

        //获取servlet中的out
        PrintWriter writer = response.getWriter();
        writer.write("使用servlet中的out对象<br/>");
        writer.println("helloworld<br/>");
        /*
        两者区别：
        （1）类型不同：JSPWriter PrintWriter
        （2）jsp中out输出到缓存中，并没有立即输出到response中，
            servlet中out输出到response中
         */
    %>

    <h3>PageContext对象：获取其他8个内置对象；当作集合使用</h3>
    <%
        /*
        jsp中的4个域对象：pageContext,request,session,application
        PageContext对象：在当前页面中使用，别的页面不能使用
        request：在当前请求过程中使用，转发中数据不会丢失（根据id查询员工）
        session：在整个会话中（登录信息等）
        application：整个应用程序中，保存所有用户共享的信息，整个程序的配置信息
         */
        //当作集合使用
        pageContext.setAttribute("num", 100);
        pageContext.setAttribute("address", "北京");
        Student stu = new Student("s666","张三","上海");
        pageContext.setAttribute("student", stu);

        Integer num = (Integer) pageContext.getAttribute("num");
        String address = (String) pageContext.getAttribute("address");
        Student student = (Student) pageContext.getAttribute("student");
        out.write(num+"<br/>"+address+"<br/>");
        out.write(student.getStuName()+"<br/>");
    %>
    <%
        //4.从四个域里挨个查找：pageContext,request,session,application
        //4.1使用PageContext获取request域中数据
        request.setAttribute("requestData", "request中数据");
        String s1 = (String)pageContext.getAttribute("requestData",PageContext.REQUEST_SCOPE);
        out.println(s1+"<br/>");
        //4.1使用PageContext获取session域中数据
        session.setAttribute("sessionData", "session中数据");
        String s2 = (String)pageContext.getAttribute("sessionData",PageContext.SESSION_SCOPE);
        out.println(s2+"<br/>");
        //4.1使用PageContext获取application域中数据
        application.setAttribute("applicationData", "application中数据");
        String s3 = (String)pageContext.getAttribute("applicationData",PageContext.APPLICATION_SCOPE);
        out.println(s3+"<br/>");

        //查找的优先级问题(找到即停)：
        request.setAttribute("username", "xxx");
        session.setAttribute("username", "yyy");
        String s4 = (String)pageContext.findAttribute("username");
        out.println(s4+"<br/>");

        //设置数据
        pageContext.setAttribute("aaa", "aaa", PageContext.REQUEST_SCOPE);
        String aaa = (String) request.getAttribute("aaa");
        out.println("pageContext设置request域中数据：aaa="+aaa+"<br/>");
        pageContext.removeAttribute("aaa");//pageContext,request,session,application中的aaa全部移除
        pageContext.removeAttribute("aaa", PageContext.REQUEST_SCOPE);//设置从哪个域移除
        out.println("aaa="+aaa);
    %>

运行结果：

jsp的out和getWriter()方法的区别：
1 out是JspWriter类型，getWriter()是PrintWriter类型
2 out输出到缓冲区中，没有写到response中，getWriter()直接写到response中。
3 out一般用在jsp中，getWriter()用在Servlet中

pageContext对象：
1 代表页面上下文，获取其他八个内置对象
    getException方法返回exception隐式对象 
    getPage方法返回page隐式对象
    getRequest方法返回request隐式对象 
    getResponse方法返回response隐式对象 
    getServletConfig方法返回config隐式对象
    getServletContext方法返回application隐式对象
    getSession方法返回session隐式对象 
    getOut方法返回out隐式对象 
2 作用容器使用

pageContext可执行的简易方法：
pageContext.forward(“2.jsp”);//转发  request.getRequestDispatcher().forward();
pageContext.include(“2.jsp”);//动态包含

域对象：
四个域对象分别是request、session、application、pageContext
    request域的使用场景:本次请求之后，数据就不再使用了，根据学号查询学生，根据新闻id查询新闻。
    session域的使用场景:同一个会话中共享的数据，使用session，用户登录信息
    application域的使用场景:所有用户共享的数据。整个程序的配置信息
    pageContext域的使用场景：当前页面。
    其中pageContext可以操作其他三个域对象(request，session，application)的数据
pageContext操作自有数据：
        void setAttribute(String name,Object o);
        Object getAttribute(String name);
        void removeAttribute(String name);
    操作其它域对象的方法：
        void setAttribute(String name,Object o,int Scope);
        Object getAttribute(String name,intScope);
        void removeAttribute(String name,intScope);
            Scope作用域，值如下:
                PageContext.PAGE_SCOPE
                PageContext.REQUEST_SCOPE
                PageContext.SESSION_SCOPE
                PageContext.APPLICATION_SCOPE
        findAttribute(Stringname)
            自动从pageContext,request ,session ,application依次查找，
            找到了就取值，结束查找（作用域的范围由小到大）

EL表达式

Expression Language表达式语言

目的：简化jsp中java代码开发，代替脚本表达式<%=username%>，它不是一种开发语言，是jsp中获取数据的一种规范

格式：${EL表达式} 等价于 <%=pageContext.findAttribute(name)%>

获取简单数据：

    <%
        pageContext.setAttribute("username", "张三");
        request.setAttribute("age", "25");
        request.setAttribute("username", "李四");//查找优先级低于pageContext
        session.setAttribute("phone", "13838383838");
        application.setAttribute("address", "北京xxx");

        Student student = new Student("s0001","小明","北京yyy");
        pageContext.setAttribute("stu",student);
    %>
    <h2>案例一：简单数据</h2>

    <h3>不使用EL输出数据</h3>
    <%=pageContext.findAttribute("username")%>
    <%=pageContext.findAttribute("age")%>
    <%=pageContext.findAttribute("phone")%>
    <%=pageContext.findAttribute("address")%>
    <%=((Student)pageContext.findAttribute("stu")).getStuName()%>

    <h3>使用EL输出数据</h3>
    ${"username"}<!--原样输出-->
    ${username}
    ${age}
    ${phone}
    ${address}

    <h3>案例二：对象数据</h3>
    ${stu.stuNo}
    ${stu.stuName}
    ${stu.address}

运行结果：

使用List和Map集合：

    <h3>案例三：使用List和Map集合</h3>
    <%
        List<String> list = new ArrayList<String>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        pageContext.setAttribute("list", list);

        Map<String,String> map = new HashMap<>();
        map.put("aa", "11");
        map.put("bb", "22");
        map.put("cc", "33");
        map.put("1111", "xxxx");
        pageContext.setAttribute("map", map);
    %>
    <h4>输出List集合</h4>
    ${list[0]}<br/><%--同${list.get(0)}--%>
    ${list[1]}<br/>
    ${list[2]}<br/>
    ${list[3]}<br/><%--此处不会报错，不会输出--%>
    <h4>输出map集合</h4>
    ${map.aa}<br/>
    ${map.bb}<br/>
    ${map.cc}<br/>
    <%--${map.1111} 此写法报错--%>
    <%--使用[]--%>
    ${map["aa"]}<%--同${map['aa']}--%>
    ${map["bb"]}
    ${map["cc"]}
    ${map["1111"]}

运行结果：

使用EL表达式执行运算、empty关键字：

    <h3>算术运算</h3>
    ${10+5}<br/>
    ${10-5}<br/>
    ${10*5}<br/>
    ${10/5}<br/>
    ${3%5}<br/>

    <%
        String s1 = new String("java");
        String s2 = new String("java");
        pageContext.setAttribute("java1",s1);
        pageContext.setAttribute("java2",s2);
    %>
    <h3>关系运算</h3>
    ${10 == 5}<br/>
    ${10 != 5}<br/>
    <span>"hello" == "hello":</span>${"hello" == "hello"}<br/>
    <span>s1 == s2:</span>${s1 == s2}<br/>
    <span>java1 == java2:</span>${java1 == java2}<br/>
    ${10 > 5}<br/>
    ${10 < 5}<br/>
    ${10 >= 5}<br/>
    ${10 <= 5}<br/>

    <h3>其他关系运算符</h3>
    ${java1 eq java2}<br/>
    ${100 eq 200}<br/>
    ${100 gt 99}<br/>
    ${50 lt 199}<br/>

    ${200 ge 199}<br/>
    ${200 le 199}<br/>
    ${200 ne 199}<br/>

    <h3>三目运算</h3>
    <%
        pageContext.setAttribute("flag",0);
        pageContext.setAttribute("sex",0);
    %>
    ${99>90?"优秀":"一般"}
    ${flag==0?"没有激活":flag==1?"激活":"删除"}
    ${sex==0?"男":"女"}

运行结果：

    <h3>逻辑运算</h3>
    ${true &&  false}<br/>
    ${true || false}<br/>
    ${!true}<br/>
    ${true and  false}<br/>
    ${true or false}<br/>
    ${not true}<br/>

    <h3>empty运算</h3>
    <% String ss1="";
        pageContext.setAttribute("ss1", ss1);
        String ss2=null;
        pageContext.setAttribute("ss2", ss2);
        String ss3="122222";
        pageContext.setAttribute("ss3", ss3);
        List list1 =new ArrayList();
        pageContext.setAttribute("list1", list1);
    %>
    <!-- empty关键字：只要内容是空即为true -->
    ${empty ss1}<br>
    ${empty ss2}<br>
    ${empty  ss3}<br>
    ${empty  list1}<br>

运行结果：

一种常用写法：
${empty user?"<a href=''>请登录</a>":"<a href=''>退出</a>"}<br/>

隐式对象（11个）：

JSP 表达式语言定义了一组隐式对象，其中许多对象在 JSP servlet和表达式中可用：

pageContext：页面上下文，可以获取jsp中其他八个内置对象
pageScope、requestScope、sessionScope、applicationScope表示四个域对象中集合

param 表示request.getParameter("username"); ${param.username}
paramvalues 表示request.getPrameterValues("hobby"); ${paramValues.hobby}
header 表示 request.getHeader("accept"); ${header.accept};
headerValues 表示 request.getHeaderValues("accept-encoding"); ${headerValues"accept-encoding"}
cookie 表示 request.getCookies(); ${cookie.JSESSIONID}

initParam 表示 ServletContext(application)初始化参数

param 和 paramvalues 只能接收浏览器的 request 请求数据，本页面设置假数据不能读取，但域对象集合 requestScope 可以。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EL表达式对象</title>
</head>
<body>
    <h2>EL表达式11隐式对象</h2>
    <ul>
        <li>pageContext</li>
        <li>pageScope</li>
        <li>requestScope</li>
        <li>sessionScope</li>
        <li>applicationScope</li>
        <li>param</li>
        <li>paramValues</li>
        <li>header</li>
        <li>headerValues</li>
        <li>cookie</li>
        <li>initParam</li>
    </ul>
    <h4>pageContext:获取其他八个jsp内置对象</h4>

    ${pageContext.request.contextPath}
    <form action="${pageContext.request.contextPath}/login" method="post">
            <input type="text" name="username" placeholder="请输入用户名">
    </form>

    ${pageContext}<br/>
    ${pageContext.request}<br/>
    ${requestScope}<br/>
    <h4>pageScope、requestScope、sessionScope、applicationScope</h4>
    <%
        pageContext.setAttribute("username", "李四");
        request.setAttribute("age", "22");
        session.setAttribute("address", "河北保定");
        application.setAttribute("phone", "110");
    %>
    ${pageScope.username}<br/>
    ${requestScope.age}<br/>
    ${sessionScope.address}<br/>
    ${applicationScope.phone}<br/>
    ${pageScope["username"]}

    <h4>param对象</h4>
    ${param.userid}<br/>
    ${param.keyword}<br/>

    <h4>paramValues</h4>
    ${paramValues.hobby[0]}<br/>
    ${paramValues.hobby[1]}<br/>

    <h4>header</h4>
    ${header.accept}<br/>
    ${header["accept-encoding"]}<br/>

    <h4>headerValues</h4>
    ${(headerValues.accept)[0]}<br/>
    ${(headerValues["accept-encoding"])[0]}<br/>

    <h4>cookie</h4>
    ${cookie.JSESSIONID.name}=${cookie.JSESSIONID.value}
    
    <h4>initParam</h4>
    ${initParam.appname}<br/>
    ${initParam.version}<br/>
</body>
</html>

JSTL

全称Java Server Pages Standard Tag Library，JSP标准标签库，代替jsp页面的脚本，实现逻辑控制。

实现JSP页面中逻辑处理，如判断，循环等。下载JSTL库：

Index of /dist/tomcat/taglibs

taglibs-standard-impl-1.2.5.jar

taglibs-standard-spec-1.2.5.jar

把jstl.jar、standard.jar放入WEB-INF/lib目录下

使用JSTL：

必须在JSP页面添加tablib指令库：
<% @taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c">

通用标签set，out，remove：

<!--1.声明变量k   var：是变量名  value:变量的值(必须是EL表达式)-->
	<c:set var="k" value="${1+1}"></c:set>
<!--2.输出变量k   value:使用EL表示表示变量-->
	移除前输出的内容：<c:out value="${k}"></c:out><br>
<!--3.移除指定变量  -->	
	<c:remove var="k"/>
	移除后输出的内容：<c:out value="${k}"></c:out><br>
<!--4.给指定变量赋默认值  -->
	默认值：<c:out value="${m}" default="123456"></c:out>

    <%
        pageContext.setAttribute("xxx","哈哈啊哈");
    %>
    <h4>out标签的使用</h4>
    <c:out value="${xxx}"></c:out></br>
    <%--${"<script type='text/javascript'>while(true){alert('这个是真烦死你，慎用');}</script>"}--%>
    <c:out value="<script type='text/javascript'>while(true){alert('烦死你');}</script>"></c:out>

运行结果：

条件标签if，choose：

    <h3>条件标签</h3>
    <c:if test="${10>5}">
        真的<br/>
    </c:if>

    <c:if test="${empty user}">
        没有登录<br/>
    </c:if>

    <c:set value="80" var="score"></c:set>
    <c:choose><%--choose(等价于java中switch)--%>
        <c:when test="${score>90}">优秀</c:when>
        <c:when test="${score>80}">良好</c:when>
        <c:when test="${score>70}">一般</c:when>
        <c:when test="${score>60}">差</c:when>
        <c:otherwise>不及格</c:otherwise>
    </c:choose>

运行结果：

迭代标签foreach：

<!-- 遍历for:输出1到10 的值 -->
	<!--var: 变量，把遍历的每一个值都存储在变量中进行输出
    begin：开始   如果是变量使用EL表达式表示
    end:结束    如果是变量使用EL表达式表示
    step:间隔的长度
    
    for( int i=0;i<10;i++){
     System.out.println(i);
    }
     -->
示例代码：
<c:forEach var="i" begin="1" end="10" step="2">
 ${i}<br>
</c:forEach>

    <h3>迭代标签foreach</h3>
    <%
        List<String> cities = new ArrayList<>();
        cities.add("北京");
        cities.add("上海");
        cities.add("西安");
        cities.add("深圳");
        cities.add("杭州");
        pageContext.setAttribute("cities",cities);

        Map<String,String> map = new HashMap<>();
        map.put("cn", "中国");
        map.put("usa", "美国");
        map.put("uk", "英国");
        pageContext.setAttribute("map",map);
    %>

    <c:forEach var="city" items="${cities}">
        ${city}
    </c:forEach>
    <br/>
    <c:forEach var="country" items="${map}">
        ${country.key}...${country.value}
    </c:forEach>
    <br/>
    <!--其他迭代-->
    <c:forEach begin="1" end="10" step="1" var="i">
        ${i}
    </c:forEach>

运行结果：

  <h3>测试list集合遍历获取学生列表</h3>
      <table border="1" width="80%" bordercolor="red" cellspacing="0"
          align="center">
          <tr>
              <th>学号</th>
              <th>姓名</th>
              <th>成绩</th>
              <th>班级</th>
              <th>是否是第一个</th>
              <th>是否是最后一个</th>
              <th>计数count</th>
              <th>索引index</th>
          </tr>
   <!-- varStatus:变量状态：遍历出的每一项内容的状态：
      isFirst()      first
      isLast()       last
      getCount()     count  计数  重要的
      getIndex()     index
       -->
       <!-- var :遍历出的每一项使用变量先存储
            items：集合(使用El表达式)
            -->
          <c:forEach var="stu" items="${students}" varStatus="vs">
              <tr>
                  <td>${stu.id}</td>
                  <td>${stu.name}</td>
                  <td>${stu.score}</td>
                  <td>${stu.classes}</td>
                  <td>${vs.first}</td>
                  <td>${vs.last}</td>
                  <td>${vs.count}</td>
                  <td>${vs.index}</td>
              </tr>
          </c:forEach>
   </table>

    <h3>url标签</h3>
    <c:url var="empurl" value="list">
        <c:param name="ename" value="张三"></c:param>
        <c:param name="job" value="销售"></c:param>
    </c:url>

    <a href="${empurl}">员工列表</a>

运行结果：