JSP 内置对象和域

1. JSP 九大内置对象简介

JSP 脚本中包含 9 个内置对象，这 9 个内置对象都是 Servlet API 接口的实例，只是 JSP 规范对它们进行了默认的初始化（由 JSP 页面对应的 Servlet 的 _jspService() 方法来创建这些实例），即它们已经是对象了，可以直接使用。

9 个内置对象依次如下：

application

javax.servlet.ServletContext 的实例，该实例代表 JSP 所属的 Web 应用本身，可用于 JSP 页面或者在 Servlet 之间交换信息。常用方法有 getAttribute(String attName)、setAttribute(String attName, String attValue) 和 getInitParameter(String paramName) 等。

config

javax.servlet.ServletConfig 的实例，该实例代表该 JSP 配置信息。常用方法有 getInitParameter(String paramName) 和 getInitParameters() 等方法。事实上，JSP 页面通常无须配置，也就不存在配置信息，因此，该对象更多地在 Servlet 中有效。

exception

java.lang.Throwable 的实例，该实例代表其他页面中的导演和错误。只有当页面中错误处理页面，即编译指令 page 的isErrorPage 属性为 true 时，该对象才可以使用。常用的方法有 getMessage() 和 printStackTrace() 等。

out

javax.servlet.jsp.JspWriter 的实例，该实例代表 JSP 页面的输出流，用于输出内容形成 HTML 页面。

page

代表该页面本身，通常没什么太大用处。也就是 Servlet 中的 this，其类型就是生成的 Servlet 类，能用 page 的地方就能用 this。

pageContext

javax.servlet.jsp.PageContext 的实例，该对象代表该 JSP 页面的上下文，使用该对象可以访问页面中的共享数据。常用的方法有 getServletContext() 和 getServletConfig() 等。

request

javax.servlet.http.HttpServletRequest 的实例，该对象封装了一次请求，客户端的请求参数都被封装在该对象里。这是一个常用对象，获取客户端请求必须使用该对象。常用的方法有 getParameter(String paramName)、 getParameterValues(String paramName)、 setAttribute(String attrName, Object attrValue)、 getAttribute(String attrName) 和 setCharacterEncoding(String env) 等。

response

javax.servlet.http.HttpServletResponse 的实例，代表服务器对客户端的响应。通常很少使用该对象直接响应，而是使用 out 对象，除非需要生成非字符响应，response 对象常用于重定向。常用的方法有 getOutputStream()、 sendRedirect(java.lang.String location) 等。

session

javax.servlet.http.HttpSession 的实例，该对象代表一次会话。当客户端浏览器与站点建立连接时，会话开始；当客户端关闭浏览器时，会话结束。常用的方法有 getAttribute(String attrName)、 setAttribute(String attrName, Object attrValue) 等。

打开 Tomcat\work\cataline\localhost\…\jsp，其中几乎所有的 JSP 页面编译后 Servlet 类都有如下所示结构：

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase implements org.apache.jasper.runtime.JspSourceDependent {

    public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

        final javax.servlet.jsp.PageContext pageContext;
        final javax.servlet.ServletContext application;
        final javax.servlet.ServletConfig config;
        javax.servlet.jsp.JspWriter out = null;
        final java.lang.Object page = this;
        javax.servlet.jsp.JspWriter _jspx_out = null;
        javax.servlet.jsp.PageContext _jspx_page_context = null;

        try {
            response.setContentType("text/html");
            pageContext = _jspxFactory.getPageContext(this, request, response,
                    null, false, 8192, true);
            _jspx_page_context = pageContext;
            application = pageContext.getServletContext();
            config = pageContext.getServletConfig();
            out = pageContext.getOut();
            _jspx_out = out;

            // ...
        }
    }
}

说明：

• 通过上面的代码可以发现 JSP 内置对象的实质：它们要么是 _jspService() 方法的形参，要么是 _jspService() 方法的局部变量，所以我们直接在 JSP 脚本（脚本对应于 Servlet 的 _jspService() 方法部分）中调用这些对象，无须创建它们。
• 上面的代码中并没有 exception 内置对象，只有当页面的 page 指令的 isErrorPage 属性为 true 时，才可使用 exception 对象，也就是说：只有异常处事页面对应的 Servlet 时才会初始化 exception 对象。

注意：
由于 JSP 内置对象都是在 _jspService() 方法中完成初始化的，因此在 JSP 脚本、JSP 输出表达式中使用这些内置对象，不能在 JSP 声明中使用它们，否则，系统将提示找不到这些变量。

2. application 对象

application 对象代表 Web 应用本身，因此使用 application 来操作 Web 应用相关数据。application 对象通常有如下两个作用：

• 在整个 Web 应用的多个 JSP、Servlet 之间共享数据。
• 访问 Web 应用的配置参数

2.1 让多个 JSP、Servlet 共享数据

application 通过 setAttribute(String attrName, Object value) 方法将一个值设置成 application 的 attrName 属性，该属性的值对整个 Web 应用有效，因此该 Web 应用的每个 JSP 页面或 Servlet 都可以访问该属性，访问该属性的方法为 getAttribute(String attrName)。

在 JSP 中可直接通过 application 内置对象在 JSP 脚本或者表达式中进行赋值和取值：

<%
    application.setAttribute("name", "JSP")
%>

<%=application.getAttribute("name")%>

在 Servlet 中，必须先获取 ServletContext 对象，才能进行赋值和取值：

ServletContext sc = getServletContext();
// ServletContext sc = getServletConfig().getServletContext();

sc.setAttribute("name", "Servlet");
sc.getAttribute("name");

建议：
虽然使用 application（即 ServletContext 实例）可以方便多个 JSP、Servlet 共享数据，但不要仅为了 JSP、Servlet 共享数据就将数据放入 application 中。由于 application 代表整个 Web 应用，所以通常只应该把 Web 应用的状态数据放入 application 里。

2.2 获取 Web 应用配置参数

因为 application 对象代表 Web 应用本身，所以可用于获取 Web 应用的初始化配置参数。

在 JSP 页面中的访问方式如下：

<% String name = application.getInitParameter("name"); %>

在 web.xml 文件的根元素（web-app）下配置 Web 应用的初始化参数：

<web-app ...>
    ......
    <context-param>
        <param-name>name</param-name>
        <param-value>web</param-value>
    </context-param>
</web-app>

3. config 对象

config 对象代表当前 JSP 配置信息，但 JSP 页面通常无须配置，也就不存在配置信息。此对象在 JSP 页面中比较少用，此处简单作说明，但在 Servlet 中则用处相对较大，详见 Servlet。

在 JSP 获取配置参数：

<%=config.getServletName()%>
<%=config.getInitParameter("name")%>

在 web.xml 中为 JSP 配置初始化参数：

<servlet>
    <servlet-name>config</servlet-name>
    <jsp-file>/config.jsp</jsp-file>
    <init-param>
        <param-name>name</param-name>
        <param-value>jsp config</param-value>
    </init-param>
</servlet>

注意：
由于对 JSP 进行了如上配置（相当于将 JSP 作为 Servlet 进行配置），所以，此 JSP 页面存在两种访问方式：

1. 正常的 JSP 访问方式：http://localhost:8080/WebProject/config.jsp
2. Servlet 的访问方式：http://localhost:8080/WebProject/config

不过要想在 JSP 页面中通过 config 内置对象获取在 web.xml 中配置的初始化参数，必须使用第二种方式。

4. exception 对象

exception 对象是 Throwable 的实例，代表 JSP 脚本中产生的错误和异常，是 JSP 页面异常机制的一部分。

在 JSP 脚本中无须处理异常，即使该异常是 checked 异常。事实上，JSP 脚本包含的所有可能出现的异常都可交给错误处理页面处理。

打开普通的 JSP 页面生成的 Servlet 类如下：

public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

    // 内置对象定义，init()，destory()...

    try {
        // 内置对象初始化，所有 JSP 脚本、静态 HTML 部分都会转换成此部分代码
    } catch (java.lang.Throwable t) { // 异常处理
        if (!(t instanceof javax.servlet.jsp.SkipPageException)) {
            out = _jspx_out;
            if (out != null && out.getBufferSize() != 0)
                try {
                    if (response.isCommitted()) {
                        out.flush();
                    } else {
                        out.clearBuffer();
                    }
                } catch (java.io.IOException e) {}
            if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
            else throw new ServletException(t);
        }
    } finally { // 释放资源
        _jspxFactory.releasePageContext(_jspx_page_context);
    }
}

说明：

• 从上面的代码可以看出，JSP脚本和静态 HTML 部分都将转换成 _jspService() 方法中的执行性代码，且已经处于 try-catch 块中，一旦捕获到 JSP 脚本异常，并且 _jsp_page_context 不为 null，就会以由该对象来处理异常。
• _jsp_page_context 对异常的处理：如果该页面的 page 指令指定了 errorPage，则将请求 forward 到 errorPage 属性指定的页面，否则使用系统页面来输出异常信息。
• 由于只有 JSP 脚本、表达式才会对应于 _jspService() 方法里的代码，所以，对于 JSP 声明部分的 checked 异常仍需要用户手动处理。

在 JSP 的异常处理机制中，一个异常处理页面可以处理多个 JSP 页面脚本部分的异常，异常处理页面通过 page 指令的 errorPage 属性确定。在异常处理页面中，需要通过 page 指令中指定 isErrorPage 属性为 true，否则 JSP 的异常处理机制无法找到 errorPage 属性指定的异常处理页面，该页面中也无法访问 exception 内置对象。

在 JSP 的异常处理页面，可以使用如下方法获取异常信息：

异常类型：<%=exception.getClass()%>
异常信息：<%=exception.getMessage()%>

5. out 对象

out 对象代表一个页面输出流，通常用于在页面上输出变量值及常量。一般在使用输出表达式的地方，都可以使用 out 对象来达到同样的效果，<%=...%> 的本质就是 out.write(…)。建议使用输出表达式，更加简洁。

在 JSP 页面中使用 out 对象的语法如下：

<%
    out.write("abc");
%>

6. pageContext 对象

这个对象代表页面上下文，该对象主要用于访问 JSP 之间的共享数据。使用 pageContext 对象可以访问 page、request、session 和 application 范围的变量。

pageContext 是 PageContext 实例，它提供了如下两个方法来访问 page、request、session 和 application 范围的变量：

1. getAttribute(String name)：取得 page 范围内的 name 属性

2. getAttribute(String name, int scope)：取得指定范围内的 name 属性，其中 scope 可以是如下 4 个常量值：

   • PageContext.PAGE_SCOPE（1）：对应于 page 范围
   • PageContext.REQUEST_SCOPE（2）：对应于 request 范围
   • PageContext.SESSION_SCOPE（3）：对应于 session 范围
   • PageContext.APPLICATION_SCOPE（4）：对应于 application 范围

与 getAttribute() 方法相对应，PageContext 也提供了 2 个对应的 setAttribute() 方法，用于将指定变量的值存入指定的范围内：

1. setAttribute(String name, Object value)
2. setAttribute(String name, Object value, int scope)

在 JSP 页面中使用 pageContext 对象进行相关范围内的赋值与取值语法：

<%
    pageContext.setAttribute("username", "administrator", PageContext.SESSION_SCOPE);

    pageContext.getAttribute("username", PageContext.SESSION_SCOPE);
%>

pageContext 还可获取其他内置对象，方法如下：

• ServletRequest getRequest()
• ServletResponse getResponse()
• ServletConfig getServletConfig()
• ServeltContext getServeltContext()
• HttpSession getSession()

因此一旦在 JSP、Servlet 编程中获取了 pageContext 对象，就可以通过它获取其他内置对象。

7. request 对象

每个 request 对象封装着一次用户请求，并且所有的请求参数都被封装在 request 对象中。该对象通常有如下几个作用：

• 获取请求参数
• 用于操作 request 范围的属性
• 执行 forward 或 include

7.1 获取请求参数

request 是 HttpServletRequest 接口的实例，它提供了如下几个方法来获取请求参数：

• String getParameter(String paramName)：获取 paramName 请求参数的值
• Map getParameterMap()：获取所有请求参数名和参数值所组成的 Map 对象
• Enumeration getParameterNames()：获取所有请求参数所组成的 Enumeration 对象
• String[] getParameterValues(String name)：paramName 请求参数的值，当该请求参数有多个值时，该 方法返回多个值所组成的数组。

HttpServletRequest 提供了如下方法来访问请求头：

• String getHeader(String name)：获取指定请求头的值
• Enumeration getHeaderNames()：获取所有请求头的名称
• Enumeration getHeaders(String name)：获取指定请求头的多个值
• int getIntHeader(String name)：获取指定请求头的值，并将该值转为整数值

7.2 操作 request 范围的属性

HttpServletRequest包含如下两个方法，用于设置和获取 request 范围的属性：

• setAttribute(String attName, Object attValue)：将 attValue 设置成 request 范围的属性
• Object getAttribute(String attName)：获取 request 范围的属性

7.3 执行 forward 或 include

除了 JSP 提供的 forward 和 include 动作指令，request 也可以执行 forward 和 include。

HttpServletRequest 类提供了一个 getRequestDispatcher(String path) 方法，其中 path 就是希望 forward 或者 include 的目标路径，该方法返回 RequestDispatcher，该对象提供了如下两个方法：

• forward(ServletRequest request, ServletResponse response)：执行 forward
• include(ServeltRequest request, ServletResponse response)：执行 include

8. response 对象

response 对象代表服务器对客户端的响应。通常情况下，在 JSP 页面中直接使用 out 对象来输出响应信息即可，但 out 是 Writer 的子类，是一个字符输出流，对于非字符内容，就必须使用 response 作为输出响应。除此之外，还可以使用 response 来重定向请求以及用于向客户端增加 Cookie。

8.1 response 响应生成非字符响应

response 是 HttpServletResponse 接口的实例，该接口提供了一个 getOutputStream() 方法，该方法返回响应的输出字节流。

8.2 重定向

HttpServletResponse 提供了一个 sendRedirect(String path) 方法，该方法用于重定向到 path 资源，即重新向 path 资源发送请求。

8.3 增加 Cookie

Cookie 通常用于网站记录客户的某些信息，存放客户端机器上，直到超出 Cookie 的生命期限。客户端浏览器完全可以禁用 Cookie，所以使用 Cookie 必须客户端浏览器支持才行。

response 对象提供如下方法增加 Cookie：

• void addCookie(Cookie cookie)

9. session 对象

session 对象代表一次用户会话。一次用户会话是从客户端浏览器连接服务器开始，到客户端浏览器与服务器断开为止。session 范围内的属性可以在多个页面的跳转之间共享，一旦关闭浏览器，即 session 结束，session 范围内的属性将全部丢失。

session 对象是 HttpSession 的实例，HttpSession 有如下两个常用的方法：

• setAttribute(String attName, Object attValue)：设置 session 范围内 attName 属性的值为 attValue
• getAttribute(String attName)：返回 session 范围内 attName 属性的值

10. JSP 中的四大域对象

在 JSP 九大内置类中存在四大域对象，分别是：

• page 域：pageContext 对象
• request 域：request 对象
• session 域：session 对象
• application 域：application 对象

域对象主要是用于 JSP 和 Servlet 的数据共享。