一、 JSP 入门
二、Cookie
三、HttpSession
四、JSP 指令
- 4.1 page 指令
4.2 include 指令（静态包含）
4.3 taglib （导入标签库）
4.4 JSP 九大内置对象
五、JSP 动作标签
六、EL 表达式
七、JSTL 标签库

一、 JSP 入门

1.1 什么是 JSP？

JSP全名为Java Server Pages ,其根本是-一个简化的Servlet设计,他实现了在Java当中使用HTML标签。Jsp是一种动态网页技术标准，也是JAVAEE的标准。JSP与Servlet- 样,是在服务器端执行的。

1.2 JSP 的作用

Servlet：
- 缺点：不适合设置 html 响应体，需要大量的 response.getWriter().print(“xxx”);
- 优点：动态资源，可以编程
html：
- 缺点：html 是静态资源，不能包含动态信息
- 优点：不必为输出 html 标签担心
jsp：
- 优点：在原有的 html 基础上添加 Java 脚本，构成 jsp 页面
- 缺点：第一次加载 jsp 会编译成 servlet，效率低

1.3 jsp 和 Servlet 的分工

JSP
- 作为请求发起的页面，例如显示表单，表格，超链接。
- 作为请求结束的界面，显示数据
Servlet：
- 作为请求处理数据的环节

1.4 jsp 的组成

jsp = html + java脚本 + jsp 标签（指令）
jsp中无序创建即可使用的对象一共有 9 个，被称为 9大内置对象，例如 request，response，out等等
3 中 Java 脚本
- <%….%>：java代码片段（常用），用于定义 0-N条Java语句！
- <%=…%>：java 表达式，用于输出（常用），用于输出一条表达式（或变量）的结果
- <%!…%>：声明，用来创建类的成员变量和成员方法（基本不用）

1.5 jsp 原理

jsp 其实是一种特殊的 Servlet
- 当 jsp 第一次被访问时，服务器会把 jsp 编译成 .java 文件（这个 java 文件其实就是一个 Servlet）
- 然后在把创建的 java 文件编译成 .class
- 然后创建该类对象
- 最后调用它的 service() 方法
- 第二次请求统一 jsp 时，直接调用 service() 方法

1.6 JSP 注释

<!--  -->  HTML 注释，在源码可以见
<%--  --%> JSP 注释，编译后（看前端源码）看不到

二、Cookie

2.1 cookie 入门

cookie 是服务端设置在客户端的信息

2.1.1 Cookie 的用途

服务器使用 Cookie 跟踪客户端的状态
保存购物车（购物车中的商品不能使用 request 保存，因为他是一个用户向服务端发送多个请求）
显示上交登录名（也是一个用户多个请求）

2.1.2 JavaWeb中使用 cookie

原始方式
- 使用 reponse 发送 Set-Cookie 响应头
- 使用 request 获取 Cookie 请求头
便捷方式
- 使用 response.addCookie() 方法向游览器保存 Cookie
- 使用 request.getCookies() 方法获取游览器归还的 Cookie

注意：Cookie 不能跨游览器

2.1.3 编写设置 Cookie 的实例

编写 A.jsp 用来保存 Cookie
编写 B.jsp 打印 Cookie

A.jsp 设置 Cookie

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>保存 Cookie</h1>
    <%
        Cookie cookie1 = new Cookie("aaa","AA");
        response.addCookie(cookie1);
        Cookie cookie2 = new Cookie("username","admin");
        response.addCookie(cookie2);
    %>
</body>
</html>

B.jsp 获取 Cookie

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>获取 Cookie</title>
</head>
<body>
    <% Cookie[] cookie=  request.getCookies();
        if (cookie !=null) {
            for (Cookie c: cookie) {
                out.println(c.getName()+":"+c.getValue()+"<br/>");
            }
        }
    %>
</body>
</html>

然后分别运行两个页面，在 B.jsp 可以看到如下打印结果

2.2 cookie 生命周期

2.2.1 Cookie 的maxAge

Cookie 的最大生命，即 Cookie 可保存的最大时长，以秒为单位

maxAge>0:浏览器会把Cookie保存到客户机硬盘上，有效时长为maxAge的值决定。
maxAge<0: Cookie只在浏览器内存中存在，当用户关闭浏览器时，浏览器进程结束，同时Cookie也就死亡了。
maxAge=0:浏览器会马上删除这个Cookie !

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>保存 Cookie</h1>
    <%
        Cookie cookie1 = new Cookie("aaa","AA");
        cookie1.setMaxAge(60);  // 设置 cookie 的生命，以秒为单位，时间一到就死亡
        response.addCookie(cookie1);

        Cookie cookie2 = new Cookie("username","admin");
        response.addCookie(cookie2);
    %>
</body>
</html>

2.3 cookie 路径

Cookie的path并不是设置这个Cookie在客户端的保存路径! ! !
Cookie的path由服务器创建Cookie时设置
当浏览器访问服务器某个路径时，需要归还哪些cookie给服务器呢?这由Cookie的path决定。
浏览器访问服务器的路径，如果包含某个Cookie的路径，那么就会归还这个cookie.

例如:

aCookie.path=/day11 1/; bCookie.path=/day11 1/jsp3/; cCookie .path=/day11_ 1/jsps/cookie/;
- 访问: /day11_ 1/index. jsp时，归还: aCookie
- 访问: /day11_ _1/jsp3/a.jsp时，归还: aCookie、 bCookie
- 访问: /day11_ 1/jsp3/ cookie/b.jsp时，归还: aCookie、 bCookie、cCookie

Cookie的path默认值:当前访问路径的父路径。例如在访问/day11 1/jsp3/a.jsp时，响应的cookie,那么这个cookie的默认path为/day11 1/jsps/

2.4 cookie 的域

Cookie的domain (了解)

domain用来指定Cookie的域名!当多个二级域中共享Cookie时才有用.
- 例如; www.baidu.com、zhidao.baidu.com、news.baidu.com、tieba.baidu.com之.间共享Cookie时可以使用domain
- 设置domain为: cookie.setDomain(“.baidu.com”);
- 设置path为: cookie.setPath(“/“);
  三、HttpSession
  3.1 HttpSession概述
HttpSession是由JavaWeb提供的，用来会话跟踪的类。session是服务器端对象，保存在服务器端! ! !
HttpSession是Servlet3三大域对象之一(request, session, application[ServletContext])，所以它也有setAttribute ()、getAttribute()、 removeAttribuce()方法
HttpSession底层依赖Cookie,或是URL重写!

3.2 HttpSession的作用

会话范围:

会话范围是某个用户从首次访问服务器开始，到该用户关闭浏览器结束! 一个用户对服务器的多次连贯性请求所谓连贯性请求，就是该用户多次请求中间没有关闭浏览器!

服务器会为每个客户端创建一个session对象， session就好比客户在服务器端的账户，它们被服务器保存到一-个Map中，这个Map被称之为session缓存!
- Servlet中得到session对象: HttpSession session = request. getSession();
- Jsp中得到ession对象: session是jsp内置对象之下，不用创建就可以直接使用!
session域相关方法:
- void setAttribute (String name, object value);
- Object getAttribute (String name) ;
- void removeAttribute (String name) ;

注意：session 底层是依赖于 Cookie的，所以不能进行跨游览器显示数据

3.3 session 中数据共享

3.3.1 演示 session域中保存数据

AServlet：向 session 域中保存数据
BServlet：向 sessiuon 域中获取数据

A.jsp 数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>保存 session </title>
</head>
<body>
    <h3>我保存了 session 数据</h3>
    <% session.setAttribute("aaa","AAA"); %>
</body>
</html>

B.jsp 数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>获取 session</title>
</head>
<body>
    <% String s = (String) session.getAttribute("aaa"); %>
    <h3>在 A.jsp 中保存的 session 结果是:  <%=s%> </h3>
</body>
</html>

然后我们先打开 A.jsp，再打开 B.jsp

游览器没有关闭之前，打开多个窗口都可以看到 session

3.3.2 演示保存登录信息

login.jsp：登录页面
suc1.jsp：登录成功可以访问的页面
1. 从 session 域中获取用户信息，如果不存在，显示 “您还没有登录”，存在则显示用户信息
suc2.jsp：登录成功可以访问的页面
1. 从 session 域中获取用户信息，如果不存在，显示 “您还没有登录”，存在则显示用户信息
LoginServlet：校验是否登录成功
1. 失败：保存错误信息到 request 域，转发到 login.jsp 并同时显示 request 域中的错误信息
2. 成功：保存用户信息到 request 域中，重定向到 suc1.jsp，显示 session 域中的用户信息

只要游览器没有关闭，session 就一直存在

编写 login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>我是登录页面</title>
</head>
<body>
<h1>登录</h1>
<!-- cookie -->
<%
    String username = "";
    Cookie cs[] = request.getCookies();
    if (cs != null) {
        for (Cookie c:cs) {
            if ("username".equals(c.getName())) {
                username = c.getValue();  // 获取这个 cookie 值
            }
        }
    }
%>

<%
    String message = "";
    String msg = (String) request.getAttribute("msg");
    if (msg != null) {
        message = msg;
    }
%>
    <form action="/web05/LoginServlet" method="post">
        <%-- 把 cookie 中的用户名显示到文本框中 --%>
        账户：<input type="text" name="username" value="<%=username %>"><br>
        密码：<input type="password" name="password"><br>
        <input type="submit" value="提交">
    </form>

   <font color="red"><%=message%></font>
</body>
</html>

编写 suc1.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>suc11</title>
</head>
<body>
    <% String username = (String)session.getAttribute("username");
        if (username == null) {
            request.setAttribute("msg","您还没有登录呢");
            request.getRequestDispatcher("/login/login.jsp").forward(request,response);
            return;
        }
    %>
    <h3>我是登录成功页面 suc1</h3>
    欢迎 <%=username %> 登录
</body>
</html>

编写 LoginServlet

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;

@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 解决乱码问题
        request.setCharacterEncoding("utf-8");
        // 获取用户表单的信息
        String username = request.getParameter("username");
        String password = request.getParameter("password");


        if (username.equals("admin")) {
            System.out.println("账户正确");
            if (password.equals("admin")) {
                System.out.println("密码正确");

                // 登录成功了
                Cookie cookie = new Cookie("username",username);
                cookie.setMaxAge(60*60*2); // 设置 cookie 保存两个小时
                response.addCookie(cookie); // 保存 cookie

                // 获取会话
                HttpSession session = request.getSession();
                session.setAttribute("username",username);
                // 重定向需要在根加上项目名，请求转发不需要加跟
                response.sendRedirect("/web05/login/suc1.jsp");
            } else {
                System.out.println("密码错误");
                request.setAttribute("msg", "登录失败，密码错误");
                // 登录失败保存到 request 域中，这样在请求转发就可以获取到数据了
                request.getRequestDispatcher("/login/login.jsp").forward(request,response);
            }
        } else {
            System.out.println("账户错误");
            request.setAttribute("msg", "登录失败，账号错误");
            // 登录失败保存到 request 域中，这样在请求转发就可以获取到数据了
            request.getRequestDispatcher("/login/login.jsp").forward(request,response);

        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

3.4 HttpSession 原理

request.getSession() 方法
- 获取 Cookie 中的 sessionId
  - 如果 sessionId 不存在，创建 session，把 session 保存起来，把新创建的 SessionId 保存到 Cookie 中
  - 如果 sessionId 存在，通过 sessionId 查找到 session 对象，如果没有查到，创建 session，把 session 保存起来，把新创建的 sessionId保存到 cookie中
  - 如果 sessionId存在，通过 sessionId 查找 session 对象，那么不会再创建 session对象了
  - 返回 session
- 如果创建了新的 session。游览器会得到一个包含了 sessionId 的 Cookie，这个 Cookie 的生命为 -1，即只能再游览器内存中存在，如果不关闭游览器，
- 下次请求时，再次执行request . getSession()方法时，因为可以通过cookie中的sessionId找到session对象，所以与上一次请求使用的是同一- session对象。
服务器不会马上创建 session，在第一次获取 session时，才会创建 session

四、JSP 指令

一个 jsp 页面中，可以用 0-N 个指令定义

4.1 page 指令

<%@page language="java" contentType="text/html;charset=UTF-8" info="xxx" ...%>

pageEncoding：指的是当前 jsp 页面的编码，在服务器需要把 jsp 编译成 .jafva 时，需要使用该标签
contentType：它表示添加一个响应头：Content-Type！等同于 response.setContentType(“text/html;charset=UTF-8”)
如果两个属性只提供一个，那么另一个的默认值为设置的那个
如果两个都没属性值，那么设置为 ISO
import 导包！可以出现多次
errorPage 和 isErrorPage
- errorPage：当前页面如果抛出异常，那么要转发到哪一个页面，由 errorPage 决定
- isErrorPage：它指定当前页面是否为处理错误的页面！这个页面会设置状态码为 500，这个页面可以使用九大内置对象中的 Exception

web.xml 配置错误页面

<?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">

    <error-page>
        <error-code>404</error-code>
        <location>/error/errorPage.jsp</location>
    </error-page>
    <error-page>
        <error-code>500</error-code>
        <location>/error/errorPage.jsp</location>
    </error-page>
    <error-page>
        <exception-type>java.lang.RuntimeException</exception-type>
        <location>/index.jsp</location>
    </error-page>
</web-app>

autoFlush 和 buffer
- autoFlash：指定 jsp 的输出流缓冲区满时，是否自动刷新！默认为 true，否则缓冲区满了就抛异常
- buffer：指定缓冲区大小，默认 8kb，通常不需要修改
isELIgnored：是否忽略 EL 表达式，默认为 false，不忽略，及支持
language：指定当前 jsp 编译后的语言类型，默认为 java
info：信息
isThreadSafe：当前 jsp 是否支持并发访问！
session：当前页面是否支持 session
extends：让 jsp 生成的 Servlet 去继承该属性需要的类

4.2 include 指令（静态包含）

与RequestDispatcher的include ()方法的功能相似!
<%include%>它是在jsp编译成java文件时完成的!他们共同生成一-个java (就是- -个servlet)文件，然后再生成. 一个class!
RequestDispatcher的include() 是-一个方法，包含和被包含的是两个servlet,即两个.class!他们只是把响应的内容在运行时合并了!
作用:把页面分解了，使用包含的方式组合在一起，这样一一个页面中不变的部分，就是一个独立jsp，而我们只需要处理变化的页面。

eg：
我们分别编写 header.html 和 footer.html
并加上一些简单的内容

然后在 index.jsp 的页面加上 include 标签

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>include 指令</title>
  </head>
  <body>
  <%@include file="header.html"%>
  <h1>Hello World</h1>
  <h2>显示中文</h2>
  <%@include file="footer.html"%>
  </body>
</html>

效果图：

4.3 taglib （导入标签库）

两个属性:

prefix: 指定标签库在本页面中的前缀!由我们自己来起名称!
uri: 指定标签库的位置!
<%@taglib prefix=”g” uri=”/struts-tags”%> 前缀的用法：

4.4 JSP 九大内置对象

在JSP中无需创建就可以使用的9个对象，它们是:

out (JspWriter): 等同与response.getWriter(),用来向客户端发送文本数据;
config (ServletConfig): 对应“真身”中的ServletConfig;
page (当前JSP的真身类型):当前JSP页面的“this”,即当前对象;
pageContext (PageContext):页面上下文对象，它是最后一个没讲的域对象;
exception ( Throwable):只有在错误页面中可以使用这个对象;
request (HttpServletRequest): 即HttpServletRequest 类的对象;
response (HttpServletResponse ):即HttpServletResponse类的对象;
application (ServletContext): 即ServletContext类的对象;
session (HttpSession ):即HttpSession类的对象，不是每个JSP页面中都可以使用，如果在某个JSP页面中设置<%@page session-=”false”%> ,说明这个页面不能使用session。

在这9个对象中有很多是极少会被使用的，例如: config、 page、 exception 基本不会使用。
在这9个对象中有两个对象不是每个JSP页面都可以使用的: exception、 session。
在这9个对象中有很多前面已经学过的对象:out、request、response、application、session、config

pageContext：

一个顶九个
Servlet 中有三大域，而 JSP 有四大域，它就是最后一个域对象！
- ServletContext：整个应用程序
- session：整个会话，一个会话中只有一个用户
- request：一个请求链
- PageContext：一个 JSP 页面！这个域是在当前 jsp 页面和当前 jsp 页面中使用标签共享数据
  - 域对象：当前页面
  - 代理其他域: pageContext . setAttribute (“xxx”, “XXX”,. PageContext . SESSION_ SCOPE) ;
  - 全域查找: pageContext . findAttribute (“xxx”);从小到大，依赖查找!
  - 获取其他8个内置对象:

五、JSP 动作标签

这些 jsp 的动作标签，与 html 提供的标签有本质的区别。

动作标签是由 tomcat（服务器）来解释执行！它与 java 代码一样，都是在服务端执行的！
html 由游览器执行！

5.1 jsp:forward 转发标签

：转发！它与 RequestDispatcher 的 forward 方法是一样的，一个是在 Servlet 中使用，一个是在 jsp 中使用，跳转的时候，标签名不变，内容改变

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>include 指令</title>
</head>
<body>

  <!-- jsp:forward 跳转页面 -->
  <jsp:forward page="second.jsp"/>
</body>
</html>

5.2 jsp:include 包含标签

: 包含:它与RequestDispatcher的include方法是一样的，一个是在Servlet中使用，一个是在jsp中使用!

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>include 指令</title>
  </head>
  <body>

  <!-- include 用于拼接静态页面 -->
  <%@include file="header.html"%>
  <h1>Hello World</h1>
  <h2>显示中文</h2>
  <%@include file="footer.jsp"%>

  <br/>
  <!-- jsp:include 运行的时候拼接页面 -->
  <jsp:include page="second.jsp"/>

  </body>
</html>

5.3 jsp:param 参数传递标签

:它用来作为forward和include的子标签! 用来给转发或包含的页面传递参数!

index.jsp 使用传递参数

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>include 指令</title>
  </head>
  <body>

    <!-- jsp:forward 跳转页面 -->
  <!-- param 传参 -->
  <jsp:forward page="third.jsp">
    <jsp:param name="aa" value="111"/>
    <jsp:param name="bb" value="222"/>
  </jsp:forward>
  </body>
</html>

third.jsp 用来接收参数

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>foot</title>
</head>
<body>
<h3>我是 third.jsp</h3>
我接收参数：<%=request.getParameter("aa")%> <br/>
<%=request.getParameter("bb")%>

</body>
</html>

六、EL 表达式

6.1 EL 入门

EL 替代的是 <%= %>，EL 只能作为输出使用

6.1.1 全域查找

编写一个 jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EL 语法学习</title>
</head>
<body>
    <%
        pageContext.setAttribute("xxx","pageContextXXX");
        request.setAttribute("xxx","requestXXX");
        session.setAttribute("xxx","sessionXXX");
        application.setAttribute("xxx","applicationXXX");
    %>

    <h3>使用 el 表达式 </h3>:
    <!-- EL 全域查找功能 -->
    <p> 全域查找： ${xxx}</p> <%-- 从小到大查找 --%>
</body>
</html>

这个查找顺序

pageContext
request
session
application

6.1.2 查找指定域

${pageScope.xxx }
${requestScope.xxx}
${sessionScope.xxx}

${applicationScope.xxx}

  <p> 查找 pageContext：${pageScope.xxx }</p>
  <p> 查找 request：${requestScope.xxx}</p>
  <p> 查找 session： ${sessionScope.xxx}</p>
  <p> 查找 application： ${applicationScope.xxx}</p>

6.1.3 查找 JavaBean

6.2 EL 11个内置对象

EL一共11个内置对象，无需创建即可以使用。这11个内置对象中有10个是Map类型的，最后一个是pageContext对象。(11 个内置对象，10个是 Map，它是 pageContext，一个顶9个

pageScope:
requestScope
sessionScope:
applicationScope
param:对应参数,它是一-个Map, 其中key参数名，value是参数值，适用于单值的参数。
paramValues:对应参数，它是一-个Map, 其中key参数名，value是多个参数值，适用于多值的参数。
header:对应请求头，它是一一个Map,其中key表示头名称，value是单个头值，适用于单值请求头
headerValues:对应请求头，它是一一个Map,其中key表示头名称，value是多个头值，适用于多值请求头
initParam:获取内的参数! ```xml // xml 声明 xxx Xx yyy YYY

// 使用 EL 表达式 ${initParam.xxx}


- cookie: Map<String, Cookie>失型，兵中key定cookie的name, value是cookie对家。 S{ cookie●usernane. value}
- pageContext:它是PageContext类型! ${pageContext.request.method.contextPath}

```html
${pageContext.request.contextPath} // 获得当前的项目路径

<a href="${pageContext.request.contextPath}/cookie/a.jsp" />

<form action="${pageContext.request.contextPath}/login/login.jsp" method="post" >
      <input type="submit value="提交"> 
</form>

6.3 EL 函数库

该函数库有 JSTL 提供，因此需要导入该 JAR包
然后需要在 jsp 中导入该标签才可以使用：

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

一些函数功能见其名，知其意

七、JSTL 标签库

7.1 什么是 JSTL

JSTL 是 apache 对 EL 表达式的扩展（也就是说 JSTL 依赖 EL），JSTL 是标签语言！ JSTL 使用起来很简单，它与 JSP 动作标签一定，只不过动作标签是 JSP 的内置标签，需要我们自己导包，以及制定标签库

如果我们要使用 JSTL 就需要自己导包：JSTL 1.2.jar 包

7.2 JSTL 标签库

JSTL一共包含四大标签库:。

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

7.3 导入标签库

jstl.jar 包
在 jsp 页面中：<%@ taglib prefix=”前缀” uri=”路径” %>

7.3.1 core —> c标签

out 和 set
1. 1. 常量字符串
  2. 与 ${aaa} 相同
  3. default：当要输出的内容为 null 时，会输出 default 的指定的值
  4. escapeXml：默认为 true，表示转义
2. : 设置（创建域的属性）
  1. var：变量名
  2. value：变量值，可以是 EL 表达式
  3. scope：域，可选值是：page、request、session、application
remove
1. 删除域变量
  1. var：变量名
  2. scope：如果不给出 scope，表示删除所有域中该变量，如果指定了域，那么只删除该域的变量
url
1. value：指定一个路径！它会在路径前面自动加项目名
  1. 它会输出/项目名/index.jsp
  2. 子标签：用来给 url 后面添加参数：
  3. var：指定变量名，一旦添加了这个属性，那么 url 标签就不会再输出到页面，而是把生成的 url 保存到域中
  4. scope：它与 url 一起使用，用来保存url
```
<c:url value="/index.jsp>
<c:param name="username" value="zs"/>
</c:url>
```
    结果为：/项目名/index.jsp?username=zs
if：对应 java 中 if
- … 当 test 为值时，执行标签体内的内容
choose
- choose: 它对应 java 中的 if/else if/…/else ```html … … … … …

等价于 if () {

} else if () {

} … else {

}


6. forEach
   - 它用来循环遍历数组，集合！
   - 它还可以用来技术方式来循环

计数方式：
```java
for (int i=1; i<=10; i++ ) {

}

// jsp 页面
<c:forEach var="i" begin="1" end="10">
    ${i}</br>
</c:forEach>

属性：

var ：循环变量
begin：设置循环变量从几开始
end：设置循环变量到几结束
step：设置步长，step 默认为1

<%
    String [] s = {"aaa","bbb","ccc"};
   request.setAttribute("strs",s);
%>

<c:forEach items="${strs}" var="str">
  ${str} </br>
</c:forEach>

属性：

items：指定要循环谁，它可以是一个数组或一个集合
var：把数组或集合中的每个元素赋值给 var 指定的变量

循环状态

可以使用 varStatus 来创建循环状态变量

循环状态变量有如下属性：

count：循环元素的个数
index：循环元素的下标
first：是否为第一个元素
lask：是否为最后一个元素

current：当前元素

<c:forEach items="${list}" var ="ele" varStatus="vs">
${vs.index} ${vs.count} ${vs.first} ${vs.last} ${vs.current} </br>
<c:forEach>

fmt库
1. 它是格式化库

value: 指定一个 Date类型变量
pattern：用来指定输出的模板：例如 yyyy-MM-dd HH:mm:ss

<fmt : formatNumber value: = "$ {num1}" pattern="0. 00">
保留小数点后2位，它会四舍五入!如果不足2位，以o补位!
<fmt: formatNumber value="S {num1}”pattern-"#.##">.
保留小数点后2位，它会四舍五入!如果不足2位，不补位!

2.3 JSP