JavaServer Pages^TM 基础 - 短期教程

by

关于本短期教程 | 练习

课程概要

• 介绍
• JSP 优点
• JSP 与 ASP 比较
• JSP 还是 servlet？
• JSP 体系结构
• JSP 访问模型
• JSP 语法基础
• 指令
  • Page 指令
  • Include 指令
• 声明
• 表达式
• 脚本小程序
• 注释
• 对象范围
• JSP 隐式对象
• 同步问题
• 异常处理
• 会话管理
• 标准操作
• 使用 JavaBean 组件
• 转发请求
• 请求链
• 包含请求

• Web 站点
• 文档和规范
• 佳文刊/A>

介绍

虽然有多种技术可用于生成为动态内容提供服务的 web 应用程序，但真正受 到开发界青睐的是 JavaServer Pages^TM (JSP^TM)。这并非没有充分的理由。JSP 不仅 拥有跨平台和跨 Web 服务器支持，并且将服务器端 Java 技术的功能与静态 HTML 页的“所见即所得”功能有效地结合了起来。

典型的JSP 页由以下几部分组成:

• 静态 HTML/XML 组件。
• 专用 JSP 标记
• 可选）用 Java 编程语言编写的代码片断，称为“脚本小程序”。

因此，您可以用常规的 HTML/XML 工具创建和维护 JSP 页。

有必要指出：JSP 规范是在 Servlet API 上定义的标准扩展。因此，您可以 利用所有与 servlet 相关的经验。

JSP 和 servlet 技术之间区别很大。servlet 是一种编程技术，对开发人员 的专门知识技能要求很高；而 JSP 与 servlet 不同，它适合更广泛的使用者。 不仅开发人员可以使用它，页面设计人员也可以使用它，从而使其在开发周期中 扮演更为直接的角色。

JSP 的另一个优点是演示与使用 JSP 技术的内容的分离，这归功于 JSP 对可 重用组件技术（例如 JavaBeans^TM 组件体系 结构和企业级 JavaBeans^TM 技术）的依赖。 本教程向您深入介绍这种多能的技术，并使用 Apache 集团的 Tomcat JSP 1.1 Reference Implementation 来运行示例程序。

JSP 优点

静态内容和动态内容的分离: 对于 servlet，动态内容的生成逻辑是 servlet 本身的固有部分，与负责用户界面的静态演示模板紧密关联。因此，即 使对 UI 所作的微小更改，通常也会导致重新编译 servlet。演示与内容的这种 紧密结合使得应用程序脆弱而不灵活。但是，对于 JSP，通过将生成动态内容的 逻辑封装到外部 JavaBeans 组件中，可使该逻辑与静态演示模板保持着分离。从 而使用特殊标记和脚本小程序的 JSP 页创建并使用这些组件。当页面设计人员对 演示模板作任何更改时，JSP 引擎便会自动重新编译 JSP 页，并将其重新加载 到 web 服务器中。

一次编写，随处运行: JSP 技术将“一次编写，随处运行”的范例推 广到了交互网页中。不需要作任何更改，就可以很轻松地跨平台和跨 Web 服务器 移动 JSP 页。

可以用多种格式为动态内容提供服务: 没有任何机制使 JSP 页中的静 态模板采用特定的格式。因此，JSP 可以为不同的客户端（包括使用 HTML/DHTML 的常规浏览器、使用 WML 的移动电话和 PDA 等手持式无线设备和使用 XML 的其 他 B2B 应用程序）提供服务。

推荐的用于 n 层体系结构的 Web 访问层: Sun 的 J2EE^TM,蓝图为使用企业级 Java API 开发大规模的应用程序提供了一些准则，它明确推荐使用 JSP（而不要使用 servlet）为动态内容提供服务。

完全利用 Servlet API: 如果您是 servlet 开发人员，若要转到 JSP，所掌握的知识技能几乎没有什么必须摈弃的。事实上，servlet 开发人员有 明显的优势，因为 JSP 只是对 servlet 的高级提炼。使用 JSP，您几乎可以做 任何使用 servlet 可以做的事情，并且更加容易！

JSP 与 ASP 比较

尽管 JSP 提供的功能看起来与 Microsoft 的 Active Server Page (ASP) 的 功能相似，但这两种技术有根本的区别，如下表所示：

JSP 还是 servlet？

servlet 和 JSP 页确实有许多相同之处，并且都可以用来为动态 Web 内容提 供服务。对于何时选择其中的一种技术而不选择另一种技术，这自然会带来一些 混淆。所幸的是，Sun 的 J2EE 蓝图对此提供了一些准则。

根据该蓝图，严格地将 servlet 用作 Web 服务器扩展技术。这可包括提供认 证、数据库验证等服务的专用控件器组件的实现。注意，有趣的是，通常所说的 “JSP 引擎”本身是一个在 servlet 引擎控制下运行的专用 servlet。由于 JSP 仅处理文本数据，因而您在与 Java applet和应用程序进行通信时必须继续 使用 servlet。

使用 JSP 开发典型的依赖动态内容的 Web 应用程序。还应当使用 JSP 来代 替服务器端包含文件之类的专有 Web 服务器扩展，因为 JSP 具有优异的处理重 复内容的功能。

练习

1. 安装和配置 Tomcat

JSP 体系结构

JSP 的用途是提供声明的、以演示为中心的开发 servlet 的方法。正如前面 所指出的那样，JSP 规范本身被定义为 Servlet API 上的标准扩展。因此，在实 质上，servlet 和 JSP 页有许多相同之处，这并不会令人感到十分奇怪。

通常，JSP 页具有翻译阶段和请求处理阶段。除非 JSP 页更改（在这种情况 下翻译阶段会重复），否则翻译阶段仅执行一次。假定页面中没有语法错误，翻 译结果是一个 JSP 页实现类文件，该文件实现 Servlet 接口，如下所示。

当 JSP 引擎首次收到传入的对 JSP 页的请求时，JSP 引擎本身通常会执行翻 译阶段。注意，JSP 1.1 规范还允许将 JSP 页预编译到类文件中。对于移除当以 源代码形式传递的 JSP 页从客户端接收到第一个请求时发生的启动日志，预编译 尤其有用。翻译阶段的许多细节（如源文件和类文件的存储位置）都依赖实现。 Tomcat 为此 JSP 页示例（展示在上图中）生成的类文件的源代码如下：

package jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.Vector;
import org.apache.jasper.runtime.*;
import java.beans.*;
import org.apache.jasper.JasperException;
import java.text.*;
import  java.util.*;

public class _0005cjsp_0005cjsptest_0002ejspjsptest_jsp_0 
	extends HttpJspBase {

 static {
 }
 public _0005cjsp_0005cjsptest_0002ejspjsptest_jsp_0( ) {
 }

 private static boolean _jspx_inited = false;
 public final void _jspx_init() throws JasperException {
 }

 public void _jspService(HttpServletRequest request, 
   HttpServletResponse  response) 
     throws IOException, ServletException {

     JspFactory _jspxFactory = null;
     PageContext pageContext = null;
     HttpSession session = null;
     ServletContext application = null;
     ServletConfig config = null;
     JspWriter out = null;
     Object page = this;
     String  _value = null;
     try {
          if (_jspx_inited == false) {
             _jspx_init();
             _jspx_inited = true;
         }
         _jspxFactory = JspFactory.getDefaultFactory();
         response.setContentType("text/html");
         pageContext = _jspxFactory.getPageContext(this, 
       		request,response, "", true, 8192, true);

         application = pageContext.getServletContext();
         config = pageContext.getServletConfig();
         session = pageContext.getSession();
         out = pageContext.getOut();
         // begin
         out.write("\r\n<html>\r\n<body>\r\n");
        // end
        // begin [file="E:\\jsp\\jsptest.jsp";from=(3,2);to=(5,0)]
        Date d = new Date();
        String today =  DateFormat.getDateInstance().format(d);
        // end
        // begin
        out.write("\r\nToday is: \r\n<em> ");
        // end
        // begin [file="E:\\jsp\\jsptest.jsp";from=(7,8);to=(7,13)]
        out.print(today);</b>
        // end
        // begin
        out.write(" </em>\r\n</body>\r\n</html>\r\n");
        // end
    } catch (Exception ex) {
       if (out.getBufferSize() != 0)
       out.clear();
       pageContext.handlePageException(ex);
    } finally {
       out.flush();
       _jspxFactory.releasePageContext(pageContext);
    }
  }
}

JSP 页实现类文件扩展 HttpJspBase，HttpJspBase 转而实现 Servlet 接口。观察此类的服务方法 _jspService() 如何在实质上内嵌了 JSP 页的内容。尽管无法忽略 _jspService()， 但开发人员可通过在他们的 JSP 页中提供jspInit() 和 jspDestroy() 两个方法的实现来描述初始化事件和毁坏事件。

一旦在 servlet 容件中加载此类文件后，_jspService() 方法 便会负责回复客户端的请求。默认情况下，在处理并发客户端请求时，servlet 容件会在一个单独的线程上分派 _jspService() 方法，如下所示：

JSP 访问模型

早期的 JSP 规范提出了两种应用 JSP 技术的理论方法，通常称为 Model 1 和 Model 2 体系结构。这两种方法主要在请求处理主体的执行位置上有区别，它 们为使用 JSP 技术生成应用程序提供了一个有用的范例。

试考虑 Model 1 体系结构，如下所示：

在 Model 1 体系结构中，从 Web 浏览器传入的请求直接发送到 JSP 页，该 页负责处理请求及回复客户端。演示与内容仍然分离，因为所有数据访问都是通 过使用 bean 执行的。

尽管 Model 1 体系结构适合简单应用程序，但可能不适合复杂的实现。不加 选择地使用这种体系结构通常会使大量脚本小程序或 Java 代码嵌入到 JSP 页中， 尤其在有大量请求处理需要执行时更是如此。虽然这对 Java 开发人员似乎不是 一个大问题，但如果您的 JSP 页由设计人员创建并维护（大型项目通常如此）， 这肯定是一个问题。这种体系结构的另一个缺陷是，每个 JSP 页必须单独负责管 理应用程序状态和验证认证与安全性。

上面展示的 Model 2 体系结构是常见的“模型/视图/控制器”设计模式的服 务器端实现。这里将处理在演示和前端组件之间作了划分。演示组件是生成 HTML/XML 响应的 JSP 页，负责在浏览器呈现用户界面时确定用户界面。前端组 件（又称控制器）不处理任何演示问题，而处理所有的 HTTP 请求。这里，它们 负责创建演示组件使用的任何 bean 或对象，并根据用户的操作确定向哪个演示 组件转发请求。可以将前端组件作为 servlet 或 JSP 页来实现。

这种体系结构的优点是，演示组件本身没有处理逻辑；它只负责检索由控制器 以前创建的任何对象或 bean，并负责提取用于插入到其静态模板中的动态内容。 这样，演示与内容的清晰分离，使编程组中的开发人员和页面设计人员的角色和 责任得以清晰描绘。此方法的另一好处是，前端组件提供了单个进入应用程序的 入口点，从而使应用程序状态、安全性和演示既统一而又易于维护。

JSP 语法基础

JSP 语法相当简单，可以分为指令、脚本元素和标准操作。

指令

JSP 指令就是向 JSP 引擎发出的消息。它们不会直接产生任何可见的输出， 但会告诉引擎如何处理 JSP 页的其他部分。JSP 指令总是被放在 <%@ ... %> 标记中。两种主要的指令是 page 和 include。（注 意，JSP 1.1 还提供 taglib 指令，该指令可用于处理自定义标记 库，不过这里不讨论它。）

Page 指令

通常，几乎在所有 JSP 页顶部都可找到 page 指令。一个 JSP 页内可以有任意数量的 page 指令，不过属性/值对必须唯一。未被 识别的属性或值会导致翻译错误。例如，

<%@ page import="java.util.*, com.foo.*" buffer="16k" %>

上面的代码将为脚本撰写提供包含的包中声明的类型，并将页面缓冲区设置 为 16K。

Include 指令

include 指令让您将内容分成更容易管理的元素，例如那些用 于包含公共页眉或页脚的元素。包含的页面可以是一个静态 HTML 页或更多的 JSP 内容。例如：

<%@ include file="copyright.html" %>

上面的指令可用于在 JSP 页中任意位置，它包含指示的文件的内容。

声明

JSP 声明让您定义页面级别的变量以保存信息，或定义 JSP 页的其他部分可能 需要的支持方法。虽然盲目地让您的 JSP 页中有很多代码是一件轻松的事情，但 这样做最终会使维护成为一场噩梦。为此，同时也是为了增强可重用性，最好将逻辑密集的处理封装为 JavaBean 组件。

声明见于 <%! ... %> 标记中。应始终以分号结束变量 声明，因为任何内容都必须是有效的 Java 语句：

<%! int i=0; %>

您还可以声明方法。例如，通过声明以下内容可以忽略 JSP 生存期中的初始 化事件：

<%! public void jspInit() {
	//some initialization code 
    }
%>

表达式

利用 JSP 中的表达式，表达式求值的结果将转换为一个字符串，并会直接包 含到输出页中。通常，表达式用于通过调用 bean 的获取器方法显示简单变量值 或返回值。JSP 表达式在 <%= ... %> 标记内开始，且不包 含分号：/P>

 <%= fooVariable %>
 <%= fooBean.getName() %>

脚本小程序

JSP 代码片断或脚本小程序嵌入在 <% ... %> 标记中。 当 JSP 页为请求提供服务时，就会运行此 Java 代码。脚本小程序内可以有任意 有效 Java 代码，而不限于有一行源代码。例如，通过联合使用表达式和脚本小 程序，下面的代码会在 H1、H2、H3 和 H4 标记内显示字符串“Hello”：

<% for (int i=1; i<=4; i++) { %>
    <H<%=i%>>Hello</H<%=i%>>
<% } %>

注释

您总可以在 JSP 页中包含 HTML 注释，用户在查看页的源代码时可查看这些 注释。但如果您不想让用户能够查看您的注释，请将注释嵌入到 <%-- ... --%> 标记中：

<%-- comment for server side only --%>

JSP 注释的最有用功能是，可以使用注释来有选择地禁止编译某些脚本小程序 或标记。这样，注释可以在调试和测试过程中发挥重要作用。

对象范围

在讲述 JSP 语法和语义之前，理解正在处理请求的 JSP 页中 Java 对象的范 围或可见性很重要。可以隐式地使用 JSP 指令、显式地通过操作或直接使用脚本 代码（这种情况较少）来创建对象。可以将实例化的对象与一个范围属性相关联， 该范围属性定义何处有对该对象的引用以及何时移除该引用。下图指出了可以与 新创建的对象关联的各种范围：

<%@ page isThreadSafe="false" %>

<%
synchronized (application) {
   SharedObject foo = (SharedObject)
	application.getAttribute("sharedObject");
   foo.update(someValue);
   application.setAttribute("sharedObject",foo);
}
%>

<%@ page isErrorPage="false" errorPage="errorHandler.jsp" %>

<%@ page isErrorPage="true" %>

<% 
Foo foo = new Foo();
session.putValue("foo",foo);
%>

<%
Foo myFoo = (Foo) session.getValue("foo");
%>

<%@ page session="false" %>

<jsp:useBean id="user" class="com.jguru.Person" 
 scope="session" />

<jsp:useBean id="user" class="com.jguru.Person" 
   scope="session">
<%
  user.setDate(DateFormat.getDateInstance(
                       ).format(new Date()));
  //etc..
%>
</jsp:useBean>

<jsp:getProperty name="user" property="name" />

<jsp:setProperty name="user" property="name" 
  value="jGuru" />

<jsp:setProperty name="user" property="name" 
  value="<%=expression %>" />

<jsp:setProperty name="user" property="*"/>

<jsp:setProperty name="user" property="address" 
  param="parameterName" />

<jsp:forward page="somePage.jsp" />

<jsp:forward page="<%= somePage %>" >
<jsp:param name="name1" value="value1" />
<jsp:param name="name2" value="value2" />
</jsp:forward>

<jsp:useBean id="fBean" class="govi.FormBean" 
  scope="request"/>
<jsp:setProperty name="fBean" property="*" />
<jsp:forward page="/servlet/JSP2Servlet" />

public void doPost (HttpServletRequest request,  
                    HttpServletResponse response) {
  try {
    FormBean f = (FormBean) request.getAttribute 
                                        ("fBean"); 
    f.setName("Mogambo"); 
    // do whatever else necessary
    getServletConfig().getServletContext().
      getRequestDispatcher("/jsp/Bean2.jsp").
        forward(request, response);
  } catch (Exception ex) {
    . . .
  }
}

<html>
<body>
<jsp:useBean id="fBean" class="govi.FormBean" 
   scope="request"/>
<jsp:getProperty name="fBean" property="name" />
</body>
</html>

<jsp:include page="shoppingcart.jsp" flush="true"/>