JSP详解

主要内容简介：

1.  JSP简介

        a)  什么是JSP

        b)  JSP的组成

        c)  JSP的特点

        d) JSP的执行过程

        e) JSP的生命周期

2. JSP语法

        a) JSP模板元素

        b) JSP表达式

        c) JSP脚本片段

        d) JSP注释

3.  JSP指令

        a) page指令

        b) Include指令

        c)  taglib指令

4. JSP九大内置(隐式)对象

5.JSP的四个域对象

6. JSP的正确使用方法

7.EL表达式详解（重点）

8.JSP标签（重点）

        a) 内置标签（动作标签）：不需要在jsp页面导入标签

        b) include指令与include动作标签的区别

        c) JSTL标签：需要在jsp页面中导入标签

        d) 自定义标签：开发者自定义

一、JSP简介

1.什么是jsp

• JSP全称是Java Server Pages，它和Servle技术一样，都是SUN公司定义的一种用于开发动态web资源的技术
• JSP这门技术的最大的特点在于，写JSP就像写html，但：

相比html而言，（html只能为用户提供静态数据）JSP技术允许在页面中嵌套java代码，为用户提供动态数据。

相比servlet而言，jsp更容易对数据进行排版

2.       JSP的组成

JSP使用Java脚本（代码片段），html，还有JSP动态标签构成的组成的

（JSP就是Servlet）

问题：为什么Jsp就是servlet！！！

                            jsp翻译的java文件：

  publicfinal class _01_hello_jsp extends org.apache.jasper.runtime.HttpJspBaseimplements org.apache.jasper.runtime.JspSourceDependent {

         HttpJspBase类：

public abstract class org.apache.jasper.runtime.HttpJspBase 

extends javax.servlet.http.HttpServletimplements javax.servlet.jsp.HttpJspPage {

结论： Jsp就是一个servlet程序！！！

       servlet的技术可以用在jsp程序中

       jsp的技术并不是全部适用于servlet程序！

简单概念图

3.     JSP的特点：

1）jsp的运行必须交给tomcat服务器！！！！

                                                        tomcat的work目录： tomcat服务器存放jsp运行时的临时文件

                   2）jsp页面既可以写html代码，也可以写java代码。

                   （html页面不能写java代码 。而jsp页面可以写java代码）

4.        JSP的执行过程

a）浏览器访问JSP页面，tomcat扫描到JSP文件，在%tomcat%/work把jsp文件翻译成java源文件（翻译）

b）Tomcat服务器把java源文件编译成class字节码文件（编译）

c）Tomcat服务器构造该jsp对象

d）Tomcat服务器调用该jsp类中的方法，返回内容显示到浏览器

注意：只在第一次访问时需要 a,b ,c,d四步骤

第二次到n次只需要执行 d步骤。当jsp文件修改或零时文件被删除了需要重新走翻译（a）和编译（b）的过程。

5.        JSP的生命周期（重点）

                     Servlet的生命周期：

                                   1）构造方法（第1次访问）

                                   2）init方法（第1次访问）

                                   3）service方法

                                   4）destroy方法            

                     Jsp的生命周期

                                   1）翻译： jsp->java文件

                                   2）编译： java文件->class文件（servlet程序）

                                   3）构造方法（第1次访问）

                                   4）init方法（第1次访问）：_jspInit()

                                   5）service方法：_jspService()

                                   6）destroy方法：_jspDestroy()

二、JSP语法

1.      JSP模板

       JSP页面中的HTML内容称之为JSP模版元素。

JSP模版元素定义了网页的基本骨架，即定义了页面的结构和外观。

2.      JSP表达式（expression）

语法：<%= 变量或表达式%>

作用：用于将程序数据输出到客户端

<%= “hello world ”%> ==   <%   out.print( “hello world ”);   %>

注意：

1）表达式的原理其实就是吧语法中的内容翻译成out.print（“内容”）；

通过该方法向浏览器写出内容

2）表达式中不能带分号

3.       JSP的脚本（scriptlet）

语法：<%    多行java代码    %>

作用：相当与在JSP翻译的Servlet类中的_jspService方法中写可以执行的代码。

注意：

1）JSP脚本片断中只能出现java代码，不能出现其它模板元素， JSP引擎在翻译JSP页面中，会将JSP脚本片断中的Java代码将被原封不动地放到Servlet的_jspService方法中。

2）JSP脚本片断中的Java代码必须严格遵循Java语法，例如，每执行语句后面必须用分号（;）结束。

3）在一个JSP页面中可以有多个脚本片断，在两个或多个脚本片断之间可以嵌入文本、HTML标记和其他JSP元素。

         举例：

<%int x = 10;out.println(x);%><p>这是JSP页面文本</p><%int y = 20;out.println(y+””+x);%>

4）多个脚本片断中的代码可以相互访问，犹如将所有的代码放在一对<%%>之中的情况。如：out.println(x);

5）单个脚本片断中的Java语句可以是不完整的，但是，多个脚本片断组合后的结果必须是完整的Java语句，例如：

<%for (int i=1; i<5;i++){%><H1>helloword</H1><%}%>

4.      JSP的声明

语法：<%! 变量或方法 %>

作用：声明JSP的变量或方法（相当于在JSP翻译的Servlet类中写成员变量或方法）

注意：

1）JSP声明可用于定义JSP页面转换成的Servlet程序的静态代码块、成员变量和方法 。

2）多个静态代码块、变量和函数可以定义在一个JSP声明中，也可以分别单独定义在多个JSP声明中。

3）JSP隐式对象的作用范围仅限于Servlet的_jspService方法，所以在JSP声明中不能使用这些隐式对象。

<%!static{System.out.println("loadingServlet!");}private intglobalVar = 0;public voidjspInit(){System.out.println("initializingjsp!");}%><%!public voidjspDestroy(){System.out.println("destroyingjsp!");}%>

5.    JSP注释

语法：<%! --   jsp注释       --%>

注意：

                                     1)html的注释会被翻译和执行。而jsp的注释不能被翻译和执行。

2)在JSP声明，脚本，表达式中可以用java的注释

三、JSP三大指令（directive）

概念：JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。在JSP 2.0规范中共定义了三个指令：

page指令

Include指令

taglib指令

JSP指令的基本语法格式：

         <%@指令属性名="值" %>

         举例：

<%@ pagecontentType="text/html;charset=UTF-8"%>

如果一个指令有多个属性，这多个属性可以写在一个指令中，也可以分开写。

         例如：

<%@ pagecontentType="text/html;charset=UTF-8"%><%@ pageimport="java.util.Date"%>

         也可以写作：

<%@ pagecontentType="text/html;charset=UTF-8"import="java.util.Date"%>

1.    page指令

1）page指令用于定义JSP页面的各种属性，无论page指令出现在JSP页面中的什么地方，它作用的都是整个JSP页面，为了保持程序的可读性和遵循良好的编程习惯，page指令最好是放在整个JSP页面的起始位置。

2）page指令中的各个属性

<%@ page

    language="java"   

--告诉服务器使用什么动态语言来翻译jsp文件

（当年sun公司想让jsp支持多种语言定义了，后来由于某种原因没有完成，所以只能翻译为java语言）

    import="java.util.*"

 --告诉服务器java文件使用什么包导入包，多个包之间用逗号分割（建议分开导入包）

    pageEncoding="utf-8" 

--告诉服务器使用什么编码翻译jsp文件（成java文件）

    contentType="text/html;charset=utf-8"

服务器发送浏览器的数据类型和内容编码

    注意：在开发工具中，以后只需要设置pageEncoding即可解决中文乱码问题

与异常错误相关的：

    errorPage="error.jsp"

    isErrorPage="false"

         Web.xml中配置全局的错误处理页面：（常用）

    buffer="8kb"  

 设置jsp页面缓存大小，因为jsp页面有JSPWriter缓存机制，数据先会写到JSPWriter缓存中，然后一定条件下才会写入页面，所以如果不需要缓存机制   可以设置为  “0kb”

    session="true"   

是否开启session功能。false，不能用session内置对象；true，可以使用session内置对象。

    isELIgnored="false"  

 是否忽略EL表达式

    %>

2.    include指令（静态包含）

原理： include指令用于引入其它JSP页面，如果使用include指令引入了其它JSP页面，那么JSP引擎将把这两个JSP翻译成一个servlet。所以include指令引入通常也称之为静态引入。

语法：

         <%@ includefile="relativeURL"%>

         其中的file属性用于指定被引入文件的相对路径。  file属性的设置值必须使用相对路径，如果以“/”开头，表示相对于当前WEB应用程序的根目录（注意不是站点根目录），否则，表示相对于当前文件。

细节：

被引入的文件必须遵循JSP语法。

被引入的文件可以使用任意的扩展名，即使其扩展名是html，JSP引擎也会按照处理jsp页面的方式处理它里面的内容，为了见明知意，JSP规范建议使用.jspf（JSP fragments）作为静态引入文件的扩展名。

由于使用include指令将会涉及到2个JSP页面，并会把2个JSP翻译成一个servlet，所以这2个JSP页面的指令不能冲突（除了pageEncoding和导包除外）。

（其实就是相当于吧两个JSP中的内容翻译到一个servlet中从生成的jspServlet文件中可以看出其实相当于把所有的信息原封不动的拿了过来。这就有可能导致当定义两个相同名称的变量是会出现错误）

  out.write('\r');out.write('\n');out.write("\r\n");out.write("\r\n");out.write("<!DOCTYPE html PUBLIC\"-//W3C//DTD HTML 4.01 Transitional//EN\"\"http://www.w3.org/TR/html4/loose.dtd\">\r\n");out.write("<html>\r\n");out.write("<head>\r\n");out.write("<metahttp-equiv=\"Content-Type\" content=\"text/html;charset=UTF-8\">\r\n");out.write("<title>Insert titlehere</title>\r\n");out.write("</head>\r\n");out.write("<body>\r\n");out.write("\tHello ");out.write("\r\n");out.write("<!DOCTYPE html PUBLIC\"-//W3C//DTD HTML 4.01 Transitional//EN\"\"http://www.w3.org/TR/html4/loose.dtd\">\r\n");out.write("<html>\r\n");out.write("<head>\r\n");out.write("<metahttp-equiv=\"Content-Type\" content=\"text/html;charset=UTF-8\">\r\n");out.write("<title>Insert titlehere</title>\r\n");out.write("</head>\r\n");out.write("<body>\r\n");out.write(" world\r\n");out.write("</body>\r\n");out.write("</html>");out.write("\r\n");out.write("</body>\r\n");                          out.write("</html>");

网页源代码

四、JSP的九大内置（隐式）对象（重点）

1.    什么是内置对象

在jsp开发中，会频繁使用到一些对象例如：

HttpSession

ServletContext,

ServletContext,

HttpServletRequet。

如果我们每次要使用这些对象都要去创建这些对象就会显得有点麻烦，所以sun公司设计jsp时，在jsp页面加载完毕之后就会自动帮开发者创建好这些对象，而开发者只需要直接使用这些对象调用方法即可！，这些创建好的对象就叫内置对象

举例：

         servlet:

                   HttpSessionsession = request.getSession(true); （需要开发者做）

         jsp:

                   tomcat服务器：    HttpSession session =request.getSession(true);(不需要开发者做)

开发者做的： session.getId();

2.    九大内置对象

request            HttpServletRequest                 ----|

response          HttpServletResponse              ----|

session              HttpSession                           ----|--------在servlet中也可以用的五个对象

application      ServletcContext                       ----|

config                     ServletConfig                   ----|

exception                   Throwable  (当设置page指令的isErorrPage属性是才可以使用)

page                           Object(this) (本JSP页面)

out                              JspWriter （带缓冲的PrintWriter）

pageContext               PageContext (使普通Java类可访问WEB资源，自定义标签常用)

内置对象特点:

        1. 由JSP规范提供,不用编写者实例化。

        2. 通过Web容器实现和管理

        3. 所有JSP页面均可使用

        4. 只有在脚本元素的表达式或代码段中才可使用(<%=使用内置对象%>或<%使用内置对象%>)

 内置对象可分为四类:

        1. 输出输入对象:request对象、response对象、out对象

        2. 通信控制对象:pageContext对象、session对象、application对象

        3. Servlet对象:page对象、config对象

        4. 错误处理对象:exception对象

对象常用方法说明:

1.request对象(请求信息 javax.servlet.http.HttpServletrequest)

 特点：Request(Javax.servlet.ServletRequest)它包含了有关浏览器请求的信息.通过该对象可以获得请求中的头信息、Cookie和请求参数。

2.response对象(响应 javax.servlet.http.HttpServletResponse)

 特点Response(Javax.servlet.ServletResponse)作为JSP页面处理结果返回给用户的响应存储在该对象中。并提供了设置响应内容、响应头以及重定向的方法(如cookies,头信息等)

3.session对象(会话 javax.servlet.http.HttpSession)

4.application对象(应用程序 javax.servlet.ServletContext)

 特点：Application(javax.servle.ServletContext)存储了运行JSP页面的servlet以及在同一应用程序中的任何Web组件的上下文信息。

5.config对象(Servlet的配置信息 javax.servlet.ServletConfig)

 特点：Config(javax.servlet.ServletConfig)该对象用于存取servlet实例的初始化参数。

6.page对象(当前JSP的实例,java.lang.object)

它代表JSP被编译成Servlet,可以使用它来调用Servlet类中所定义的方法

特点：Page(Java.lang.Object)表示当前JSP页面的servlet实例

可以用他来获取整个类中的所有方法和成员变量（反射）

7.out对象(数据流 javax.servlet.jsp.jspWriter)（重点）

1.用于将内容写入JSP页面实例的输出流中,提供了几个方法使你能用于向浏览器回送输出结果。特点：Out(Javax.servlet.jsp.JspWriter)

2.out对象是通过调用pageContext对象的getOut方法返回的，其作用和用法与ServletResponse.getWriter方法返回的PrintWriter对象非常相似。

3.JSP页面中的out隐式对象的类型为JspWriter，JspWriter相当于一种带缓存功能的PrintWriter，设置JSP页面的page指令的buffer属性可以调整它的缓存大小，甚至关闭它的缓存。

4.只有向out对象中写入了内容，且满足如下任何一个条件时，out对象才去调用ServletResponse.getWriter方法，并通过该方法返回的PrintWriter对象将out对象的缓冲区中的内容真正写入到Servlet引擎提供的缓冲区中：

•  设置page指令的buffer属性关闭了out对象的缓存功能
•  out对象的缓冲区已满
•  整个JSP页面结束

out隐式对象工作原理

8.pageContext对象(页面上下文 javax.servlet.jsp.PageContext)

常见的用法：

特点：   pageContext对象的类型是PageContext，叫jsp的上下文对象

  1）可以获取其他八个内置对象

                            publicclass 01_hello_jsp {publicvoid _jspService(request,response){创建内置对象HttpSessionsession =....;ServletConfigconfig = ....;把8个经常使用的内置对象封装到PageContext对象中PageContextpageContext  = 封装；调用method1方法method1(pageContext);}publicvoid method1(PageContext pageContext){希望使用内置对象从PageContext对象中获取其他8个内置对象JspWriterout =pageContext.getOut();HttpServletRequestrquest =           pageContext.getRequest();........}}

                使用场景：在自定义标签的时候，PageContext对象频繁使用到！！！

     2）本身是一个域对象

                   ServletContextcontext域

                   HttpServletRequet  request域

                   HttpSession    session域     --Servlet学习的

                   PageContext   page域        --jsp学习的

         作用：保存数据和获取数据，用于共享数据

         #保存数据

                            ）默认情况下，保存到page域

                            pageContext.setAttribute("name");

                            2）可以向四个域对象保存数据

                                     pageContext.setAttribute("name",域范围常量)

         #获取数据

                   1）默认情况下，从page域获取

                                     pageContext.getAttribute("name")

                   2）可以从四个域中获取数据

                                     pageContext.getAttribute("name",域范围常量)

等价于    

域对象.getAttribute(“name”)

                   域范围常量:（可以使用pageContext.setAttribute(key,value,域范围常量)来设置添加的数据添加到那个域）

                   PageContext.PAGE_SCOPE

                   PageContext.REQUEST_SCOPE

                   PageContext..SESSION_SCOPE

                   PageContext.APPLICATION_SCOPE

         3）自动在四个域中搜索数据（从作用域最低的域开始找）

pageContext.findAttribute("name");

顺序： page域 ->request域 -> session域- >context域（application域）    

4）引入和跳转到其他资源（重点）

PageContext类中定义了一个forward方法和两个include方法来分别简化和替代RequestDispatcher.forward方法和include方法

传递给这些方法的资源路径，如果路径以“/”开头，表示相对于当前WEB应用程序的根目录，否则，表示相对于当前JSP所映射到的访问路径。

9.exception对象(运行时的异常,java.lang.Throwable)

被调用的错误页面的结果,只有在错误页面中才可使用,

即在页面指令中设置:<%@page isErrorPage=“true”%>

Exception(Javax.lang.Throwable)在某个页面抛出异常时,将转发至JSP错误页面,提供此对象是为了在JSP中处理错误。只有在错误页面中才可使用<%@page isErrorPage=“true”%>

五、JSP的四个域对象

pageContext          page域(jsp有效)     pageContext.

request               request域(一次请求)   HttpServletRequest

Session                session域(一次会话)     HTTPSession

Application       Context域(当前web应用)   ServletContext

之所以他们是域对象，原因就是他们都内置了map集合，都有setAttribute getAttribute方法。

他们都有自己固定的生命周期和作用域。这四个对象的生命周期(生命周期就是值对象的创建到销毁的期间)。

四个域对象的生命周期：

·        page：jsp页面被执行，生命周期开始，jsp页面执行完毕，声明周期结束。

·        request:用户发送一个请求，开始，服务器返回响应，请求结束，生命周期结束。

·        session:用户打开浏览器访问，创建session(开始),session超时或被声明失效，该对象生命周期结束。

·        application：web应用加载的时候创建。Web应用被移除或服务器关闭，对象销毁。[结束]。

注意：

·        Page只在当前jsp有效，每次请求分别对应不同的request。

·        Request只在当前请求有效，每次请求分别对应不同的request域。

·        Session只在一次会话中有效，会话结束就无法取到数据了。

四个域对象在选择的时候，能用范围小的绝不用范围大的：

page:数据只是暂时存在集合，在jsp页面的其他地方要用，用page(页面中自定义的map)。

Request:数据只是做显示的，看完了就没用了。就存request域，请求转发，Servlet产生的处理结果（数据）交给jsp显示，数据转发可以带数据。

Session:数据给用户看完了，一定还要用，会话结束了就没用了。用户登录，用户信息发给客户端看，看完了，一会访问别的页面还要看用户信息。 购物车，购物车成功了，给用户看购物车，待会随时间可以查看购物车。 请求重定向，因为是两次请求，每一次请求的数据，第二次请求还要看。

application:数据给一个用户用完了，别人还要用。聊天室，聊天记录，需要给所有的用户看。 统计网站在线人数，所有看到的应该是一个数。

总结：

1）域对象作用：

         保存数据  和 获取数据 ，用于数据共享。

2）域对象方法：

         setAttribute("name",Object)保存数据

         getAttribute("name")  获取数据

         removeAttribute("name")清除数据

3）域对象作用范围：

         page域：只能在当前jsp页面中使用（当前页面）

         request域：只能在同一个请求中使用（转发）

         session域：只能在同一个会话（session对象）中使用（私有的）

         context域：只能在同一个web应用中使用。（全局的）

四个域对象在选择的时候，能用范围小的绝不用范围大的。需要定义Map时不如用page，请求Servlet，转发给jsp的数据存request，请求重定向带过去的数据存Session，全局的数据存application。

六、JSP的正确使用方法

         Servlet技术： 开发动态资源。是一个java类，最擅长写java代码

                                     jsp技术： 开发动态资源。通过java代码最擅长输出html代码。

（尽量在jsp页面中少写甚至不写java代码。）

                                     各取所长：

                                               在web项目中涉及到逻辑：

                                                        1）接收参数     servlet做

                                                        2）处理业务逻辑，返回结果    servlet做

                                                        3）显示数据到浏览器      jsp做

                                                        4）跳转到其他页面       servlet做

                                      servlet+jsp模式

                                      servlet:

                                                        1）接收参数

                                                        2）处理业务逻辑

                                                        3）把结果保存到域对象中

                                                        4）跳转到jsp页面

                                               Jsp:

                                                        1）从域对象取出数据

                                                        2）把数据显示到浏览器

                                     servlet的数据    ->   jsp页面

                                     List<Contact>    使用域对象共享数据

七、EL表达式 （Expression  Language）

EL表达式的主要作用：

1. 获取（域对象中的）数据：

EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域中检索java对象、获取数据。(某个web域中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组)

EL既可以用来创建算术表达式也可以用来创建逻辑表达式。在JSPEL表达式内可以使用整型数，浮点数，字符串，常量true、false，还有null。

一个简单的语法

典型的，当您需要在JSP标签中指定一个属性值时，只需要简单地使用字符串即可：

<jsp:setProperty name="box" property="perimeter" value="100"/>

JSP EL允许您指定一个表达式来表示属性值。一个简单的表达式语法如下：

${expr}

其中，expr指的是表达式。在JSPEL中通用的操作符是 . 和 {} 。这两个操作符允许您通过内嵌的JSP对象访问各种各样的JavaBean属性。

举例来说，上面的<jsp:setProperty>标签可以使用表达式语言改写成如下形式：

<jsp:setProperty name="box" property="perimeter" 

                 value="${2*box.width+2*box.height}"/>

当JSP编译器在属性中见到"${}"格式后，它会产生代码来计算这个表达式，并且产生一个替代品来代替表达式的值。

您也可以在标签的模板文本中使用表达式语言。比如<jsp:text>标签简单地将其主体中的文本插入到JSP输出中：

<jsp:text><h1>Hello JSP!</h1></jsp:text>

现在，在<jsp:text>标签主体中使用表达式，就像这样：

<jsp:text>

Box Perimeter is: ${2*box.width + 2*box.height}</jsp:text>

在EL表达式中可以使用圆括号来组织子表达式。比如${(1 + 2) * 3}等于9，但是${1+ (2 * 3)} 等于7。

想要停用对EL表达式的评估的话，需要使用page指令将isELIgnored属性值设为true：

<%@ page isELIgnored ="true|false" %>

这样，EL表达式就会被忽略。若设为false，则容器将会计算EL表达式。

EL中的基础操作符

EL表达式支持大部分Java所提供的算术和逻辑操作符：

el表达式的使用

${变量}

输出普通字符串： ${name}

输出对象属性：  ${student.name}  注意： .name 相当于  .getName（）方法

输出List集合：   ${list[0].name }   注意： [0]  相当于 get（下标）方法

输出map集合：  ${map[key].name}  注意：　［key］相当于get（key）方法

注意：[ ]可在el表达式中输出带敏感字符的变量名${requestScope["Accept-Language"]}

JSP EL中的函数

JSP EL允许您在表达式中使用函数。这些函数必须被定义在自定义标签库中。函数的使用语法如下：

${ns:func(param1, param2, ...)}

ns指的是命名空间（namespace），func指的是函数的名称，param1指的是第一个参数，param2指的是第二个参数，以此类推。比如，有函数fn:length，在JSTL库中定义，可以像下面这样来获取一个字符串的长度：

${fn:length("Get my length")}

要使用任何标签库中的函数，您需要将这些库安装在服务器中，然后使用<taglib>标签在JSP文件中包含这些库。

JSP EL隐含对象

JSP EL支持下表列出的隐含对象：

您可以在表达式中使用这些对象，就像使用变量一样。接下来会给出几个例子来更好的理解这个概念。

pageContext对象

pageContext对象是JSP中pageContext对象的引用。通过pageContext对象，您可以访问request对象。比如，访问request对象传入的查询字符串，就像这样：

${pageContext.request.queryString}

Scope对象

pageScope，requestScope，sessionScope，applicationScope变量用来访问存储在各个作用域层次的变量。

举例来说，如果您需要显式访问在applicationScope层的box变量，可以这样来访问：applicationScope.box。

param和paramValues对象

param和paramValues对象用来访问参数值，通过使用request.getParameter方法和request.getParameterValues方法。

举例来说，访问一个名为order的参数，可以这样使用表达式：${param.order}，或者${param["order"]}。

接下来的例子表明了如何访问request中的username参数：

<%@ page import="java.io.*,java.util.*" %><%

    String title = "Accessing Request Param";

%><html><head><title><% out.print(title); %></title></head><body><center><h1><% out.print(title); %></h1></center><div align="center"><p>${param["username"]}</p></div></body></html>

param对象返回单一的字符串，而paramValues对象则返回一个字符串数组。

header和headerValues对象

header和headerValues对象用来访问信息头，通过使用 request.getHeader方法和request.getHeaders方法。

举例来说，要访问一个名为user-agent的信息头，可以这样使用表达式：${header.user-agent}，或者${header["user-agent"]}。

接下来的例子表明了如何访问user-agent信息头：

<%@ page import="java.io.*,java.util.*" %><%

    String title = "User Agent Example";

%><html><head><title><% out.print(title); %></title></head><body><center><h1><% out.print(title); %></h1></center><div align="center"><p>${header["user-agent"]}</p></div></body></html>

八、JSP标签（重点）

1. JSP标签的作用

替换jsp脚本

1）流程判断（if   for循环）

2）跳转页面（转发，重定向）

2.JSP标签的分类

1）内置标签（动作标签）：不需要在jsp页面导入标签

2）JSTL标签：需要在jsp页面中导入标签

3）自定义标签：开发者自行定义，需要在jsp页面导入标签

动作标签：

该部分内容引用自菜鸟教程

与JSP指令元素不同的是，JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。

利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。

动作元素只有一种语法，它符合XML标准：

<jsp:action_name attribute="value" />

动作元素基本上都是预定义的函数，JSP规范定义了一系列的标准动作，它用JSP作为前缀，可用的标准动作元素如下：

常见的属性

所有的动作要素都有两个属性：id属性和scope属性。

·        id属性：

id属性是动作元素的唯一标识，可以在JSP页面中引用。动作元素创建的id值可以通过PageContext来调用。

·        scope属性：

该属性用于识别动作元素的生命周期。 id属性和scope属性有直接关系，scope属性定义了相关联id对象的寿命。 scope属性有四个可能的值： (a) page, (b)request, (c)session, 和 (d)application。

·         

·         

<jsp:include>动作元素

<jsp:include>动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下：

<jsp:include page="相对 URL 地址" flush="true" />

　前面已经介绍过include指令，它是在JSP文件被转换成Servlet的时候引入文件，而这里的jsp:include动作不同，插入文件的时间是在页面被请求的时候。

以下是include动作相关的属性列表。

实例

以下我们定义了两个文件 date.jsp 和 main.jsp，代码如下所示：

date.jsp文件代码：

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

    pageEncoding="UTF-8"%><p>

   今天的日期是: <%= (new java.util.Date()).toLocaleString()%></p>

main.jsp文件代码：

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

    pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鸟教程(runoob.com)</title></head><body>

<h2>include 动作实例</h2><jsp:include page="date.jsp" flush="true" />

</body></html>

现在将以上两个文件放在服务器的根目录下，访问main.jsp文件。显示结果如下：

include 动作实例

今天的日期是: 2016-6-25 14:08:17

<jsp:useBean>动作元素

jsp:useBean 动作用来加载一个将在JSP页面中使用的JavaBean。

这个功能非常有用，因为它使得我们可以发挥 Java 组件复用的优势。

jsp:useBean动作最简单的语法为：

<jsp:useBean id="name" class="package.class" />

在类载入后，我们既可以通过 jsp:setProperty 和 jsp:getProperty 动作来修改和检索bean的属性。

以下是useBean动作相关的属性列表。

在给出具体实例前，让我们先来看下 jsp:setProperty 和 jsp:getProperty 动作元素：

<jsp:setProperty>动作元素

jsp:setProperty用来设置已经实例化的Bean对象的属性，有两种用法。首先，你可以在jsp:useBean元素的外面（后面）使用jsp:setProperty，如下所示：

<jsp:useBean id="myName" ... />

...<jsp:setProperty name="myName" property="someProperty" .../>

此时，不管jsp:useBean是找到了一个现有的Bean，还是新创建了一个Bean实例，jsp:setProperty都会执行。第二种用法是把jsp:setProperty放入jsp:useBean元素的内部，如下所示：

<jsp:useBean id="myName" ... >

...

   <jsp:setProperty name="myName" property="someProperty" .../></jsp:useBean>

此时，jsp:setProperty只有在新建Bean实例时才会执行，如果是使用现有实例则不执行jsp:setProperty。

jsp:setProperty动作有下面四个属性,如下表：

<jsp:getProperty>动作元素

jsp:getProperty动作提取指定Bean属性的值，转换成字符串，然后输出。语法格式如下：

<jsp:useBean id="myName" ... />

...<jsp:getProperty name="myName" property="someProperty" .../>

下表是与getProperty相关联的属性：

实例

以下实例我们使用了Bean:

package com.runoob.main;

public class TestBean {

   private String message = "菜鸟教程";

   public String getMessage() {

      return(message);

   }

   public void setMessage(String message) {

      this.message = message;

   }}

编译以上实例文件 TestBean.java ：

$ javac TestBean.java

编译完成后会在当前目录下生成一个 TestBean.class 文件，将该文件拷贝至当前 JSP 项目的 WebContent/WEB-INF/classes/com/runoob/main 下( com/runoob/main 包路径，没有需要手动创建)。

下面是一个 Eclipse 中目录结构图：

下面是一个很简单的例子，它的功能是装载一个Bean，然后设置/读取它的message属性。

现在让我们在main.jsp文件中调用该Bean:

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

    pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鸟教程(runoob.com)</title></head><body>

<h2>Jsp 使用 JavaBean 实例</h2><jsp:useBean id="test" class="com.runoob.main.TestBean" />

 <jsp:setProperty name="test" 

                    property="message" 

                    value="菜鸟教程..." />

 <p>输出信息....</p>

 <jsp:getProperty name="test" property="message" />

</body></html>

浏览器访问，执行以上文件，输出如下所示：

<jsp:forward>动作元素

　jsp:forward动作把请求转到另外的页面。jsp:forward标记只有一个属性page。语法格式如下所示：

<jsp:forward page="相对 URL 地址" />

以下是forward相关联的属性：

实例

以下实例我们使用了两个文件，分别是： date.jsp 和 main.jsp。

date.jsp 文件代码如下：

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

    pageEncoding="UTF-8"%><p>

   今天的日期是: <%= (new java.util.Date()).toLocaleString()%></p>

main.jsp文件代码：

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

    pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鸟教程(runoob.com)</title></head><body>

<h2>forward 动作实例</h2><jsp:forward page="date.jsp" /></body></html>

现在将以上两个文件放在服务器的根目录下，访问main.jsp文件。显示结果如下：

今天的日期是: 2016-6-25 14:37:25

<jsp:plugin>动作元素

jsp:plugin动作用来根据浏览器的类型，插入通过Java插件 运行Java Applet所必需的OBJECT或EMBED元素。

如果需要的插件不存在，它会下载插件，然后执行Java组件。 Java组件可以是一个applet或一个JavaBean。

plugin动作有多个对应HTML元素的属性用于格式化Java 组件。param元素可用于向Applet或 Bean 传递参数。

以下是使用plugin 动作元素的典型实例:

<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class"

                           width="60" height="80">

   <jsp:param name="fontcolor" value="red" />

   <jsp:param name="background" value="black" />

   <jsp:fallback>

      Unable to initialize Java Plugin

   </jsp:fallback>

 </jsp:plugin>

如果你有兴趣可以尝试使用applet来测试jsp:plugin动作元素，<fallback>元素是一个新元素，在组件出现故障的错误是发送给用户错误信息。

<jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素

<jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素动态定义XML元素。动态是非常重要的，这就意味着XML元素在编译时是动态生成的而非静态。

以下实例动态定义了XML元素：

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

    pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鸟教程(runoob.com)</title></head><body><jsp:element name="xmlElement"><jsp:attribute name="xmlElementAttr">

   属性值</jsp:attribute><jsp:body>

   XML 元素的主体</jsp:body></jsp:element></body></html>

浏览器访问以下页面，输出结果如下所示：

<jsp:text>动作元素

<jsp:text>动作元素允许在JSP页面和文档中使用写入文本的模板，语法格式如下：

<jsp:text>模板数据</jsp:text>

以上文本模板不能包含其他元素，只能只能包含文本和EL表达式（注：EL表达式将在后续章节中介绍）。请注意，在XML文件中，您不能使用表达式如 ${whatever > 0}，因为>符号是非法的。 你可以使用${whatever gt 0}表达式或者嵌入在一个CDATA部分的值。

<jsp:text><![CDATA[<br>]]></jsp:text>

如果你需要在 XHTML 中声明DOCTYPE,必须使用到<jsp:text>动作元素，实例如下：

<jsp:text><![CDATA[<!DOCTYPE html

PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"DTD/xhtml1-strict.dtd">]]></jsp:text><head><title>jsp:text action</title></head><body>

<books><book><jsp:text>  

    Welcome to JSP Programming</jsp:text></book></books>

</body></html>

3.   include指令和include动作标签的区别

<%@include file = “”%>指令是静态包含

<jsp:include/> 动作标签是动态包含

原理： 包含与被包含的页面先各自翻译成java源文件，然后再运行时合并在一起。

         （先翻译再合并），动态包含

1） 语法不同

静态包含语法： <%@incluefile="被包含的页面"%>

动态包含语法：　<jsp:includepage="被包含的页面">

2）参数传递不同

         静态包含不能向被包含页面传递参数

         动态包含可以向被包含页面传递参数

3）原理不同

         静态包含： 先合并再翻译

         动态包含： 先翻译再合并

4.   JSTL标签

1）.JSTL (全名：java  standard  tag libarary   -  java标准标签库  )

                            核心标签库（c标签库）天天用

                            国际化标签（fmt标签库）

                            EL函数库（fn函数库）

已经过时的两种

                            xml标签库（x标签库）

                   sql标签库（sql标签库）      

2)        .使用步骤

1）导入jstl支持的jar包（标签背后隐藏的java代码）

                                               注意：使用javaee5.0的项目自动导入jstl支持jar包

                            2）使用taglib指令导入标签库

                                                                <%@tagliburi="tld文件的uri名称"prefix="简写"%>

                 3）在jsp中使用标签             

核心标签库的重点标签：

核心标签是最常用的JSTL标签。引用核心标签库的语法如下：

<%@ taglib prefix="c" 

           uri="http://java.sun.com/jsp/jstl/core" %>

1.<c:set></c:set>              

         保存数据：<c:set>标签用于把某一个对象存在指定的域范围内，或者设置Web域中的java.util.Map类型的属性对象或JavaBean类型的属性对象的         属性。

2.<c:outvalue=""></c:out>

获取数据： <c:out> 标签用于输出一段文本内容到pageContext对象当前保存的“out”对象中。

3.<c:iftest=""></c:if>      

    单条件判断：<c:if test=“”>标签可以构造简单的“if-then”结构的条件表达式

4. <c:choose>

          <c:whentest=""></c:when>

          <c:otherwise></c:otherwise>

</c:choose>

多条件判断：<c:choose>标签用于指定多个条件选择的组合边界，它必须与<c:when>和<c:otherwise>标签一起使用。使用<c:choose>，<c:when>和<c:otherwise>三个标签，可以构造类似“if-else if-else”的复杂条件判断结构。

5.<c:forEach></c:forEach>

  <c:forTokensitems=""delims=""></c:forTokens>

循环数据：<c:forEach>标签用于对一个集合对象中的元素进行循环迭代操作，或者按指定的次数重复迭代执行标签体中的内容。

<c:forTokens>用来浏览一字符串中所有的成员，其成员是由定义符号所分隔的

6.<c:redirect></c:redirect>

重定向：<c:redirect>标签用于实现请求重定向

7.<c:remove>标签

用于删除各种Web域中的属性

8.<c:catch>标签

用于捕获嵌套在标签体中的内容抛出的异常，其语法格式如下：<c:catch           [var="varName"]>nestedactions</c:catch>

9.<c:param>标签         

在JSP页面进行URL的相关操作时，经常要在URL地址后面附加一些参数。<c:param>标签可以嵌套在<c:import>、<c:url>或<c:redirect>标签内，为这些标签所使用的URL地址附加参数。

10.<c:import>标签,实现include操作

11.<c:url>标签

用于在JSP页面中构造一个URL地址，其主要目的是实现URL重写。URL重写就是将会话标识号以参数形式附加在URL地址后面

格式化标签

JSTL格式化标签用来格式化并输出文本、日期、时间、数字。引用格式化标签库的语法如下：

<%@ taglib prefix="fmt" 

           uri="http://java.sun.com/jsp/jstl/fmt" %>

JSTL函数

JSTL包含一系列标准函数，大部分是通用的字符串处理函数。引用JSTL函数库的语法如下：

<%@ taglib prefix="fn" 

           uri="http://java.sun.com/jsp/jstl/functions" %>

EL函数库（fn函数库）的使用：

<%--contains 是否存在一个变量--%>${fn:contains("aaa","a")}<%--containsIgnoreCase 是否存在一个变量（忽略大小写）--%>${fn:containsIgnoreCase("aaa","a")}<%--fn:endsWith 以什么结尾--%>${fn:endsWith("bca","a")}<%--fn:startsWith 以什么结尾--%>${fn:startsWith("acb","a")}<%--indexOf 是否存在某个字符或字符串--%>${fn:indexOf("acb","a")}<%--length 某个对象的长度（字符长度）--%>${fn:length("acbAAAA哈哈")}<%--substring截取某个字符长度返回一个新字符--%>${fn:substring("acbAAAA哈哈",0,3)}<%--substringAfter第一次出现a的位置开始截取--%>${fn:substringAfter("acbAAAA哈哈","a")}<%--substringBefore最后一个出现‘c’的位置开始截取--%>${fn:substringBefore("bcbAAcAAa","c")}<%--toLowerCase转换为小写--%>${fn:toLowerCase("bcbAAcAAa")}<%--toUpperCase转换为大写--%>${fn:toUpperCase("bcbAAcAAa")}<%--trim转换为大写--%>${fn:trim("   bcbAAcAAa  ")}<%--split以某个字符切分为一个数组    （数组的类型[Ljava.lang.String;@67cc9a9a）--%>${fn:split("1,2,3,45,6",",")}<%--join给每个数组中的元素拼接一个字符--%>${fn:join((fn:split("1,2,3,45,6",",")),"haha")}<%--  escapeXml将某个标签已字符串格式输出整个标签  --%>${fn:escapeXml("<h1>哈哈<h1>")}<%-- 与c标签库中的out标签中的 c:out标签的escapeXml属性相同 --%><c:out escapeXml="true"value="<h1>哈哈<h1>"></c:out>

5. 自定义标签：

jsp自定义标签 Tag文件版

1.在WEB-INF/tags/if.tag

<%@taglanguage="java"pageEncoding="UTF-8"%><%@attributename="text"required="true"type="java.lang.Boolean"%><%if(text){%>   <jsp:doBody></jsp:doBody><%}%>

这里要注意tag文件只能放在如下位置:
1.WEB-INF/tags
2.WEB-INF/tags的子目录
3.WEB-INF/lib中jar包的META-INF/tags
4.WEB-INF/lib中jar包的META-INF/tags下的子目录
5.jar包中的tag文件需要tld
添加jstl.jar与standard.jar到WEB-INF/lib目录,还有一点就是上面标红的部分:不要使用http://java.sun.com/jstl/core这个url,否则会报foreach中的item属性有问题

2.在jsp中的使用

<%@pageimport="java.util.ArrayList"%><%@pageimport="java.util.List"%><%@ page language="java"contentType="text/html;charset=UTF-8"pageEncoding="UTF-8"%><%@ taglib tagdir="/WEB-INF/tags"prefix="my"%><!DOCTYPEhtmlPUBLIC "-//W3C//DTDHTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd"><html><head><metahttp-equiv="Content-Type"content="text/html;charset=UTF-8"><title>Insert title here</title></head><body><%--自定义if标签 --%><my:iftext="${1==1}"><%--自定义out标签 --%><my:outvalue="<h1>哈哈哈</h1>"></my:out></my:if></body></html>

jsp 自定义标签

jsp标签有两组api
JspTag ->SimpleTag ->SimpleTagSupport
JspTag ->Tag ->IterationTag->BodyTag
第二组是classic的,比较早的使用方式,doStartTag(),doEndTag()有N多返回值的那种,使用起来也确实不方便,今天学到了另一个使用第一组api方式的,让人大快人心,贴码
例子是一个Select的标签,支持动态属性设置
1.编写标签类

publicclass SelectTagHandler extends SimpleTagSupport implements DynamicAttributes {private static final String ATTR_TEMPLATE = "%s='%s'";private static final String OPTION_TEMPLATE = "<optionvalue='%1$s'>%1$s</option>";private List optionsList;private String name;private String size;private Map<String, Object> tagAttrs = new HashMap<String,Object>();publicvoid setName(String name) {this.name = name;}publicvoid setSize(String size) {this.size = size;}publicvoid setOptionsList(List optionsList) {this.optionsList = optionsList;}@Overridepublic void doTag() throws JspException, IOException {PageContext pageContext = (PageContext) getJspContext();JspWriter out = pageContext.getOut();out.print("<select ");out.print(String.format(ATTR_TEMPLATE, "name",this.name));out.print(String.format(ATTR_TEMPLATE, "size",this.size));for(String attrName : tagAttrs.keySet()) {StringattrDefinition = String.format(ATTR_TEMPLATE, attrName,tagAttrs.get(attrName));out.print(attrDefinition);}out.print(">");for(Object option : this.optionsList) {StringoptionTag = String.format(OPTION_TEMPLATE, option.toString());out.println(optionTag);}out.println("</select>");}@Overridepublicvoid setDynamicAttribute(String uri, String name, Object value) throwsJspException {tagAttrs.put(name,value);}
}

看到没,代码如此的简洁,动态属性配置也十分的方便,不用写N多个setter与getter方法.

2.编写tld文件WebRoot/tld/select.tld

<?xmlversion="1.0" encoding="UTF-8" ?>
<taglibxmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3g.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"
version="2.0"><tlib-version>1.2</tlib-version><jsp-version>1.2</jsp-version><short-name>Forms Taglib</short-name><uri>http://hi.baidu.com/tags/forms</uri><description>An example tab library of replacements for the html form tags.</description><tag><name>select</name><tag-class>com.baidu.hi.tag.SelectTagHandler</tag-class><body-content>empty</body-content><attribute><name>optionsList</name><required>true</required><rtexprvalue>true</rtexprvalue><type>java.util.List</type></attribute><attribute><name>name</name><required>true</required></attribute><attribute><name>size</name><required>true</required></attribute><dynamic-attributes>true</dynamic-attributes></tag>
</taglib>

3.在jsp中的使用

<%@page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><%@ page import="java.util.*" %>
<%@ taglib  prefix="formTags" uri="/tld/select.tld"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<%@page import="java.util.ArrayList"%><html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%List<String> colorList = new ArrayList<String>();colorList.add("red");colorList.add("blue");colorList.add("white");request.setAttribute("colorList",colorList);
%>
<form action="" method="post"><formTags:select name="color" size="1"optionsList="${requestScope.colorList}" style="width:140px"/>
</form>
</body>
</html>