Jsp详解

Jsp详解

1.简介

2.Jsp的运行原理

3.Jsp的语法

1.Jsp模板元素

2.Jsp中的脚本表达式

3.Jsp中的脚本片段

4.Jsp的声明

5.Jsp注释

6.Jsp指令

1.首先我们来看一下page指令的用法

2.下面在来看一下include指令

3.最后来看一下taglib指令

7.Jsp中内置的9个隐式对象

8.JSP标签库

1.jspinclude标签

2.jspforward标签

3.jspparam或者jspparams标签

4.jspuseBean标签jspsetProperty标签jspgetProperty标签

9.Jsp中怎么排查错误

简介：

JSP全称是JavaServer Pages，它和servle技术一样，都是SUN公司定义的一种用于开发动态web资源的技术。

JSP这门技术的最大的特点在于，写jsp就像在写html，但：

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

相比servlet而言，servlet很难对数据进行排版，而jsp除了可以用java代码产生动态数据的同时，也很容易对数据进行排版。

不管是JSP还是Servlet，虽然都可以用于开发动态web资源。但由于这2门技术各自的特点，在长期的软件实践中，人们逐渐把servlet作为web应用中的控制器组件来使用，而把JSP技术作为数据显示模板来使用。

其原因为，程序的数据通常要美化后再输出：

让jsp既用java代码产生动态数据，又做美化会导致页面难以维护。

让servlet既产生数据，又在里面嵌套html代码美化数据，同样也会导致程序可读性差，难以维护。

因此最好的办法就是根据这两门技术的特点，让它们各自负责各的，servlet只负责响应请求产生数据，并把数据通过转发技术带给jsp，数据的显示jsp来做。

Jsp的运行原理:

目标：

Web服务器是如何调用并执行一个jsp页面的？

Jsp页面中的html排版标签是如何被发送到客户端的？

Jsp页面中的java代码服务器是如何执行的？

Web服务器在调用jsp时，会给jsp提供一些什么java对象？

思考：JSP为什么可以像servlet一样，也可以叫做动态web资源的开发技术？

其实Jsp就是一个Servlet，所以我们要先介绍Servlet的相关技术，当我们第一次访问Jsp 的时候，Jsp引擎都会将这个Jsp翻译成一个Servlet，这个文件存放在Tomcat中的work目录中，这里，我们新建一个MyJsp.jsp页面，然后访问以下，我们看一下翻译后的源码：

1.<%@ page language="java"import="java.util.*"pageEncoding="utf-8"%>

2.

3.

4.01 Transitional//EN">

4.

5.

6.

7.

8.

9.

10.

11.

12. This is my JSP page.

13.

14.

1.package org.apache.jsp;

2.

3.import javax.servlet.*;

4.import javax.servlet.http.*;

5.import javax.servlet.jsp.*;

6.import java.util.*;

7.

8.public final class MyJsp_jsp extends org.apache.jasper.runtime.HttpJspBase

9.implements org.apache.jasper.runtime.JspSourceDependent {

10.

11.private static final JspFactory _jspxFactory = JspFactory.getDefaultFactor

y();

12.

13.private static java.util.List _jspx_dependants;

14.

15.private javax.el.ExpressionFactory _el_expressionfactory;

16.private org.apache.AnnotationProcessor _jsp_annotationprocessor;

17.

18.public Object getDependants() {

19.return _jspx_dependants;

20. }

21.

22.public void _jspInit() {

23. _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServlet

Config().getServletContext()).getExpressionFactory();

24. _jsp_annotationprocessor = (org.apache.AnnotationProcessor) getServletCo

nfig().getServletContext().getAttribute(org.apache.AnnotationProcessor.class .getName());

25. }

26.

27.public void _jspDestroy() {

28. }

29.

30.public void _jspService(HttpServletRequest request, HttpServletResponse re

sponse)

31.throws java.io.IOException, ServletException {

32.

33. PageContext pageContext = null;

34. HttpSession session = null;

35. ServletContext application = null;

36. ServletConfig config = null;

37. JspWriter out = null;

38. Object page = this;

39. JspWriter _jspx_out = null;

40. PageContext _jspx_page_context = null;

41.

42.

43.try {

44. response.setContentType("text/html;charset=utf-8");

45. pageContext = _jspxFactory.getPageContext(this, request, response,

46.null, true, 8192, true);

47. _jspx_page_context = pageContext;

48. application = pageContext.getServletContext();

49. config = pageContext.getServletConfig();

50. session = pageContext.getSession();

51. out = pageContext.getOut();

52. _jspx_out = out;

53.

54. out.write("\r\n");

55. out.write("\r\n");

56. out.write("

/EN\">\r\n");

57. out.write("\r\n");

58. out.write(" \r\n");

59. out.write(" \r\n");

60. out.write(" \r\n");

61. out.write(" \r\n");

62. out.write(" \r\n");

63. out.write(" \r\n");

64. out.write(" \r\n");

65. out.write(" This is my JSP page.
\r\n");

66. out.write(" \r\n");

67. out.write("\r\n");

68. } catch (Throwable t) {

69.if (!(t instanceof SkipPageException)){

70. out = _jspx_out;

71.if (out != null && out.getBufferSize() != 0)

72.try { out.clearBuffer(); } catch (java.io.IOException e) {}

73.if (_jspx_page_context != null) _jspx_page_context.handlePageExcepti

on(t);

74. }

75. } finally {

76. _jspxFactory.releasePageContext(_jspx_page_context);

77. }

78. }

79.}

我们看到，这个类继承了org.apache.jasper.runtime.HttpJspBase，要想看到这个类的源码，我

1./*

2. * Licensed to the Apache Software Foundation (ASF) under one or more

3. * contributor license agreements. See the NOTICE file distributed with

4. * this work for additional information regarding copyright ownership.

5. * The ASF licenses this file to You under the Apache License, Version 2.0

6. * (the "License"); you may not use this file except in compliance with

7. * the License. You may obtain a copy of the License at

8. *

9. * https://www.360docs.net/doc/6418980760.html,/licenses/LICENSE-2.0

10. *

11. * Unless required by applicable law or agreed to in writing, software

12. * distributed under the License is distributed on an "AS IS" BASIS,

13. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

14. * See the License for the specific language governing permissions and

15. * limitations under the License.

16. */

17.

18.package org.apache.jasper.runtime;

19.

20.import java.io.IOException;

21.

22.import javax.servlet.ServletConfig;

23.import javax.servlet.ServletException;

24.import javax.servlet.http.HttpServlet;

25.import javax.servlet.http.HttpServletRequest;

26.import javax.servlet.http.HttpServletResponse;

27.import javax.servlet.jsp.HttpJspPage;

28.import javax.servlet.jsp.JspFactory;

29.

30.import https://www.360docs.net/doc/6418980760.html,piler.Localizer;

31.

32./**

33. * This is the super class of all JSP-generated servlets.

34. *

35. * @author Anil K. Vijendran

36. */

37.public abstract class HttpJspBase

38.extends HttpServlet

39.implements HttpJspPage

40.

41.

42.{

43.

44.protected HttpJspBase() {

45. }

46.

47.public final void init(ServletConfig config)

48.throws ServletException

49. {

50.super.init(config);

51. jspInit();

52. _jspInit();

53. }

54.

55.public String getServletInfo() {

56.return Localizer.getMessage("https://www.360docs.net/doc/6418980760.html,");

57. }

58.

59.public final void destroy() {

60. jspDestroy();

61. _jspDestroy();

62. }

63.

64./**

65. * Entry point into service.

66. */

67.public final void service(HttpServletRequest request, HttpServletRespons

e response)

68.throws ServletException, IOException

69. {

70. _jspService(request, response);

71. }

72.

73.public void jspInit() {

74. }

75.

76.public void _jspInit() {

77. }

78.

79.public void jspDestroy() {

80. }

81.

82.protected void _jspDestroy() {

83. }

84.

85.public abstract void _jspService(HttpServletRequest request,

86. HttpServletResponse response)

87.throws ServletException, IOException;

88.}

好吧，看到了，继承了HttpServlet类，所以说其实Jsp就是一个Servlet

Jsp的语法:

1.JSP模版元素

2.JSP表达式

3.JSP脚本片段

4.JSP注释

5.JSP指令

6.JSP标签

7.JSP内置对象

8.如何查找JSP页面中的错误

Jsp模板元素

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

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

Jsp中的脚本表达式

JSP脚本表达式（expression）用于将程序数据输出到客户端

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

举例：当前时间:<%= new java.util.Date() %>

JSP引擎在翻译脚本表达式时，会将程序数据转成字符串，然后在相应位置用out.print(…) 将数据输给客户端。

JSP脚本表达式中的变量或表达式后面不能有分号(;)。

如下图：Jsp翻译之后的Servlet中的脚本表达式翻译的结果：

就是将脚本表达式中的代码原封不动的使用out.print()输出

Jsp中的脚本片段

JSP脚本片断（scriptlet）用于在JSP页面中编写多行Java代码。语法：

<%

多行java代码

%>

注意：JSP脚本片断中只能出现java代码，不能出现其它模板元素，JSP引擎在翻译JSP 页面中，会将JSP脚本片断中的Java代码将被原封不动地放到Servlet的_jspService方法中。JSP脚本片断中的Java代码必须严格遵循Java语法，例如，每执行语句后面必须用分号（;）结束。

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

1.<%

2. int x = 10;

3. out.println(x);

4.%>

5.

这是JSP页面文本

6.<%

7. int y = 20;

8. out.println(y);

9.%>

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

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

1.<%

2. for (int i=1; i<5; i++)

3. {

4.%>

5.

https://www.360docs.net/doc/6418980760.html,

6.<%

7. }

8.%>

Jsp的声明

JSP页面中编写的所有代码，默认会翻译到servlet的service方法中，而Jsp声明中的java 代码被翻译到_jspService方法的外面。语法：

<%！

java代码

%>

所以，JSP声明可用于定义JSP页面转换成的Servlet程序的静态代码块、成员变量和方法。多个静态代码块、变量和函数可以定义在一个JSP声明中，也可以分别单独定义在多个JSP 声明中。

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

1.<%!

2.static

3.{

4. System.out.println("loading Servlet!");

5.}

6.private int globalVar = 0;

7.public void jspInit()

8.{

9. System.out.println("initializing jsp!");

10.}

11.%>

12.<%!

13.public void jspDestroy()

14.{

15. System.out.println("destroying jsp!");

16.}

17.%>

Jsp注释

JSP注释的格式：

<%-- 注释信息--%>

JSP引擎在将JSP页面翻译成Servlet程序时，忽略JSP页面中被注释的内容。

Jsp指令

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

page指令

Include指令

taglib指令

JSP指令的基本语法格式：

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

首先我们来看一下page指令的用法

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

JSP 2.0规范中定义的page指令的完整语法：

<%@ page

[ language="java" ]

[ extends="package.class" ]

[ import="{package.class | package.*}, ..." ]

[ session="true | false" ]

[ buffer="none | 8kb | sizekb" ]

[ autoFlush="true | false" ]

[ isThreadSafe="true | false" ]

[ info="text" ]

[ errorPage="relative_url" ]

[ isErrorPage="true | false" ]

[ contentType="mimeType [ ;charset=characterSet ]" | "text/html ; charset=ISO-8859-1" ]

[ pageEncoding="characterSet | ISO-8859-1" ]

[ isELIgnored="true | false" ]

%>

1.看一下通过page指令设置页面的编码：

举例：<%@ page contentType="text/html;charset=gb2312"%>

这个指令的作用就相当于response.setContentType("text/html;charset=gb2312");

但是这个指令和

<%@ page pageEncoding="gb2312"%>

的区别是：

pageEncoding是jsp文件本身的编码

contentType的charset是指服务器发送给客户端时的内容编码

JSP要经过两次的“编码”，第一阶段会用pageEncoding，第二阶段会用utf-8至utf-8，第三阶段就是由Tomcat出来的网页，用的是contentType。

第一阶段是jsp编译成.java，它会根据pageEncoding的设定读取jsp，结果是由指定的编码方案翻译成统一的UTF-8 JAVA源码（即.java），如果pageEncoding设定错了，或没有设定，出来的就是中文乱码。

第二阶段是由JAVAC的JAVA源码至java byteCode的编译，不论JSP编写时候用的是什么编码方案，经过这个阶段的结果全部是UTF-8的encoding的java源码。

JAVAC用UTF-8的encoding读取java源码，编译成UTF-8 encoding的二进制码（即.class），这是JVM对常数字串在二进制码（java encoding）内表达的规范。

第三阶段是Tomcat（或其的application container）载入和执行阶段二的来的JAVA二进制码，输出的结果，也就是在客户端见到的，这时隐藏在阶段一和阶段二的参数contentType就发挥了功效

contentType的設定.

pageEncoding 和contentType的预设都是ISO8859-1. 而随便设定了其中一个, 另一个就跟着一样了(TOMCAT4.1.27是如此). 但这不是绝对的, 这要看各自JSPC的处理方式. 而pageEncoding不等于contentType, 更有利亚洲区的文字CJKV系JSP网页的开发和展示, (例pageEncoding=GB2312 不等于contentType=utf-8)。

jsp文件不像.java，.java在被编译器读入的时候默认采用的是操作系统所设定的locale所对应的编码，比如中国大陆就是GBK，台湾就是BIG5或者MS950。而一般我们不管是在记事本还是在ue中写代码，如果没有经过特别转码的话，写出来的都是本地编码格式的内容。所以编译器采用的方法刚好可以让虚拟机得到正确的资料。

但是jsp文件不是这样，它没有这个默认转码过程，但是指定了pageEncoding就可以实现正确转码了。

因为我们使用了MyEclipse开发工具，只要我们设置其中一个编码就会将该文件的编码以及页面访问编码都设置好了，例如：

我们使用指令：

<%@ page contentType="text/html;charset=gb2312"%>

我们看一下翻译之后的servlet代码：

我们在来看一下这个文件的编码：

可以看到都是gb2312的编码，

同样我们在使用指令：

<%@ page pageEncoding="utf-8"%>

效果和上面一样的，会同时将文件的编码和页面浏览的编码都设置成了utf-8编码，这些动作都是得益于MyEclipse的智能，如果你使用txt文本开发的话，就不会有这样的结果了。

那么当我们同时使用这两个命令的话是什么样的结果呢：

<%@ page contentType="text/html;charset=gb2312"%>

<%@ page pageEncoding="utf-8"%>

这时候我就会发现，文件的编码是utf-8,而页面浏览的编码是gb2312,所以说上面的一条指令是专门设置页面浏览的编码的，下面的指令是专门设置文件的保存编码的。出现以上的结果都是因为使用了MyEclipse开发工具。

2.通过page指令导入java包：

JSP 引擎自动导入下面的包：

https://www.360docs.net/doc/6418980760.html,ng.*

javax.servlet.*

javax.servlet.jsp.*

javax.servlet.http.*

可以在一条page指令的import属性中引入多个类或包，其中的每个包或类之间使用逗号分隔：

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

上面的语句也可以改写为使用多条page指令的import属性来分别引入各个包或类：

<%@ page import="java.util.Date"%>

<%@ page import="java.sql.*"%>

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

3.下面在来看一下buffer属性：

<%@ page buffer="4kb" %>

使用这个属性是指定out对象的缓存大小，关于out对象，我们后面会说到，比如我们这里设置了out的缓冲区是4kb，我们可以看一下翻译后的代码：

如果我们想关闭缓冲区的话，只需要设置值为none就可以了

4.下面在来看一下isThreadSafe属性：

这个属性见名知意，是设置是否线程安全的，我们在之前讨论Servlet的时候，说到了Servlet 是个单例对象，是线程不安全的，我们那时候可以通过实现一个接口来实现线程安全，这里只需要设置这个属性值就可以控制Jsp翻译之后的Servlet时候线程安全：

<%@ page isThreadSafe="true|false" %> 默认值为true

isThreadSafe=false模式表示它是以Singleton模式运行。

该模式implements了接口SingleThreadMode,

该模式同一时刻只有一个实例，不会出现信息同步与否的概念。

若多个用户同时访问一个这种模式的页面，

那么先访问者完全执行完该页面后，后访问者才开始执行。

isThreadSafe=true模式表示它以多线程方式运行。

该模式的信息同步，需访问同步方法(用synchronized标记的)来实现。

我们将值设置成false之后发现翻译Jsp之后的Servlet：

实现了SingleThreadModel接口。

5.下面在来看一下session属性：

<%@ page session="false|true"%>默认值是true

是指不能在本页使用session.也就是在本页面禁用了session

就是在将Jsp翻译成Servlet的时候不会传递Session对象了，比如我们将他设置成false,查看翻译后的Servlet源码：

我们发现并没有HttpSession对象，所以我们也不能在Jsp页面中使用session对象了

6.下面来看一下errorPage属性

这个属性是设置服务器端出错之后的错误页面的，比如我们在编写服务器代码的时候，突然抛出异常，那么会返回一个500，这样给用户的感觉就很恶心，所以我们要做的人性化一点，就是通过这个属性值，设置一个错误页面，当服务器发生错误的时候都会跳转到这个页面中，比如：

<%@ page errorPage="/error.jsp"%>

1.<%

2. int x = 1/0;

3.%>

这样就会抛出异常，我们访问这个Jsp看一下效果：

转到了错误页面，同时我们观察地址栏可以发现这里面使用的是转发技术，所以我们在书写url地址的时候，那个开始的斜杠代表是当前应用，因为这个地址是给服务器用的(这个原则我们在之前说过了)

这里在拓展一下，如果我们想给应用配置一个全局的错误页面我们该怎么配置呢？

1.

2.

3.Exception

4./error.jsp

5.

6.

7.

8.404

9./error.jsp

10.

11.

12.

13.500

14./error.jsp

15.

我们看到这里可以配置抛出的异常类型所对应的错误页面，也可以配置状态码对应的错误页面，而且这里配置的结果的优先级没有errorPage属性配置错误页面的优先级高。

7.同时还有一个属性就是isErrorPages:

<@ page isErrorPages="false|true"%>默认值是true

是否开启错误页面，就是控制上面的errorPage属性的作用开关的

8.属性isELIgnored

<@ page isELIgnored="false|true"%>默认值是false

是否在该页面中忽视EL表达式的功能，这个我们一般都不去做设置，因为我们在页面中肯定会使用到EL表达式的

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

例如：

1.<%@ page contentType="text/html;charset=gb2312"%>

2.<%@ page import="java.util.Date"%>

1.<%@ page contentType="text/html;charset=gb2312"import="java.util.Date"%>

下面在来看一下include指令

include指令很简单，就是实现页面包含的，我们之前在介绍request的时候，说到使用代码进行页面包含，那时候我们说到了，这个代码来实现页面包含是动态包含，而使用include 指令来实现页面包含是静态包含，关于静态包含和动态包含，我们在下面介绍jsp:include标签的时候在详细说明

最后来看一下taglib指令

这个指令作用也是很简单的，就是引入标签，这个之后再我们后面接收JSTL的内容的时候在作介绍

Jsp中内置的9个隐式对象

每个JSP 页面在第一次被访问时，WEB容器都会把请求交给JSP引擎（即一个Java程序）去处理。JSP引擎先将JSP翻译成一个_jspServlet(实质上也是一个servlet) ，然后按照servlet 的调用方式进行调用。

由于JSP第一次访问时会翻译成servlet，所以第一次访问通常会比较慢，但第二次访问，JSP 引擎如果发现JSP没有变化，就不再翻译，而是直接调用，所以程序的执行效率不会受到影响。