jsp介绍

概述
    JSP全名为Java Server Pages，Java服务页面（提供Java服务的页面）
    jsp页面可以写html代码，也可以写Java代码。
    其根本是一个简化的Servlet设计。
    后缀名为(*.jsp)
    用JSP开发的Web应用是跨平台的，既能在Linux下运行，也能在其他操作系统上运行。
    JSP与Servlet一样，是在服务器端执行的。
    通常返回给客户端的就是一个HTML文本，因此客户端只要有浏览器就能浏览.
    JSP技术使用Java编程语言编写类XML的tags和scriptlets，来封装产生动态网页的处理逻辑。
    网页还能通过tags和scriptlets访问存在于服务端的资源的应用逻辑。
作用
    jsp用于开发动态资源的技术。
    servlet中向浏览器输出html数据是非常不方便的，所以就要使用jsp替代。
    jsp就是servlet+html
原理
    jsp就是一个servlet。
    JSP会被最终编译成一个Servlet
    把项目运行到tomcat中后，访问某个jsp。然后到tomcat的work/catalina/local/项目名称/org/apache/jsp目录下有对应的jsp生成的文件。
        _01_showtime_jsp.class 
        _01_showtime_jsp.java
运行过程
    1）浏览器发出请求访问的jsp
    2）tomcat服务器会把jsp文件翻译成一个Java文件。
    3）tomcat服务器会把Java文件编译成class文件。
    4）tomcat服务器创建jsp类对象
    5）调用jsp类的方法
注意：
    1）翻译和编译操作在第一次访问的时候执行和修改jsp后执行。
问题
    1）jsp中的HTML代码是如何输出的？
        在_jspService()中执行
        把jsp代码中的所有内容通过out.write()输出到界面。
    2）Java代码如何执行的？
        直接把jsp中的Java代码拷贝到Java文件中，也是在_jspService()中执行
特点：
    简单易用
    完全的面向对象
    具有平台无关性且安全可靠
    主要面向因特网
一个JSP页面可以被分为以下几部份：
    静态数据，如HTML
    JSP指令，如include指令
    JSP脚本元素和变量
    JSP动作
    用户自定义标签

jsp语法

jsp模板
    作用：就是jsp页面写的HTML代码
jsp表达式
    作用：向浏览器输出变量或表达式计算的结果
    语法：<%=变量或者表达式%>
    注意：
        1）原理使用out.print();输出内容
        2）不要以分号结尾
jsp脚本
    作用：执行Java代码
    语法：<%%>
    注意：
        原理是原封不动的拷贝到_jspService()方法中执行
    使用：
        <%
        for(Student stu:students){
        %>
        <tr>
            <td><%=stu.getId()%></td>
            <td><%=stu.getName()%></td>
            <td><%=stu.getAge()%></td>
        </tr>
        <%}%>
    不足
        代码结构混乱
        脚本与HTML混合，容易出错
        代码不易于维护
jsp声明
    作用：声明成员变量和成员方法.可以在脚本和表达式中使用。
    语法:<%!  %>
    使用：
        <%! 
            String name="shuaige";
            public String getName(){return name;}
        %>
    注意：
        1）不能定义和翻译同名类或者同名方法
        2）方法只能定义在声明中，脚本不能定义方法的
        3）声明定义的是全局变量，脚本定义的是局部变量。
jsp注释
    作用：注释jsp页面
    语法：<%-- jsp注释 --%>
    注意：
        1）jsp注释与HTML注释要区分开来。 html注释会被翻译和被执行。而jsp注释不会被翻译。
        2）jsp页面尽量使用jsp注释。

jsp指令

作用
    1）指令的作用就是告诉web服务器如何翻译这个jsp页面的内容。
    2）翻译的过程起作用
语法
    <%@ 指令名称 属性1 属性2 ... %>
三大指令
    page
        作用：通知web服务器如何翻译一些常用的属性
    include指令
        作用:包含其它页面
        原理:被包含的jsp页面不会被翻译和被编译
        注意：
            1）包含和被包含的页面内容先合并在一起，然后翻译一个Java文件（先合并再翻译）
            2）这种包含叫做静态包含
    taglib
        作用：用于导入标签库指令。

EL表达式

作用：向浏览器输出域对象中的变量或者表达式结果。用于替代jsp表达式
    可以用于获取JavaBean的属性
    能够读取集合类型对象中的元素
    运用运算符进行数据处理
    屏蔽常见的异常
    自动实现类型转换
    
    页面结构清晰
    代码可读性高，易于维护
不足
    EL表达式无法实现逻辑控制
语法：${变量名|表达式}
EL表达式获取不同类型数据
    取普通的字符串 ${username} 其实是替代 <%=pageContext.findAttribute("name")%>
    取对象的属性数据${student.name}
    List集合或数组数据${list[0].name}/${arr[0]} 
    取Map集合数据${map['username']}
EL执行表达式计算
    数学运算 +,-,*,/,%   ${a+b}
    逻辑运算 &&,||,!    ${true && false}
    比较运算 >,<,>=,<=,== ${a>b}
    三目运算 ?:  ${a>b?"是":"不是"} <input type="radio" name="gender" value="男" ${gender=="男"?"checked='checked'":""}/>
    为空判断 ${name==null || name==""} 或者 ${empty name}
    改变优先级 () 例如${3*(4+5)}
EL的内置对象（11个）
    ${pageContext}  ==  <%=pageContext%> 
    ${pageScope.name}  ==  <%=pageContext.getAttribute("name",PAGE_SCOPE)%>
    ${requestScope.name}  ==  <%=pageContext.getAttribute("name",REQUEST_SCOPE)%>
    ${sessionScope.name}  ==  <%=pageContext.getAttribute("name",SESSION_SCOPE)%>
    ${applicationScope.name}  ==  <%=pageContext.getAttribute("name",APPLICATION_SCOPE)%>
    ${param['name']}  ==  <%=request.getParameter("name")%>
    ${paramValues['name']}  ==  <%=request.getParameterValues("name")%>
    ${header['user-agent']}  ==  <%=request.getHeader("user-agent")%>
    ${headerValues['user-agent']}  ==  <%=request.getHeaders("user-agent")%>
    ${cookie}  ==  <%=request.getCookies()%>
    ${initParam['aaa']}  ==  <%=application.getInitParameter("aaa")%>
作用域访问对象
    pageScope   
        与页面作用域(page)中的属性相关联的Map类，主要用于获取页面范围内的属性值
    requestScope    
        与请求作用域(request)中的属性相关联的Map类，主要用于获取请求范围内的属性值
    sessionScope    
        与会话作用域(session)中的属性相关联的Map类，主要用于获取会话范围内的属性值
    applicationScope    
        与应用程序作用域(application)中的属性相关联的Map类，主要用于获取应用程序范围内的属性值

自定义标签

1）作用：用于执行Java代码，替代jsp脚本
2）需求：向浏览器输出当前客户端的ip地址
    jsp页面脚本：Java代码
        String ip = request.getRemoteHost();
        out.write(ip);
    自定义标签
        1.创建一个类继承SimpleTagSupport
        2.实现doTag方法
        3.在doTag方法中获取到pageContext对象，就可以做任何事情了。
        4.在WEB-INF目录下创建一个xxx.tld文件，到tomcat的webapps/examples目录下搜索*tld
        5.说明
            tlib-version 标签库的版本
            jsp-version  jsp的版本
            short-name  引用时的简单名称:引用标签库的名称，我这改为shuai。在jsp页面中的taglib的prefix中写这个。
            uri  引用这个标签库的路径名称，随便写。在jsp页面中的taglib的uri中写这个。
            tag 就是一个标签
                name 标签的名字，这里我使用hello。在jsp页面上使用。
                tag-class 标签的全路径
                body-content 标签内容格式
                    scriptless: 不能写java代码  (推荐)
                    empty:      当前标签为空标签  
                    tagdependent :  可以写java代码，但是不执行（当前普通字符串执行）
                attribute 属性名称 <shuai:hello num="值">
                    name 在标签类中有一个此名称的属性，注意：要有get/set方法
                    required 是否必填
                    rtexprvalue 是否支持el表达式
        6.jsp页面引用 <%@ taglib uri="http://it.shuai.com" prefix="shuai" %>
        7.使用标签 <shuai:hello></shuai:hello>
    自定义标签作用
        1.控制是否输出标签体内容
            doTag中：
                JspFragment body = this.getJspBody();
                PageContext context = (PageContext)this.getJspContext();
                JspWriter out = context.getOut();
                body.invoke(out);//写就可以显示hello，如果不写就不显示。
                //默认代码
                this.getJspBody().invoke(null);
            jsp页面中
                <shuai:hello>
                    hello
                </shuai:hello>
        2.控制是否输出标签后面的内容
            输出：doTag中什么都不做
            不输出：doTag中抛出一个异常，那么jsp中这个标签后的所有HTML内容都不显示
        3.控制重复输出标签体内容
        4.修改标签体内容
            //1)获取原来的标签体内容
            JspFragment jspBody = this.getJspBody();
            //2)创建一个临时容器用于存放标签体内容
            StringWriter sw = new StringWriter();
            //3)暂时把标签体内容写到一个临时容器中
            jspBody.invoke(sw);
            //4)从临时容器中取出内容
            String content = sw.toString();
            //5)修改内容
            content = content.toUpperCase();
            //6)手动写出给浏览器
            this.getJspContext().getOut().write(content);
3）自定义标签执行过程
    1.tomcat服务器检查指令
        <%@ taglib uri="http://it.shuai.com" prefix="shuai" %>
        查询是否存在uri值为http://it.shuai.com的tld文件
        检查prefix
    2.tomcat服务器查找hello这个标签。到这个tld文件中找这个标签。
    3.得到tag-class的内容
    4.构造com.shuai.tags.OneTag对象
    5.调用com.shuai.tags.OneTag对象的方法
4）SimpleTag接口：所有标签处理类都必须实现此接口（这个是标准）
    生命周期方法
        setJspContext() 设置pageContext对象
        setParent() 设置父的标签对象，如果没有父标签，则不会调用。
        setJspbody() 设置标签体内容，没有标签体内容，则不调用此方法
        doTag() 执行标签方法
5）自定义foreach遍历标签
6）自定义if写法
7）自定义choose:when+otherwise写法
8）打jar包
    1.导出jar包，只留src下的tag标签
    2.jar包中只留标签目录和META-INF目录即可。其它的删掉（META-INF就相当于WEB-INF目录）
    3.把tld文件拷贝到jar包中的META-INF目录下即可。
9）其它
    获得标签体的内容
        <shuai:choose name="test">
            shuaige
        </shuai:choose>
        //获取标签内容并且输出
        JspFragment body = getJspBody();
        StringWriter sw = new StringWriter();
        body.invoke(sw);
        System.out.println(sw.toString());
        JspWriter out = this.getJspContext().getOut();
        out.write(sw.toString());
    输出标签内容
        <shuai:choose name="test">
            shuaige
        </shuai:choose>
        JspFragment body = getJspBody();
        body.invoke(null);
        或者
        JspFragment body = getJspBody();
        JspWriter out = this.getJspContext().getOut();
        body.invoke(out);
    添加标签属性
        <shuai:choose name="test">
            shuaige
        </shuai:choose>
        private String name;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        <tag>
            <name>choose</name>
            <tag-class>com.shuai.tag.OneTag</tag-class>
            <body-content>scriptless</body-content>
            <attribute>
                <name>name</name>
                <required>true</required>
                <rtexprvalue>true</rtexprvalue>
            </attribute>
        </tag>
获取上下文
    JspContext context = this.getJspContext();

jsp指令 - page

通过属性定义了JSP的特性，实现与JSP容器的通信
语法:
    <%@ page 属性="值"%>
详细介绍:
    language="java" 
        语言是Java语言
    contentType="text/html; charset=UTF-8"  
        指定当前JSP页面的MIME类型和字符编码
        翻译成response.setContentType(""); 通知浏览器的内容和编码
        注意：contentType的默认值和pageEncoding的值保存一致。
    pageEncoding="UTF-8" 
        指定当前页面的编码格式,服务器用什么编码翻译成Java文件
    buffer="8kb" 
        指定out对象使用缓冲区的大小，默认8kb
        有了缓存区之后，内容满足以下条件才会写到浏览器：
            1）缓存区满了。
            2）jsp执行完毕
            3）手动刷新缓存区
            4）设置缓存区为0（也就是没有缓存区）
            注意：只有out才有缓存区，response.getWriter().write()没有缓存
    autoFlush="true" 
        控制out对象的 缓存区
    errorPage="error.jsp" 
        指定当JSP页面发生异常时需要转向的错误处理页面
    isErrorPage="true" 
        指定当前页面是否可以作为另一个JSP页面的错误处理页面
        当前jsp页面就是错误页面，
        只有设置了此属性，才能使用exception。否则无法使用。
        错误页面显示错误信息<%=exception.getMessage()%>
    extends="javax.servlet.http.HttpServlet" 
        指定当前jsp页面的servlet从哪一个类继承
    import="java.util.ArrayList" 
        导入要使用的Java类。
        在jsp导入包。
        默认导入java.lang.* 。
        多个包用逗号,隔开
    info="onejsp" 
        定义JSP页面的描述信息
    isThreadSafe="true" 
        指定对JSP页面的访问是否为线程安全，默认是true
    session="true" 
        指定JSP页面是否使用session，默认是true
        是否打开httpSession功能。
    isELIgnored="false" 
        指定是否执行EL表达式,默认是false
        是否忽略EL表达式，false不忽略(默认)，true忽略
具体使用:
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <%@ page buffer="8kb" autoFlush="true"%>
    <%@ page errorPage="error.jsp" isErrorPage="true"%>
    <%@ page extends="javax.servlet.http.HttpServlet"%>
    <%@ page import="java.util.ArrayList"%>
    <%@ page info="onejsp"%>
    <%@ page isThreadSafe="true"%>
    <%@ page session="true"%>
    <%@ page isELIgnored="false"%>

jsp指令 - include

语法：
    <%@ include file="界面" %>
详细介绍:
    file="common.jsp" 指定包含其他文件,相对路径或者绝对路径
具体使用:
    <%@ include file="common.jsp" %>
注意:
    file="/common.jsp" 路径是WebContent下 
    file="common.jsp" 路径是WebContent下

jsp指令 - taglib

概述
    引入标签库的定义
    指令引入一个自定义标签集合的定义，包括库路径、自定义标签
语法：
    <%@ taglib 属性="值" %>
详细介绍:
    uri="http://java.sun.com/jsp/jstl/core"  标签库的描述URI
    prefix="c" 指定一个前缀prefix
    tagdir="/WEB-INF/tags" 其中的tags是个目录，里面有若干tag文件
具体使用:
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    <%@ taglib prefix="sys" tagdir="/WEB-INF/tags" %>
注意:
    一般我们只是使用 uri + prefix
    tagdir 是自定义标签库

jsp中内置的Java对象

jsp页面在执行过程中，为开发者提前创建好了一些开发中常用的对象。
    config
        ServletConfig类的实例。
        这个对象允许开发者访问Servlet或者JSP引擎的初始化参数，比如文件路径等。
    out 
        JSPWriter用来写入响应流的数据，JspWriter类的实例，用于把结果输出至网页上
        包含了大部分java.io.PrintWriter类中的方法
    page
        servlet自身，类似于Java类中的this关键字
    pageContext
        一个PageContext实例包括和整个页面相联系的数据，一个给定的HTML页面可以在多个JSP之间传递。
        PageContext类的实例，提供对JSP页面所有对象以及命名空间的访问。
        主要用来访问页面信息，同时过滤掉大部分实现细节。
        存储了request对象和response对象的引用。
        application对象，config对象，session对象，out对象可以通过访问这个对象的属性来导出。
        包含了传给JSP页面的指令信息，包括缓存信息，ErrorPage URL,页面scope等。
        定义了一些字段，包括PAGE_SCOPE，REQUEST_SCOPE，SESSION_SCOPE， APPLICATION_SCOPE。
        它也提供了40余种方法，有一半继承自javax.servlet.jsp.JspContext 类。
        其中一个重要的方法就是removeArribute()，它可接受一个或两个参数。
        作用：
            1）可以获取其它8个内置对象
                自定义标签时经常用到这个。
            2）是一个域对象 作用范围是当前的jsp范围
                可以把数据保存在jsp页面范围内
                可以把数据保存在其它三个域对象,setAttribute(key,value,域常量);getAttribute(key,域常量);
                    域常量：PAGE_SCOPE,REQUEST_SCOPTE,SESSION_SCOPE,APPLICATION_SCOPTE
            3）可以从4个域自动搜索数据findAttribute(key);
                搜索属性：从小到大：page-->request-->session-->application 找不到就是空
    request
        HTTP request对象，HttpServletRequest类的实例。
        是javax.servlet.http.HttpServletRequest 类的实例。
        每当客户端请求一个JSP页面时，JSP引擎就会制造一个新的request对象来代表这个请求。
        提供了一系列方法来获取HTTP头信息，cookies，HTTP方法等等。
    response
        HTTP response对象，HttpServletResponse类的实例。
        是javax.servlet.http.HttpServletResponse类的实例。
        当服务器创建request对象时会同时创建用于响应这个客户端的response对象。
        定义了处理HTTP头模块的接口。通过这个对象，开发者们可以添加新的cookies，时间戳，HTTP状态码等等。
    session 
        HttpSession类的实例，用于保持客户端与服务器连接的对象
        用来跟踪在各个客户端请求间的会话。
    application 
        ServletContext类的实例，与应用上下文有关。
        这个对象在JSP页面的整个生命周期中都代表着这个JSP页面。
        这个对象在JSP页面初始化时被创建，随着jspDestroy()方法的调用而被移除。
        通过向application中添加属性，则所有组成您web应用的JSP文件都能访问到这些属性。
    exception    
        Throwable  异常对象

内置对象 - out对象

说明:
    混合写Java代码
语法：
    <% 在此区域写Java代码 %>
详细介绍:
    
具体使用:
    <%
        out.println("输出到界面<br/>");
        out.print("aaa<br/>");
        out.print("bbb<br/>");
        out.print("ccc<br/>");
    %>
注意:
    1.输出乱码问题：
        1.1页面必须要引入
            <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        1.2jsp的文件编码要是UTF-8
    2.println与print方法
        均不能使页面换行,必须添加<br/>

内置对象 - request对象

说明:
    混合写Java代码
语法：
    <% 在此区域写Java代码 %>
详细介绍:
    
具体使用:
    <%
        //获取用户提交的数据
        //返回指定参数名称数值，返回类型为String类型，若无对应名称的参数，返回NULL
        String name = request.getParameter("name");
        //返回具有相同参数名称的数值集合，返回类型为String类型的数组
        String[] names = request.getParameterValues("name");
        //设置请求时的编码
        request.setCharacterEncoding("UTF-8");
        //通过属性存储/获取值
        //使用属性存取数据时，要确保数据在保存时必须是Object类型，而在取出时还要转换成原先自己的类型
        //通过属性存储值
        request.setAttribute("desc", "zhangsan");
        //通过属性获取值
        String desc = (String)request.getAttribute("desc");
        //转发
        request.getRequestDispatcher("info.jsp").forward(request, response);
    %>

内置对象 - response对象

说明:
    混合写Java代码
语法：
    <% 在此区域写Java代码 %>
详细介绍:
    对请求作出响应并返回结果
具体使用:
    <%
        //设置响应时的编码
        response.setCharacterEncoding("UTF-8");
        //重定向
        response.sendRedirect("info.jsp");
    %>
注意:
    重定向是对请求的重新定位，所以重定向后，原请求中的数据将会丢失

内置对象 - session对象

说明:
    混合写Java代码
语法：
    <% 在此区域写Java代码 %>
详细介绍:
    用于存储与用户相关的会话信息
    setAttribute(String key,Object obj) 以key/value形式保存数据
    getAttribute(String key)    通过key获取数据
    getId() 获取sessionid
    invalidate()    设置session对象失效
    setMaxInactiveInterval(int interval)    设置session对象有效期
    removeAttribute(String key) 移除session中的属性
具体使用:
    <%
        //存储/获取数据
        //存储数据
        session.setAttribute("name", "zhangsan");
        //获取数据
        String name = (String)session.getAttribute("name");
    %>

cookie

说明:
    由服务器端生成，发送到客户端保存的一段文本信息
语法：
    <% 在此区域写Java代码 %>
详细介绍:
    使用Cookie记录上网浏览的信息
    在页面请求时，可以带着cookie到后台。
    可以在响应页面时，返回设置cookie。
    Cookie的常用方法
        setMaxAge(int expiry)   设置Cookie的有效期，以秒为单位
        setValue(String value)  创建Cookie后，为Cookie赋值
        getName()   获得Cookie的名称
        getValue()  获得Cookie的值
        getMaxAge() 获取Cookie的有效期，以秒为单位
具体使用:
    <%
        //创建Cookie
        Cookie cookie = new Cookie("name","zhangsan");
        //写入Cookie
        response.addCookie(cookie);
        //读取 Cookie
        Cookie[] cookies = request.getCookies();
        for(int i = 0;i<cookies.length;i++){
            //获取指定的cookie
            Cookie cookie1 = cookies[i];
            //获取cookie的值
            String value = cookie1.getValue();
        }
    %>

jsp内置标签

特点
    是jsp语法内设计的一些标签，使用这些内置标签不需要导入tld或者jar包
jsp标签优点
    封装页面显示功能
    页面代码简介
    提高可读性，易于维护
标签
    jsp:useBean
        会默认创建对象
        id 对象名
        class 引用类的地址,要全路径
        scope 作用域
        beanName
        type
    jsp:setProperty 
        设置对象属性的值
        name 对象名
        property 对象的属性名
        value 属性值
    jsp:getProperty
        获取对象属性的值
        name 对象名
        property 对象的属性名
    jsp:include
        动态页面包含
        使用页面包含技术实现最大限度的页面复用
        分类
            静态页面包含
                先将页面包含，后执行页面代码，即将一个页面的代码复制到另一个页面中
                被包含的页面内容发生变化时，包含页面将会被重新编译
            动态页面包含
                先执行页面代码，后将页面包含，即将一个页面的运行结果包含到另一个页面中
                被包含页面内容发生变化时，包含页面不会重新编译
        静态包含
            <%@include file="URL "%>
    jsp:forward 
        转发
        代码
            <%-- 服务器路径 --%>
            <jsp:forward page="info.jsp">
                <%-- 转发时带路径 --%>
                <jsp:param value="zhangsan" name="name"/>
            </jsp:forward>
    jsp:param 
        参数标签
    jsp:include 
        被包含的页面将会被翻译
        代码
            <%-- 服务器路径 ， 会把两个页面合并在一起 --%>
            <jsp:include page="header.jsp"></jsp:include>
        <%@ include %> 包含页面，被包含的标签不会被翻译
            <%@ include %>指令包含是先合并再翻译，叫静态包含。
            jsp:include标签包含是先翻译后合并，叫动态包含。
            <%@ include %>指令包含可以使用被包含页面的变量（数据）。
            jsp:include标签包含不可以使用被包含页面的变量（数据），建议使用静态包含。

jstl标签库

说明
    java standard tag library
    JSP标准标签库
    实现JSP页面中的逻辑控制
特点：
    需要导入标签库
分类：
    1.核心标签库：core c
    2.国际化/格式标签库 format fmt
    3.EL函数库 fn，在jsp页面上简化String的操作
    4.SQL标签库 sql - 不用
    5.XML标签库 xml x - 不用
核心标签库：core c
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    c:set
        保存数据到域对象中
        <c:set var="变量名" value="变量值" scope="域"></c:set>
        <c:set value= "变量值" target="对象名称" property="对象的属性名称" />
        <c:set var="name" value="shuaige" scope="request" property="user"></c:set>
    c:out
        从域对象中取出数据
        <c:out value="${el表达式 }" default="默认值" escapeXml="默认值是html标签时是否转义"></c:out>
        <c:out value="name" default="shuaige1" escapeXml="true"></c:out>
    c:if
        单条件判断
        <c:if test="条件" scope="判断结果存放的作用域">条件为true时显示</c:if>
        <c:if test="${1==1}">
            <p>如果条件成立显示内容</p>
        </c:if>
    c:choose/c:when/c:otherwise
        多条件判断
        <c:choose>
            <c:when test="条件">条件为true时显示</c:when>
            <c:when test="条件">条件为true时显示</c:when>
            <c:otherwise>上边的条件都不成立时显示</c:otherwise>
        </c:choose>
        <%
            request.setAttribute("score", 90);
        %>
        <c:choose>
            <c:when test="${score >=90 }">条件成立大于90</c:when>
            <c:when test="${score >=80 }">条件成立大于80</c:when>
            <c:otherwise>以上条件不成立小于80</c:otherwise>
        </c:choose>
    c:forEach
        遍历集合或数组
        <c:forEach items="需要遍历的数据" var="遍历时，每个对象的名称" begin="从哪个元素开始，从0开始" end="到哪个元素结束" step="步长，就是条件增加多少" varStatus="把当前元素的状态信息封装到次元素vs中，第几个元素count ${vs.count }"></c:forEach>
        <c:forEach items="${list }" var="student" begin="0" end="10" step="1" varStatus="vs">
            ${vs.count } - ${student.name }
        </c:forEach>
    c:forTokens
        遍历字符串
        <c:forTokens items="要处理的字符串" delims="split的符号" var="分隔后每个元素的名称"></c:forTokens>
        <c:forTokens items="${strs }" delims="-" var="str" begin="0" end="10" step="1" varStatus="vs">
            ${vs.count } - ${str }
        </c:forTokens>
    c:url
        简化URI的编写
        <c:url value="url路径，服务器路径"></c:url>
    c:redirect
        重定向
        <c:redirect url="重定向路径"></c:redirect>
    c:param
        参数标签
        <c:param name="参数名称" value="参数的值"></c:param>
    c:import
        导入标签
        <c:import url="导入资源的路径"></c:import>
    c:remove
    c:catch
EL函数库 fn 
    用来处理字符串
    <%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
    toUpperCase
        小写转大写
        ${fn:toUpperCase(str) }
        <%
            request.setAttribute("name", "zhangsan");
        %>
        ${fn:toUpperCase(name) }
    toLowerCase
        大写转小写
        ${fn:toLowerCase(str) }
        <%
            request.setAttribute("name", "SHUAIGE");
        %>
        ${fn:toLowerCase(name) }
    length
        字符串长度
        ${fn:length(str)}
        <%
            request.setAttribute("name","shuaige");
        %>
        ${fn:length(name) }
    contains
        包含某个字符串
        <%
            request.setAttribute("name", "shuaige");
        %>
        ${fn:contains(name,'ge') }
        ${fn:contains(name,"ge") }
    containsIgnoreCase
        是否包含(忽略大小写)
        <%
            request.setAttribute("name", "shuaige");
        %>
        ${fn:containsIgnoreCase(name,'Ge') }
        ${fn:containsIgnoreCase(name,"Ge") }
    endsWith
        以什么结尾
        <%
            request.setAttribute("name", "shuaige.txt");
        %>
        ${fn:endsWith(name,'.txt') } 
    escapeXml
        html标签是否生效
        <%
            request.setAttribute("name","<p>shuaige</p>");
        %>
        ${name }<br/>
        ${fn:escapeXml(name) }
    indexOf
        查找某个字符第一次发现的下标
        <%
            request.setAttribute("name", "shuaige.txt");
        %>
        ${fn:indexOf(name,'.') }
    join
        把数组以某个分隔符拼接成字符串
        <%
            String[] str = {"aaa","bbb","ccc"};
            request.setAttribute("str",str);
        %>
        ${fn:join(str,'-') }
    replace
        替换
        <%
            request.setAttribute("name","shuai;ge");
        %>
        ${fn:replace(name,";","") }
    split
        以某个分割符分割
        <%
            request.setAttribute("name","shuai;ge");
        %>
        <c:forEach items="${fn:split(name,';')}" var="str">
            <p>${str }</p>
        </c:forEach>
    startsWith
        以某个字符开始
        <%
            request.setAttribute("name","shuaige");
        %>
        ${fn:startsWith(name,"shuai")}
        ${fn:startsWith(name,'shuai')}
    substring
        截取
        <%
            request.setAttribute("name","shuaige");
        %>
        ${fn:substring(name,0,5) }
    substringAfter
        截取
        <%
            request.setAttribute("name","shuaige");
        %>
        ${fn:substringAfter(name,"shuai") }
    substringBefore
        截取
        <%
            request.setAttribute("name","shuaige");
        %>
        ${fn:substringBefore(name,"ge") }
    trim
        去掉前后空格
        <%
            request.setAttribute("name", "  shuaige  ");
        %>
        ${fn:trim(name) }
fmt标签
    格式化
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
    fmt:formatDate
        实现格式化的日期和时间显示
        <fmt:formatDate value="date" pattern="显示格式"/>
        <fmt:formatDate  value= " date" pattern="yyyy-MM-dd HH:mm:ss"/>
    fmt:bundle
    fmt:formatNumber
    fmt:message
    fmt:param
    fmt:parseDate
    fmt:parseNumber
    fmt:requestEncoding
    fmt:setBundle
    fmt:setLocale
    fmt:setTimeZone
    fmt:timeZone

通过设置页面的基路径避免使用相对路径

在页面上取得项目路径：
    <%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+
    request.getServerName()+":"+
    request.getServerPort()+path+"/";
    %>
在<head>中添加：
    <base href="<%=basePath%>">

国际化

src目录下
    message_en_US.properties
    message_zh_CN.properties
    message_en_GB.properties
测试读取
    ResourceBundle bundle = ResourceBundle.getBundle("message", Locale.CHINA);
    String username = bundle.getString("username");
    String password = bundle.getString("password");
项目读取
    ResourceBundle bundle = ResourceBundle.getBundle("message", Locale.getDefault());
    String username = bundle.getString("username");
    String password = bundle.getString("password");
jsp页面使用
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
    <fmt:setBundle basename="message"/><%--绑定资源包 --%>
    <fmt:message key="username"/><%--读取资源包中的key --%>
    

日期数字格式化