jsp详解

JSP概念
    Servlet是j2ee提供的动态资源开发技术,
    是以java的程序的形式进行开发,
    在java中书写HTML标签是一件十分头疼的事情,
    所以人们开发出了JSP,看起来像是HTML一样,
    但是通过服务器的编译最终可以生成Servlet
    动态网页技术

    页面不需要改变->改变数据库数据

    jsp = html + java


1、jsp页面中可以写哪些内容
        1.html标签
    2.css
    3.jstl标签库
    4.java代码
    5.EL表达式
    6.javascript

    页面会非常乱.java+html+css+js
    不容易修改

    .jsp -->  .java --> .class
         翻译

2、jsp是如何工作的以及jsp的特点.
     1.jsp页面其实就是一个servlet。
     2.jsp页面的运行需要服务器的支持。
     3.服务器中的jsp引擎可以帮我们去运行jsp页面。(注意并不是所有服务器都有这样的引擎的.引擎其实就是别人写的支持jsp页面运行的jar包或者代码)
     4.jsp页面在运行之前,要经过几个步骤:首先jsp页面要被翻译成.java文件,然后再编译成.class文件,
        最后再运行这个.class文件.(创建这个类的对象,调用指定方法_jspService,方法中把页面里面要显示的内容用io流一行行的写给浏览器)
     5.jsp翻译成的.java文件中,其实就是写了一个servlet,在这个类中的方法里面,用io流,把jsp页面中的内容一行一行的输出给了浏览器。
        因为这是在java类中的方法里面做的事情,所有很多数据我们都可以用变量来表示,同时也可以调用其他类中的方法.
        (在这里,jsp动态页面的效果也就体现出来.)
     6.运行jsp页面过程中,jsp引擎帮我们去翻译或者编译成的.java文件和.class文件都保存在了tomcat中的work目录里面。
     7.通过上述jsp的特点可知,写完一个项目之后,第一次部署运行的时候,整个项目的运行jsp速度会慢一些,因为第一次访问运行jsp的时候,
        需要先翻译成.java文件然后再编译成.class文件,最后再运行,这个过程会耗费一些时间,但是第二访问运行的时候就会比较快了.

     8.访问项目中的一个jsp页面的时候,服务器首先会检查你所访问的这个jsp页面是否存在,如果不存在,服务器直接给你返回404,
        如果存在,服务器会进一步检查有没有和这个jsp页面对应的.class文件,如果有的话就直接运行这个.class,如果没有的话,
        则先把这个jsp页面翻译成.java,然后再编译成.class,最后再运行这个.class文件.

     9.jsp页面其实就是在html页面中直接写上java代码.但是,在一个jsp页面中,可以没有任何html的代码而只有java代码,
        也可以没有任何java代码只有html的代码.

     10.servlet能做的事情jsp全能做。


3、jsp中的元素:三大元素
    1,脚本元素  
        <%!  声明  %>
        <%= 表达式 %>
        <% 脚本 %>
        脚本元素 对应在 java文件什么位置
    2,指令元素  <%@ 指令 %>
    3,动作元素  <jsp:out>:为了避免在jsp中写过多的脚本元素
 1) 脚本元素
    a) 声明(Declaration):相当于在类中方法外的代码
        语法: <%!  %> jsp页面任何地方
        作用: 在servlet中声明一些成员变量、成员方法和内部类
        特点: 声明被翻译进servlet后变成了成员变量、成员方法和内部类
        注意: 不能使用表达式和隐含对象-->jsp--9

    b) 表达式(Expression):相当于在_jspServlet()方法中的 out.println(表达式);代码
        语法: <%= expression %>
        作用: 将expression输出到out(输出流)中,expression可以是算术、逻辑、关系表达式、变量、有返回值的方法、jsp中的9种隐含对象。
        9种隐含对象:
          page pageContext request response session application out config exception

        特点: 表达式翻译进servlet后变成了out.print(expression),该代码处于
        _jspService()方法中;

        注意: expression都一律被转换成字符串后再写到输出流out(JspWriter)中。另外,expression中不能有分号(;)。

    c) 脚本(Scriptlet):相当于_jspService(...){脚本}中代码
         语法: <% java code %>
         作用: 在jsp中嵌入该jsp转化成的_jsp.jsp代码,不能嵌入成员变量、成员方法。
         特点: 脚本被翻译进servlet的_jspService()方法中。

 2) 指令元素
    a) page指令
        语法: <%@ page attributeName="attribuerValue"...%>
        作用: 利用page指令中的属性可以和容器进行通信,这些属性的设置对整个jsp都有影响。

     page指令中的属性:
      language="java"
         表示当前页面中的编程语言是java,目前这个属性值只能写java
      import="package.class,package2.class2"
        在当前页面中要引入哪些包下的类.和一般的java import意义一样,用","来隔开,
        import="java.util.*"
        import="java.util.HashMap,java.sql.Connection"

      session="true|false"  默认为true
        用来指定当前页面是否支持使用session,如果设置为true,则翻译过来的servlet中将会有对session对象的引用,于是可以直接在jsp中使用session隐式对象。但是这将导致一旦访问jsp就会调用request.getSession()方法,可能导致不必要的空间浪费。如果确定jsp中不需要session可以设为false
      buffer="none|8kb|sizekb" 默认为8kb
        out隐式对象所使用的缓冲区的大小
      autoFlush="true|false"  默认为true
        out隐式对象是否自动刷新缓冲区,默认为true,不需要更改
      isThreadSafe="true|false"  默认为true
        翻译过来的servlet是否实现SingleThreadModel
      info="text"
         关于jsp页面的信息,定义一个字符串,可以使用getServletInfo()获得
      errorPage="b.jsp"   默认忽略
        如果页面出错,将要跳转到的页面,除了在jsp中使用此属性指定错误页面外也可以在web.xml中配置整个web应用的错误页面,如果两个都设置则jsp中的此属性起作用

      isErrorPage="true|false"   默认为false
        表明当前的页面是否为其它页面的errorPage目标,如果设置为true,则可以使用exception对象。反之,如果设置为false,则不可以使用exception对象
      extends="package.class"
         设置jsp页面被翻译成java文件的时候,java文件中的类要继承那个父类.这个属性不用设置,jsp引擎会给它一个默认的父类去继承的.
      isELIgnored="true|false"
        指定EL表达式语言是否被忽略,如为true则忽略,反之可以使用EL。

      contentType="text/html;charset=UTF-8"
        定义response中的内容类型和jsp页面的编码格式,
        翻译后变成response.setContentType("text/html;charset=UTF-8")。
      pageEncoding="UTF-8"
        设置jsp页面文件保存时候所用的编码,实现功能跟contentType="text/html;charset="UTF-8"一致,但是两者若同时设置,jsp页面的编码格式以pageEncoding为准,response中的内容类型和编码格式以contentType为准。
    
    b) include指令 : 静态导入
         语法: <%@ include file="url"%>,称为静态导入(静态包含)
         作用: 在一个页面中导入另一个页面的内容(这些内容一般不会有变化,如公司的标题和版权等信息)。

         特点: 在jsp翻译成servlet后就将被导入的页面内容嵌入到servlet中。
               导入时间发生在翻译阶段。
         被导入的资源: html、xml、jsp等
         优点: 执行效率高
         缺点: 当被导入页面的内容发生变化,那么jsp必须要重新被翻译。

    c) taglib指令是定义一个标签库以及其自定义标签的前缀.
        <%@ taglib uri="" prefix=""%>
        指定在jsp中要使用的标签库描述文件(*.tld)的路径
        prefix="给标签库取的别名"
        uri="标签库的路径"

3) 动作元素(jsp自带的标准标签)
    
    减少在jsp页面编写java代码

    jsp基本动作元素:
        jsp:attribute    设置动态定义的XML元素属性。

        jsp:body    设置动态定义的XML元素内容。

        jsp:element    定义动态XML元素

        jsp:fallback    回滚,下载失败则显示里面的内容,此标记只能在<jsp:plugin>内部使用

    *    jsp:forward    把请求转到一个新的页面。该操作允许将请求转发到另一个JSP,Servlet或者静态资源文件。一旦遇上此标记即会停止执行当前的JSP,转而执行被转发的资源。
                <jsp:forward page="sucess.jsp">

        jsp:getProperty    输出某个JavaBean的属性。此操作是对<jsp:setProperty>操作的补充,它用来访问一个Bean的属性。它访问的属性值将它转化成一个String,然后发送到输出流中。如果属性是一个对象,将调用toString()方法,
                <jsp:getProperty name="beanName" property="propertyName">

    *    jsp:include    在页面被请求的时候引入一个文件。该操作允许在请求的时间内在现成的JSP页面里面包含静态或动态的资源。被访问的对象对JSP write对象的访问权,并且它不能设置头或者Cookie.如果页面输出是缓冲的,那么缓冲区的刷新要俦于包含的刷新。因此它在运行效率上比<%@   include  file="include.html"%>要低,但它可以动态增加内容,使用
                <jsp:include page="two.jsp" flush="true">

    *    jsp:param    操作被用来以“名-值”对的形式为其他标签提供附加信息。写一般与<jsp:forward>,<jsp:include>,<jsp:plug>,一起使用。
                <jsp:param name="paramName"  value="paramValue"/>

        jsp:params    表示需要向Applet或Bean传送的参数或值

        jsp:plugin    根据浏览器类型为Java插件生成OBJECT或EMBED标记。此操作是用来产生客户端浏览器的特别标签(Object或者embed),可以使用它来插入Applet或者JavaBean。一般来说<jsp:plugin>元素指定的对象是Applet还是Bean,同样也会指定class的名字,另外还会指定将从哪里下载这个Java插件。
                <jsp:plugin type=applet  code="efly.testMyApplet.class"  codebase=".">
                    <jsp:params>
                        <jsp:param  name="aParameterName"  value="aParameterNameValue"/>
                    </jsp:params>
                    <jsp:fallback>
                        <p>Unable  to  load  applet.</p>
                    </jsp:fallback>
                </jsp:plugin>
                解释:
                    1:type="bean/applet"
                    2:code="classFileName"  插件执行JAVA类文件的名称。在名称中必须加上扩展名,且此文件必须放在用 codebase属性的目录下。
                    3:codebase="classFileDirectoryName"这包含插件将运行的JAVA类的目录或指向这个目录的路径。默认为JSP文件的当前路径。
                    4:name="instanceName" 这是Bean或Applet的实例的名称。使得被同一个JSP文件调用的Bean或Applet之间的通讯成为可能。
                    5:archive="URIToArchive,……"这是以逗号分隔的路径名列表,是那些用于codebase指定的目录下的类装载器预装载的存档文件所在的路径名。
                    6:align="botton/top/middle/left/right"图形,对象,Applet的排列方式。
                    7:height="displayPixels"  width="displayPixels"  显示的高宽
                    8:hspace="leftRightPixels"  vspace="topBottomPixels"  左右  上下留下空间大小
                    9:jreversion="JREVersionNumber | 1.1" 这是Applet或Bean运行时所需的JRE版本
                    10:nspluginurl="URLToPlugin" 这是Netscape Navigator用户能够使用的JRE下载地址
                    11:iepluginurl="URLToPlugin" 这是Internet Explorer用户能够使用的JRE下载地址

        jsp:setProperty    设置JavaBean的属性。此操作与useBean协作,用来设置Bean的简单属性和索引属性。<jsp:setProperty>标签使用Bean的setXXX()方法。利用它设置属性多种方法。Bean的自省(introspection)用来发现出现的是哪些属性和它们的名字是什么,这些属性是简单的还是索引的,它们有什么类型等,用以下方法使用
                 <jsp:setProperty name="beanName"  property="propertyName" value="propertyValue"/>


        jsp:useBean    寻找或者实例化一个JavaBean。此标签用于在JSP页面中创建一个Bean实例,并指定它的名字及作用范围。它保证对象在标签指定的范围内可以使用。
                创建:
                <jsp:useBean id="shopcar" scope="session" class="com.briup.Carts"/>
                <jsp:setProperty name="shopcart" property="*"/>
                寻找:
                <jsp:useBean id="checking" scope="session" class="com.briup.Checking">
                    <jsp:setProperty name="checking" property="balance" value="0.0"/>
                </jsp:useBean>
                scope的取值可以是page/request/session/application 范围依次递增!
            相当于代码:
               <%
                com.briup.Carts shopcar = null;
                shopcar = (Carts)pageContext.getAttribute("shopcar");
                if(shopcar==null){
                    shopcar = new Carts();
                    pageContext.setAttribute("shopcar",shopcar);
                }
               %>


    语法: <jsp:tagName/>

    a) 动态导入(动态包含)
       语法: <jsp:include page="url" flush="true|false"/> 或者
           <jsp:include page="url" flush="true|false">
            {<jsp:param …/>}*
           </jsp:include>

      特点: 动态导入发生在执行阶段,也就是在运行serlvet的时候才动态生成被导入页面的内容,然后嵌入到调用页面,最后将两个页面的内容一起返回给客户端。
      注意: 在翻译(.jsp->.java)阶段并没有生成被导入页面的内容。

      缺点: 执行效率没有静态导入高
      优点: 如果被导入页面的内容发生变化,调用页面不必重新翻译。

       b) forward(服务器内部跳转)
      语法: <jsp:forward page="url"/>或者
        <jsp:forward page="url">
                   {<jsp:param …/>}*
        </jsp:forward>

4、jsp中的注释
    a) HTML/XML注释
    语法: <!-- content -->
    注意: 它只能注释html、xml中的静态内容。不能注释脚本元素、指令元素和动作元素。如果注释,它们还是会被编译执行。

    b) 隐藏注释
    语法: <%-- content --%>
    注意: 它可以注释jsp中所有的内容。

    c) 脚本注释
    语法: <    %
        //java code

        /**
          java code
        */

        /*
           java code
        */
          %>

三种注释的区别:
           servlet源文件    客户端页面源文件         浏览器显示

HTML/XML注释        出现           出现                  不显示

隐藏注释         不出现          不出现              不显示

脚本注释        出现          不出现              不显示


    静态导入: <%@ include %>
    特点:-->a_jsp.java会包含两个页面中所有的数据
    翻译阶段发生
    动态导入: <jsp:include>
    特点:a.jsp-->b.jsp-->a_jsp.java不会包含b.jsp的内容
    留下一个b.jsp的引用
    在代码运行的时候(运行的时候导入)


 5) JSP九大隐含对象也叫九大内置对象
    
    JSP容器生成的Servlet类的_jspService()方法中,定义的几个对象我们可以在编写
    

     JSP页面时使用的隐含对象。
    page:当前的jsp页面,指针this
    pageContext:当前的jsp页面的上下文:容器
    request:封装请求的信息
    response:封装响应
    session:会话
    application:指web应用
    out:输出流
    config :配置信息
    exception:异常信息

    在哪里声明?
    _jspService()
jsp 三大元素
    四大容器: pageCentext : 当前页面
          request
          session
          application
   九大内置对象:
    page---> this
    pageContext  --> 当前页面容器
    request  
    response
    session
    application
    out
    config
          
脚本元素
    <%    %>

    <%= 表达式  %>
    
    <%! 声明 %>
指令元素
动作元素


    



    pageContext 对象提供了访问其他隐含对象的方法
    getRequest()
    getResponse()
    getSession()
    getServletContext()
    JspWriter getOut()
    getServletConfig()
    Object getPage()
    Exception getException()

    pageContext还可以用来保存属性,但是只能在当前页面中获取
      setAttribute(String name,Object val);
      Object getAttribute(String name);
    
    pageContext还可以设置和得到其他范围对象中保存的属性
      setAttribute(String name,Object val,int scope);
      Object getAttribute(String name,int scope);
      removeAttribute(String name,int scope)删除指定范围内名字为name的属性
      removeAttribute(String name)        删除所有范围内名字为name的属性
      findAttribute(String name)    该方法会按照page,request,session,application
            范围顺序搜索指定名字的属性。

        PageContext.PAGE_SCOPE        页面范围
        PageContext.REQUEST_SCOPE    请求范围
        PageContext.SESSION_SCOPE    会话范围
        PageContext.APPLICATION_SCOPE    应用程序范围
    exception
    对象表示了JSP页面运行时产生的异常,该对象只有在错误页面(page指令中指定
    isErrorPage=true的页面)中才可以使用。当JSP页面运行发生错误时,JSP容器会
    自动调用指定的错误处理页面,如果JSP页面使用errorPage属性定义了错误页面,
    那么在web.xml文件中定义的任何错误页面将不会被使用

  6) 对象和范围
    在JSP中,有4中范围
    page范围:--->pageContext
      具有page范围的对象被绑定到javax.servlet.jsp.PageContext对象中,在这个
      范围中的对象,只能在创建对象的页面中访问。page范围内的对象,在客户端
      每次请求JSP页面时创建,在页面向客户端发送回响应或请求被转发到其他资源
      后被删除。
    request范围
      具有request范围的对象被绑定到javax.servlet.http.HttpServletRequest对象
      中。在调用forward()方法转向的页面或调用include()方法包含的页面中,都可
      以访问这个范围内的对象。
    session范围

      具有session返回的对象被绑定到javax.servlet.http.HttpSession对象中,JSP
      容器为每次会话,创建一个HttpSession对象,在会话期间,可以访问session
      范围内的数据
    application范围
      具有application范围的对象被绑定到javax.servlet.ServletContext中,在web
      应用程序运行期间,所有页面都可以访问这个范围内的对象。


            JSTL

什么JSTL
    第三方标签库,是一个JSP标签集合,需要导入jar包才可以使用。
    该标签库可以完成更复杂的功能,比如可以完成遍历集合,条件判断,循环等功能。
    根据标签功能,JSTL标签库可分5类:
        核心标签库    <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
        I18N格式化标签库<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
        SQL标签库    <%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
        XML标签库    <%@taglib prefix="xml" uri="http://java.sun.com/jsp/jstl/xml" %>
        函数标签库    <%@taglib prefix="functions" uri="http://java.sun.com/jsp/jstl/functions" %>

    使用原因:
        不希望在jsp页面中出现java逻辑代码。
相关jar包
    老版本:
    standard.jar 标准jar包,定义规范
    jstl.jar   具体实现jar包
    新版本:
    jstl-1.2.jar
    注意:
    1)web工程导包需要将包copy到WEB-INF下lib文件夹中。
    2)在jsp页面中导入标签库。
        如核心标签库的引入:
        <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
核心标签库,可分为四大类

    第一类:表达式控制标签
        <c:out>:用于在JSP中显示数据,就像<%= ... >
        <c:set>: 用于将数据放到容器中(4大容器)
        <c:remove>: 用于删除容器中数据
        <c:catch>: 用来处理产生错误的异常状况,并且将错误信息储存起来
    第二类:流程控制标签
        <c:if>:与我们在一般程序中用的if一样
        <c:choose>: 本身只当做<c:when>和<c:otherwise>的父标签
        <c:when>: <c:choose>的子标签,相当于 else if() 用来判断条件是否成立
        <c:otherwise>: <c:choose>的子标签,相当于 else{} 接在<c:when>标签后,当<c:when>标签判断为false时被执行
        上面三个标签一起使用相当于 java中:if(){} else if(){}else if(){}else{}

    第三类:循环标签
        <c:forEach>:基础迭代标签,接受多种集合类型
        <c:forTokens>:根据指定的分隔符来分隔内容并迭代输-->split("/")
    第四类:URL操作标签
    
        <c:import>: 检索一个绝对或相对 URL,然后将其内容暴露给页面:导入到页面中
        
        <c:import>  任意的uri
        <jsp:import> 当前项目下的url


        <c:param>: 用来给包含或重定向的页面传递参数
        获取的话:从请求中获取
            req.getParameter("")

        <c:redirect>: 重定向 至一个新的URL.


        <c:url>: 使用可选的查询参数来创造一个URL

核心标签详解

1、<c:out> 输出变量到JspWriter输出流中
    语法1:<c:out value="result" [escapeXml]="{true|false}" [default="defaultValue"]/>
    语法2:<c:out value="result" [escapeXml]="{true|false}">
            default value
        </c:out>
    注意:    a)如果result为null,则输出default中的值
        a.1)属性default="值" 和标签的文本域默认值 不能同时出现
        b)escapeXml:设定是否转换特殊字符(如&lt、&gt等一些转义字符)
            默认值为true的情况下直接在输出&lt的,
            如果改为false将会进行转义输出“<”等。
    例如: <c:out value="${student.address.country}"/>
          <c:out value="你好"/>

2、<c:set> 该标签用于在某个范围中设置指定变量,或者设置某个对象的属性
    1)设置范围变量
        语法1:<c:set var="name" value="attrValue" [scope="page|request|session|application"]/>
                注: var指定的值-->属性名、变量名
                    value指定的值-->属性值、变量值
                    value可以通过el标签来取到数据,如:value="${user }"
        语法2:    <c:set var="varName" [scope=""]>
                    body content
                </c:set>
                注:var指定的值-->属性名、变量名
                    body content指定的值-->属性值、变量值
                    scope指定变量存放的范围,默认为page
        等价于:scope.setAttribute("name","attrValue");
    2)设置某个特定对象的一个属性
        语法1:<c:set target="${target}" property="propertyName" value="propertyValue"/>
                注:target:目标对象
                    propertyName:目标对象属性名
                    propertyValue:属性值
        语法2:    <c:set target="${target}" property="propertyName">
                    body content
                </c:set>
                注:target:目标对象
                    propertyName:目标对象属性名
                    body content:属性值
        例子:
            <c:set target="${student}" property="name" value="terry"/>
            注:把一个值为terry赋值给指定的student对象的name属性,
                等价于调用student对象的setter方法。
        注意:     1)scope属性不能在这里使用。
    eg:<c:set var="name" value="tom" scope="application"></c:set>

3、<c:remove> 在指定scope中根据属性名varName来删除属性值
    语法:<c:remove var="varName" [scope="page|...."]/>
            等价于 scope.removeAttribute("varName");
    注意:如果没有指定scope,那么依次从page、request、session和application范围中
            根据该属性名去删除属性值。
    eg:<c:remove var="test" scope="application"/>
4、<c:catch> 捕获由嵌套在它里面的代码抛出的异常
    语法:<c:catch [var="varName"]>
            nested actions
        </c:catch>
        注:var:用于存放这个异常对象的属性名,
                通过它可以输出异常对象的所有信息。
            scope:默认为page。
    eg:
        <c:catch var="e">
            <%
                int  x=10/0;
            %>
        </c:catch>
        <c:out value="${e}"/>

5、<c:if> 判断
    语法:      <c:if test="condition" var="varName" [scope]>
                body content
            </c:if>
    注:    var为存放布尔型变量的属性名
        scope为该变量的存放范围。
        condition通常为el表达式
    eg:
        <c:if test="true|false">
            条件为真
        </c:if>

6、<c:choose> 用于条件选择,它和<c:when>以及<c:otherwise>一起使用
    语法:   <c:choose>
                (<c:when> and <c:otherwise>)
            </c:choose>
    注意: body体内容只能由以下的元素构成
            1) 空格
            2) 0个或者多个<when>子标签,
                <c:when>必须出现在<c:choose>和<c:ohterwise>之间
            3) 0个或者多个<ohterwise>

7、<c:when> 代表了<c:choose>的一个分支
    语法:     <c:when test="condition">
                body content
            </c:when>
    注意: 必须以<c:choose>作为它的父标签
          必须在<c:otherwise>之前出现

8、<c:otherwise> 代表了<c:choose>的最后的选择
    语法:     <c:otherwise>
                body
            </c:otherwise>
    注意: 必须以<c:choose>作为父标签
          必须是<c:choose>的最后分支


9、 <c:forEach>用来迭代集合、数组、枚举或者迭代器(Iterator))
    语法1:     <c:forEach [var="varName"]
                items="collection/array/Enumaration/Iterator"
                [varStatus="varStatusName"]
                [begin="begin"] [end="end"]
                [step="step"]>
                    body
            </c:forEach>

    语法2: 迭代固定的次数(做普通的循环输出,类似for循环)
            <c:forEach [var="varName"]
                [varStatus="varStatusName"]
                begin="begin" end="end"
                [step="step"]>
                    body content
            </c:forEach>

    名字        类型        描述
    var        String        存放变量(迭代出来的)的属性名(scope为page)
    items        任何支持的类型    将要迭代itmes的集合/数组/枚举/Iterator
    varStatus    String        迭代的状态,可以访问迭代的自身信息,如索引号
    begin        int            items从index[begin]开始迭代
                            没有指定items从index开始做循环
    end         int         items从index[end]结束
                            没有指定items从end结束
    step        int            迭代的步长(>0)

    注意:varStatus中有index(索引),count(循环次数)
          ,first(是否是第一个位置),last(是否为最后一个位置)

    eg:遍历List
        <c:forEach items="${list }" var="str" varStatus="index" step="2" begin="1">
            ${str}-----${index.count }<br>
        </c:forEach>
        解析:
        items="${}"需要遍历的集合
        var="str"给遍历到的每个对象取个名字方便使用
        varStatus="index"给角标对象取名字-->${index.count}-->注意:从1开始
        step="2"步长为2  0__ 1__ 2__ 现在在0位置 然后步长为2 所以到了2号位
        begin="1"从集合的几号位置开始读取数据
        end="2"取到2号位置

    eg:遍历map
        <c:forEach items="${map}" var="m" varStatus="index">
            ${m.key }----${m.value}---${index.count }<p>
        </c:forEach>

10、 <c:forTokens>类似java中的StringTokenizer
                这个标签专门用于处理TokenString的迭代,
                可以指定一个或者多个分隔符号(delimiters)
    语法: <c:forTokens items="stringOfTokens"
             delims="delimiters"
            [var="varName"]
            [varStatus="varStatusName"]
            [begin="begin"] [end="end"]
            [step="step"]>
                body content
          </c:forTokens>
    eg:
        <c:forTokens items="briup|briup2|briup3|sssss|"
            delims="|" var="a" begin="" end="" step="" varStatus="">
            ${a }<p>
        </c:forTokens>
        item:需要被打断的字符串
        delims:通过什么打断
        var:打断以后的每个字符取个名字方便使用

11、 <c:import>导入一个基于URL的资源,可以把其他静态或动态文件包含到本JSP页面
    语法:<c:import url="url" [var="varName"] [scope]>
            [<c:param/>]*
          </c:import>
        var:存放URL资源内容的属性名
        scope:存放的范围

    区别:
        <jsp:include>:只能包含同一个web应用中的文件。
        <c:import>可以包含其他web应用中的文件,甚至是网络上的资源。
    eg:
    <c:import url="2_instruct_head.jsp" var="path" scope="session">
    </c:import>

12、 <c:param> 在<c:import>、<c:url>和<c:redirect>中添加请求的参数
    语法1:     <c:param name="name" value="value"/>
    语法2:     <c:param name="name">
            parameter value
        </c:param>
    eg:
        <c:import url="ServletTest" var="path" scope="request">
            <c:param name="hhh">jjj</c:param>
        </c:import>
        解释:
        先使用c:import 跳转到一个servlet然后使用s:param给请求附加数据域加在reqeust的请求体中


13、 <c:url> 用于构造URL,主要用途是URL重写
    语法: <c:url value="url" [var="varName"] [scope]>
            [<c:param/>]*
          </c:url>
    注意:1)var:存放重写后的URL的属性名
          2)scope:存放的范围
          3)若为相对路径,url会被重写
          4)若使用绝对路径则url不会重写
          5)一般和a连用,如<a href="varName">test</a>
        eg:<a href="<c:url value="/jsp/index.htm"/>">TEST</a>
14、 <c:redirect> 把客户的请求重定向到另一个资源
    语法: <c:redirect url="url">
            [<c:param/>]*
          </c:redirect>
    注意:1)若为相对路径,url会被重写
          2)若使用绝对路径则url不会重写




    EL最初是定义在JSTL1.0规范中,在JSP2.0中,EL从JSTL中剥离出来,放到JSP规范中
    成为了JSP2.0规范的一部分,并添加了新的特性。在JSP页面中,使用EL可以简化对
    变量和对象的访问。
    JSP中的表达式语言,使得访问存储在JavaBean中的数据变得非常简单。
    它既可以用来创建算术表达式也可以用来创建逻辑表达式。
    el表达式内可以使用整型数,浮点数,字符串,常量true、false,还有null。
    目的:
        通过EL标签取数据和输出信息,
        简化代码,不需要使用java来输出。
        使用Java代码也可以取数据,但是这样不利于维护JSP。

<c:forEach var="map">
 ${map.key}
 ${map.value}
            EL详解

 

形式:${ }


*    作用:从一个范围里面取值或者从一个
    ${name}
    容器
    key   value
    name    obj
    对象中取值或是向页面输出值.
    1.接收客户端参数.
       ${param.name1 }
    2.指定范围并取值
       ${pageScope.name2 }
         ${requestScope.name3 }
         ${sessionScope.name4 }
         ${applicationScope.name5 }
        3.可以不指定范围再去取值
       ${name}
       这时候会按照pageContext request session application这样一个顺序依次的去找有没有一个叫name的值存在,一旦找到了就输出出来,最终没有找到那么就什么都不输出。


${对象.属性}

    4.取出一个对象中的属性值.
       ${requestScope.student.id}
       ${requestScope.student.name}
       ${requestScope.student.age}
       或者
       ${student.id}
       ${student.name}
       ${student.age}
       或者
       ${student["id"]}
       ${student["name"]}
       ${student["age"]}

       注意:比如 ${student.id}表示是要调用student对象中的getId方法,至于对象中有没有id属性对这个操作没有任何影响.

       如果Student类中一个方法是getAddress,返回一个Address类的对象,Address类中有一个方法getCity,这个时候我们就可以这样写去拿到city属性的值.
       ${student.address.city}


    5.输出字符串
        ${"hello"}

    6.输出运算结果或者boolean表达式
        a)算术运算符
         +、-、*、/和 %(或 mod)
        b)关系运算符
         ==(或 eq)、!=(或 ne)、<(或 lt)、
        >(或 gt)、<=(或 le)和 >=(或 ge)
        c)逻辑运算符
         &&(或 and)、||(或 or)和 !(或 not)
        
        d)判空运算符 ${empty ""}-->变量name是否为空:${empty name}-->为空就是true
            empty
              <% String name="";%>
        如果为空 --> true
        不为空   --> false

        ${empty ""}
        ${empty name}




        ${1+1 }
        ${(1+2)*3-4+5*3 }
        ${1<3 }
        //为空的话返回true
        ${empty "" }
        ${empty "hello" }
        //取否 不为空的话返回true
        ${not empty "hello" }
        ${! empty "hello" }
        ${param.score >50 }
        ${param.score >60?"good":"bad" }

    7.输出数组、集合中的元素

        ${str[0] }<br>
        ${list[1] }<br>
        ${map["c"] }<br>

        <%
        String[] str = {"hello","world"};

        List<String> list = new ArrayList<String>();
        list.add("zhangsan");
        list.add("lisi");

        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("a",100);
        map.put("b",200);
        map.put("c",300);

        request.setAttribute("str",str);
        request.setAttribute("list",list);
        request.setAttribute("map",map);

        %>

        ${str[0] }<br>
        ${list[1] }<br>
        ${map["c"] }<br>





    8.表达式语言(EL)中定义了一些可以使用的隐含对象:
    1) pageContext: jsp页面的上下文,它提供了访问以下对象的方法
        a) servletContext
            ${pageContext.servletContext}
            等于
            out.println(pageContext.getServletContext())
        b) session
            ${pageContext.session.id}
            等于
            out.println(pageContext.getSession().getId())
        c) request
            ${pageContext.request}
            等于
            out.println(pageContext.getRequest())
        d) response
            ${pageContext.response}
            等于
            out.println(pageContext.getResponse())

    ------>看看
    2) parma: 把请求中的参数和单个值进行映射
        ${param.name}或者${param["name"]}或者${param['name']}
        等于
        out.println(request.getParameter("name"))
      注意:${param.name}如果获取不到值返回""。
            request.getParameter("name")如果获取不到值返回null。

    3) paramValues: 把请求中的参数和一个array值进行映射
        ${paramValues.hobby}或者${paramValues["hobby"]}或者${paramValues['hobby']}
           等于
        String[] array = request.getParameterValues("hobby")
            out.println(array);

    4) header: 把请求头中header的字段和单个值映射
        ${header.referer}
        等于
        out.println(request.getHeader("referer"));
        //获得http request请求头中所有字段名字
        Enumeration e =
            request.getHeaderNames();


    5) headerValues: 把请求头中header的字段和一个枚举进行映射
        ${headerValues.referer}
        等于
        Enumeration enum =
            request.getHeaders("referer")
        out.println(enum);

    6) cookie: 把请求中的Cookie和单个值进行映射
        Cookie cookie = new Cookie("height","100");
        Cookie cookie2 = new Cookie("width","200");
        response.addCookie(cookie);
        response.addCookie(cookie2);

                在服务器端获得从客户端发送过来的cookie:
        ${cookie.height}: 输出一个Cookie的对象
        ${cookie.height.name}=${cookie.height.value}
            分别输出Cookie的名称和值(height=100)
            ${cookie.width}: 同上
        ${cookie.width.name}=${cookie.width.value}: 同上

    7) initParam: 把Web应用上下文的初始化参数和单个值进行映射
         <context-param>
            <param-name>name</param-name>
            <param-value>value</param-value>
        </context-param>

        ${initParam.name}
        等于
        String value = getServletContext()
                .getInitParameter("name");
        out.println(value);

    8) pageScope: 把page范围中的key和value进行映射
        pageContext.setAttribute
                ("name","jack");

        ${pageScope.name}
        等于
        out.println
        (pageContext.getAttribute("name"));

    9) requestScope: 把request范围中的key和value进行映射
        request.setAttribute("name","jack");
        ${requestScope.name}
        等于
        out.println(request.getAttribute("name"));

    10) sessionScope: 把session范围中的key和value进行映射
        session.setAttribute("name","jack");
        ${sessionScope.name}
        等于
        out.println(session.getAttribute("name"));

    11) applicationScope: 把application范围中的key和value进行映射
        getServletContext().setAttribute("name","jack");
        ${applicationScope.name}
        等于
        out.println(getServletContext().getAttribute("name"));

       注意: 如果没有指明任何的范围根据key来查找对应的value,默认从page、request、session和application从小到大的范围开始查找,若找到就不往更大的范围去查找。
    例如: ${name} ,分别从page request session
    和 application中去查找name的值
(scope.getAttribute("name")),scope为上面四种范围。


补充:
JSTL-fmt标签库

国际化核心标签:<fmt:setLocale>、<fmt:bundle>、<fmt:setBundle>、<fmt:message>、<fmt:param>、<fmt:requestEncoding>
格式化标签:<fmt:timeZone>、<fmt:setTimeZone>、<fmt:formatNumber>、<fmt:parseNumber>、<fmt:formatDate>、<fmt:parseDate>

1.<fmt:parseDate>标签:用于解析日期
    属性描述
    value:将被解析的字符串
    type:解析格式化的类型
    pattern:解析格式化模式
    var:结果保存变量,类型为 java.lang.Date
    scope:变量的作用范围
    parseLocale:以本地化的形式来解析字符串,该属性的内容为 String 或 java.util.Locale 类型的实例
    timeZone:指定解析格式化日期的时区


2.<fmt:formatNumber>标签:用于格式化数字
    属性描述
    value:格式化的数字,该数值可以是 String 类型(需要是全数字)或 java.lang.Number 类型的实例
    type:格式化的类型,可能值包括:currency(货币)、number(数字)和percent(百分比)
    pattern:格式化模式:前缀
    var:结果保存变量
    scope:变量的作用范围
    maxIntegerDigits:指定格式化结果的:小数点前最多保留几位
    minIntegerDigits:指定格式化结果的:小数点前保留几位 ,补全
    maxFractionDigits:指定格式化结果的:小数点后最多保留几位
    minFractionDigits:指定格式化结果的:小数点后最少保留几位 默认是2

    如:
        结果将被保存在“ money ”变量中,将根据 Locale 环境显示当地的货币格式
        <fmt:formatNumber value="1000.888" type="currency" var="money"/>


3.<fmt:bundle> 、 <fmt:setBundle> 标签:用于资源配置文件的数据来源
    3.1<fmt:bundle> 标签将资源配置文件绑定于它标签体中的显示
    属性描述
    basename:资源配置文件的指定,只需要指定文件名而无须扩展名
    prefix:前置关键字
    如:
    资源文件中配置的数据为:
    label.backcolor=#FFF
    label.fontcolor=#000
    则,可以用如下方法取得label的backcolor和fontcolor值:
        <fmt:bundle basename="MyResourse" prefix="label.">
        <fmt:message key="backcolor" />
        <fmt:message key="fontcolor" />
        </fmt:bundle>

    3.2<fmt:setBundle> 标签则允许将资源配置文件保存为一个变量,在之后的工作可以根据该变量来进行
    属性描述 ,二组标签共有的属性
    var:<fmt:setBundle> 独有的属性,用于保存资源配置文件为一个变量
    scope:变量的作用范围
    如:
        查找一个名为 applicationMessage_zh_CN.properties 的资源配置文件,来作为显示的 Resource 绑定
        <fmt:setBundle basename="applicationMessage" var="applicationBundle"/>


4.<fmt:message> 标签:用于显示资源配置文件信息(该资源文件必须遵循如下格式:1.扩展名必须为properties,2.文件的内容必须依照key = value的格式;3.文件要放到WEB-INF/classes目录下)
    属性描述
    key:资源配置文件的“键”指定
    bundle:若使用 <fmt:setBundle> 保存了资源配置文件,该属性就可以从保存的资源配置文件中进行查找
    var:将显示信息保存为一个变量
    scope:变量的作用范围
    如:
    1)用<fmt:setBundle>标签将"applicationMessage"资源配置文件被赋于了变量"applicationBundle"
        用<fmt:message>标签显示由<fmt:setBundle>标签保存的资源配置文件中"键"为"passWord"的信息

        <fmt:setBundle basename="applicationMessage" var="applicationBundle"/>
        <fmt:message key="passWord" bundle="${applicationBundle}" />

    2)用<fmt:bundle>标签定义的"applicationAllMessage"资源配置文件作用于其标签体内的显示
        用<fmt:message>标签显示"applicationAllMessage"资源配置文件中"键"为"userName"的信息

        <fmt:bundle basename="applicationAllMessage">
            <fmt:message key="userName" />
        </fmt:bundle>

5.<fmt:param 标签:用于参数传递
    <fmt:param>标签应该位于 <fmt:message> 标签内,将为该消息标签提供参数值。它只有一个属性value
    如:在MyResourse.properties文件中,有一个索引值如下(其中,{0}代表占位符):
    Str2=Hi,{0}
    则,使用<fmt:param>标签传入值如下:
        <fmt:bundle basename="MyResourse">
        <fmt:message key="Str2">
            <fmt:param value="张三" />
        </fmt:message>
        </fmt:bundle>
    也可以在资源文件中指定参数的类型:
    如:在MyResourse.properties文件中,有一个索引值如下:
    Str3={0,date}
    则,使用<fmt:param>标签传入值如下:
        <% request.setAttribute("now",new Date()); %>
        <fmt:bundle basename="MyResourse">
        <fmt:message key="Str3">
            <fmt:param value="${now}" />
        </fmt:message>
        </fmt:bundle>


6.<fmt:timeZone>、<fmt:setTimeZone>标签:用于设定时区
    <fmt:timeZone> 标签将使得在其标签体内的工作可以使用该时区设置
    <fmt:setTimeZone> 标签则允许将时区设置保存为一个变量,在之后的工作可以根据该变量来进行
    属性描述
    value:时区的设置
    var:<fmt:setTimeZone> 独有的属性,用于保存时区为一个变量
    scope:变量的作用范围


7.<fmt:requestEncoding>标签:用于为请求设置字符编码
    它只有一个属性 value ,在该属性中可以定义字符编码。
    如:
        <fmt:requestEncoding value="GB2312"/>


8.<fmt:parseNumber> 标签:用于解析数字
    属性描述
    value:将被解析的字符串
    type:解析格式化的类型
    pattern:解析格式化模式
    var:结果保存变量,类型为 java.lang.Number
    scope:变量的作用范围
    parseLocale:以本地化的形式来解析字符串,该属性的内容应为 String 或 java.util.Locale 类型的实例

    如:
        将"15%"转换为数字
        <fmt:parseNumber value="15%" type="percent" var="num"/>

------------
9.<fmt:formatDate>标签:用于格式化日期
    属性描述
    value:格式化的日期,该属性的内容应该是 java.util.Date 类型的实例
    type:格式化的类型
    pattern:格式化模式
    var:结果保存变量
    scope:变量的作用范围
    timeZone:指定格式化日期的时区


10.<fmt:setLocale>标签:用于设置本地化环境
    属性描述
    value:Locale 环境的指定,可以是 java.util.Locale 或 String 类型的实例
    scope:Locale 环境变量的作用范围(可选)
    如:
        设置本地环境为繁体中文
        <fmt:setLocale value="zh_TW"/>
        设置本地环境为简体中文
        <fmt:setLocale value="zh_CN"/>

posted on 2018-03-20 11:26  shenhaha  阅读(1475)  评论(0编辑  收藏  举报

有用的话麻烦点个推荐哈