jsp基础教程

1、配置

初学者问的诸如：《怎样配置环境变量》《怎样运行Servlet》啊？这样的问题太多了，现在我写一个初学者入门必读，以便对初学者有指导作用！

　　首先是下载工具：

　　我建议初学者用Editplus＋JDK，我觉得如果用例如JB，Eclipse，JCreator，虽然刚开始的时候比较方便，但是确使初学者门不知道怎样配置环境变量，从而难以达到知其然，知其所以然的地步。

　　可以通过如下地址下载：

Editplus(最新版本是v2.11)：http://count.skycn.com/softdown.php?id=3641&url=http://sc-http.skycn.net/down/epp211a_cn.exe(要照注册码就自己找吧，网上很多的）
JDK(最新版本是Java2sdk1_4_2)：http://count.skycn.com/softdown.php?id=3116&url=http://sc-http.skycn.net/down/j2sdk-1_4_2-windows-i586.exe（这是For Windows）

　　然后就是安装JDK，我是把它装到从c:\JDK目录下面。

　　然后设置CLASSPATH的问题了：

　　正如操作系统利用PATH来搜索可执行程序一样，Java运行环境也会遍历CLASSPATH来查找类，即便是HelloWorld这样简单的程序，JVM也会遍历CLASSPATH定义的每一个路径，直到找到相应的文件为止。

　　相信大家用的系统不是2k就是XP，然后就应当如下设置Path：

　　我的电脑-＞属性-＞高级-＞环境变量

　　然后在环境变量的Path后面追加: C:\JDK\bin;.;C:\JDK\lib

　　也可以这样配置:C:\JDK\bin;.;C:\JDK\lib\dt.jar;C:\JDK\lib\tools.jar

　　★记住:环境变量中的 . 切记不能少，它表示当前路径，如果少掉出现的错误等会就说！

　　dt.jar是关于运行环境的类库，tools.jar是关于一些工具的类库

　　如果没有配置:C:\JDK\bin，则会出现 “ javac' 不是内部或外部命令，也不是可运行的程序或批处理文件。”这样的错误。

　　下面我们就写一个示例程序：

　　打开Editplus，新建一个Java文件，请照着如下输入，要一字不漏，并且分清大小写：

public class HelloWorld{
public static void main(String[] args){
System.out.println("Hello,World!");
}
}

　　然后把这个文件保存(ctrl + s)到HelloWorld.java,Java是分大小写的，所以大小写一定要分清，是HelloWorld.java不是helloworld.java或者其他。

　　运行：开始-＞运行-＞cmd

　　在控制台中把目录切换到当前目录：

javac HelloWorld.java
java HelloWorld

　　你就会在控制台上看见输出的Hello,World!

　　javac是编译命令，它把HelloWorld.java编译成HelloWorld.class

　　java就是解释命令，JVM把HelloWorld.class解释执行.

　　在这个时候：

　　1、如果出现Exception in thread "main" java.lang.NoClassDefFoundError: HelloWorld
那就是你在环境变量中没有加上那个.(dot)

　　2、如果出现Exception in thread "main" java.lang.NoSuchMethodError: main
或者HelloWorld.java:1: Public class helloworld must be defined in a file called

"HelloWorld.java".

　　那就是你没有分清大小写的写入这个HelloWorld，或者保存得时候没有保存为HelloWorld.java。这个名字一定要跟public class的名字一样

　　对于环境变量的问题就说到这里，下面我先所说怎么在Editplus里面编译和运行，在Tools－＞参数设置-＞配置用户工具

　　1.添加工具（添加应用程序）

　　菜单文字：Compile Java Program

　　程序：C:\JDK\bin\javac.exe

　　参数：文件名称

　　初始目录：文件目录

　　2.添加工具（添加应用程序）

　　菜单文字：Run Java Program

　　程序：C:\JDK\bin\java.exe

　　参数：文件名称（不含扩展名）

　　初始目录：文件目录

　　工具组名称可以随便添，比如Debug Java Program。

　　然后在Tools的下拉菜单中，你就会看见Compile Java Program以及Run Java Program这两个选项，以后你就可以利用ctrl + 1编译和ctrl ＋2运行程序了

　　下面我们讨论Servlet的运行环境：

　　要运行Servlet，则需要JSP/Servlet container，我建议初学者用Tomcat。

Tomcat（最新版本5.0）：http://cvs.apache.org/builds/jakarta-tomcat-5/nightly/jakarta-tomcat-5-bin-20030725.zip

　　然后把这个压缩包解压到：

　　C:\Tomcat

　　然后再配置环境变量；添加三个系统变量：

JAVA_HOME: C:\JDK
TOMCAT_HOME: C:\Tomcat
CLASSPATH: %JAVA_HOME%\lib;%TOMCAT_HOME%\lib

　　Tomcat的环境变量就配置完毕了，下面检验Tomcat是否能够运行：

　　在控制台中转到C:\Tomcat\bin这个目录，运行startup，然后回出现一个窗口，连跳一大串东西，最后表示Server已经运行。

　　在浏览器中输入http://localhost:8080，出现欢迎界面，则表示Tomcat没问题了。然后和上面一样，写入你的第一个Servlet。

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet
{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException
{

response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("＜html＞＜head＞＜title＞");
out.println("This is my first Servlet");
out.println("＜/title＞＜/head＞＜body＞");
out.println("＜h1＞Hello,World!＜/h1＞");
out.println("＜/body＞＜/html＞");

}
}

　　然后照样用javac HelloWorld.java来编译这个文件，如果出现无法import javax.servlet.*

　　那么就是应该把C:\Tomcat\common\lib里面的servlet.jar文件拷贝到C:\JDK\jre\lib\ext中，再次编译，就没有问题了！

　　然后在Tomcat目录里面的C:\Tomcat\webapps\ROOT里面按如下的文件结构：

ROOT\index.html
ROOT\welcom.jsp
ROOT\WEB-INF\lib\MyServlet.jar（如果你的servlet的.class打成了.jar文件，则放在lib下面)
ROOT\WEB-INF\classes\HelloWorld.class(把上面生成的HelloWorld.class文件放在这个里面)

　　然后在浏览器中输入http://localhost:8080/servlet/HelloWorld,于是Server众望所归的报错了:Error 404--Not Found

　　怎么回事呢？

　　Servlet必须使用C:\Tomcat\webapps\ROOT\WEB-INF这个目录下面的web.xml文件进行注册，用EP打开这个web.xml文件，在里面加入：

＜servlet＞
＜servlet-name＞HelloWorld＜/servlet-name＞
＜servlet-class＞HelloWorld＜/servlet-class＞
＜/servlet＞
＜servlet-mapping＞
＜servlet-name＞HelloWorld＜/servlet-name＞
＜url-pattern＞/servlet/helloworld＜/url-pattern＞
＜/servlet-mapping＞ 

　　这样的结构

＜servlet＞
＜servlet-name＞HelloWorld＜/servlet-name＞
＜servlet-class＞HelloWorld＜/servlet-class＞
＜/servlet＞

　　表示指定包含的servlet类。而以下的结构：

＜servlet-mapping＞
＜servlet-name＞HelloWorld＜/servlet-name＞
＜url-pattern＞/servlet/HelloWorld＜/url-pattern＞
＜/servlet-mapping＞

　　 表示指定HelloServlet应当映射到哪一种URL模式。

　　在修改web.xml完毕过后，重新启动Server，然后再输入http://localhost:8080/servlet/HelloWorld，那么偌大一个Hello,World!等着你呢。

Java Servlet和JSP教程[转载]

　　 1 概述 

　　 1.1 Java Servlet及其特点 

　　 Servlet是Java技术对CGI编程的回答。Servlet程序在服务器端运行，动态地生成Web页面。与传统的CGI和许多其他类似CGI的技术相比，Java Servlet具有更高的效率，更容易使用，功能更强大，具有更好的可移植性，更节省投资（更重要的是， Servlet程序员收入要比Perl程序员高:-）： 

　　高效 

　　在传统的CGI中，每个请求都要启动一个新的进程，如果CGI程序本身的执行时间较短，启动进程所需要的开销很可能反而超过实际执行时间。而在Servlet中，每个请求由一个轻量级的Java线程处理（而不是重量级的操作系统进程）。 

　　在传统CGI中，如果有N个并发的对同一CGI程序的请求，则该CGI程序的代码在内存中重复装载了N次；而对于Servlet，处理请求的是N个线程，只需要一份Servlet类代码。在性能优化方面，Servlet也比CGI有着更多的选择，比如缓冲以前的计算结果，保持数据库连接的活动，等等。 

　　方便 

　　Servlet提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等。 

　　功能强大 

　　在Servlet中，许多使用传统CGI程序很难完成的任务都可以轻松地完成。例如，Servlet能够直接和Web服务器交互，而普通的CGI程序不能。Servlet还能够在各个程序之间共享数据，使得数据库连接池之类的功能很容易实现。 

　　可移植性好 

　　Servlet用Java编写，Servlet API具有完善的标准。因此，为I-Planet Enterprise Server写的Servlet无需任何实质上的改动即可移植到Apache、Microsoft IIS或者WebStar?负跛械闹髁鞣务器都直接或通过插件支持Servlet。 

　　节省投资 

　　不仅有许多廉价甚至免费的Web服务器可供个人或小规模网站使用，而且对于现有的服务器，如果它不支持Servlet的话，要加上这部分功能也往往是免费的（或只需要极少的投资）。 

　　 1.2 JSP及其特点 

　　 JavaServer Pages（JSP）是一种实现普通静态HTML和动态HTML混合编码的技术，有关JSP基础概念的说明请参见《JSP技术简介》。 

　　许多由CGI程序生成的页面大部分仍旧是静态HTML，动态内容只在页面中有限的几个部分出现。但是包括Servlet在内的大多数CGI技术及其变种，总是通过程序生成整个页面。JSP使得我们可以分别创建这两个部分。例如，下面就是一个简单的JSP页面： 

 
 
 
 

欢迎

 
欢迎, 
 
<% out.println(Utils.getUserNameFromCookie(request)); %> 
要设置帐号信息，请点击 
这里 

 
页面的其余内容... 
 

　　下面是JSP和其他类似或相关技术的一个简单比较： 

　　JSP和Active Server Pages（ASP）相比 

　　Microsoft的ASP是一种和JSP类似的技术。JSP和ASP相比具有两方面的优点。首先，动态部分用Java编写，而不是VB Script或其他Microsoft语言，不仅功能更强大而且更易于使用。第二，JSP应用可以移植到其他操作系统和非Microsoft的Web服务器上。 

　　JSP和纯Servlet相比 

　　JSP并没有增加任何本质上不能用Servlet实现的功能。但是，在JSP中编写静态HTML更加方便，不必再用 println语句来输出每一行HTML代码。更重要的是，借助内容和外观的分离，页面制作中不同性质的任务可以方便地分开：比如，由页面设计专家进行HTML设计，同时留出供Servlet程序员插入动态内容的空间。 

　　JSP和服务器端包含（Server-Side Include，SSI）相比 

　　SSI是一种受到广泛支持的在静态HTML中引入外部代码的技术。JSP在这方面的支持更为完善，因为它可以用Servlet而不是独立的程序来生成动态内容。另外，SSI实际上只用于简单的包含，而不是面向那些能够处理表单数据、访问数据库的“真正的”程序。 

　　JSP和JavaScript相比 

　　JavaScript能够在客户端动态地生成HTML。虽然JavaScript很有用，但它只能处理以客户端环境为基础的动态信息。除了Cookie之外，HTTP状态和表单提交数据对JavaScript来说都是不可用的。另外，由于是在客户端运行，JavaScript不能访问服务器端资源，比如数据库、目录信息等等。 

2 安装 

　　2.1 安装Servlet和JSP开发工具 

　　要学习Servlet和JSP开发，首先你必须准备一个符合Java Servlet 2.1/2.2和JavaServer Pages1.0/1.1规范的开发环境。Sun提供免费的JavaServer Web Development Kit（JSWDK），可以从 http://java.sun.com/products/servlet/下载。 

　　安装好JSWDK之后，你还要告诉javac，在编译文件的时候到哪里去寻找Servlet和JSP类。JSWDK安装指南对此有详细说明，但主要就是把servlet.jar和jsp.jar加入CLASSPATH。CLASSPATH是一个指示Java如何寻找类文件的环境变量，如果不设置CLASSPATH，Java在当前目录和标准系统库中寻找类；如果你自己设置了CLASSPATH，不要忘记包含当前目录（即在CLASSPATH中包含“.”）。 

　　另外，为了避免和其他开发者安装到同一Web服务器上的Servlet产生命名冲突，最好把自己的Servlet放入包里面。此时，把包层次结构中的顶级目录也加入CLASSPATH会带来不少方便。请参见下文具体说明。 

　　2.2 安装支持Servlet的Web服务器 

　　除了开发工具之外，你还要安装一个支持Java Servlet的Web服务器，或者在现有的Web服务器上安装Servlet软件包。如果你使用的是最新的Web服务器或应用服务器，很可能它已经有了所有必需的软件。请查看Web服务器的文档，或访问 http://java.sun.com/products/servlet/industry.html查看支持Servlet的服务器软件清单。 

　　虽然最终运行Servlet的往往是商业级的服务器，但是开始学习的时候，用一个能够在台式机上运行的免费系统进行开发和测试也足够了。下面是几种当前最受欢迎的产品。 

　　Apache Tomcat. 

　　Tomcat是Servlet 2.2和JSP 1.1规范的官方参考实现。Tomcat既可以单独作为小型Servlet、JSP测试服务器，也可以集成到Apache Web服务器。直到2000年早期，Tomcat还是唯一的支持Servlet 2.2和JSP 1.1规范的服务器，但已经有许多其它服务器宣布提供这方面的支持。 

　　Tomcat和Apache一样是免费的。不过，快速、稳定的Apache服务器安装和配置起来有点麻烦，Tomcat也有同样的缺点。和其他商业级Servlet引擎相比，配置Tomcat的工作量显然要多一点?咛迩氩渭鹔ttp://jakarta.apache.org/。 

　　JavaServer Web Development Kit (JSWDK). 

　　JSWDK是Servlet 2.1和JSP 1.0的官方参考实现。把Servlet和JSP应用部署到正式运行它们的服务器之前，JSWDK可以单独作为小型的Servlet、JSP测试服务器。JSWDK也是免费的，而且具有很好的稳定性，但它的安装和配置也较为复杂?咛迩氩渭鹔ttp://java.sun.com/products/servlet/download.html。 

　　Allaire JRun. 

　　JRun是一个Servlet和JSP引擎，它可以集成到Netscape Enterprise或FastTrack Server、IIS、Microsoft Personal Web Server、版本较低的Apache、O'eilly的WebSite或者StarNine Web STAR。最多支持5个并发连接的限制版本是免费的，商业版本中不存在这个限制，而且增加了远程管理控制台之类的功能?咛迩氩渭鹔ttp://www.allaire.com/products/jrun/。 

　　New Atlanta 的ServletExec 

　　ServletExec是一个快速的Servlet和JSP引擎，它可以集成到大多数流行的Web服务器，支持平台包括Solaris、Windows、MacOS、HP-UX和Linux。ServletExec可以免费下载和使用，但许多高级功能和管理工具只有在购买了许可之后才可以使用。New Atlanta还提供一个免费的Servlet调试器，该调试器可以在许多流行的Java IDE下工作?咛迩氩渭鹔ttp://newatlanta.com/。 

　　Gefion的LiteWebServer (LWS) 

　　LWS是一个支持Servlet 2.2和JSP 1.1的免费小型Web服务器。 Gefion还有一个免费的WAICoolRunner插件，利用该插件可以为Netscape FastTrack和Enterprise Server增加Servlet 2.2和JSP 1.1支持?咛迩氩渭鹔ttp://www.gefionsoftware.com/。 

　　Sun的Java Web Server. 

　　该服务器全部用Java写成，而且是首先提供Servlet 2.1和JSP 1.0规范完整支持的Web服务器之一。虽然Sun现在已转向Netscape/I-Planet Server，不再发展Java Web Server，但它仍旧是一个广受欢迎的Servlet、JSP学习平台。要得到免费试用版本，请访问 http://www.sun.com/software/jwebserver/try/。 

3 Servlet 

　　3.1 Servlet基本结构 

　　下面的代码显示了一个简单Servlet的基本结构。该Servlet处理的是GET请求，所谓的GET请求，如果你不熟悉HTTP，可以把它看成是当用户在浏览器地址栏输入URL、点击Web页面中的链接、提交没有指定METHOD的表单时浏览器所发出的请求。Servlet也可以很方便地处理POST请求。POST请求是提交那些指定了METHOD=“POST”的表单时所发出的请求，具体请参见稍后几节的讨论。 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 

public class SomeServlet extends HttpServlet { 
public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 

　// 使用“request”读取和请求有关的信息（比如Cookies） 
　// 和表单数据 

　// 使用“response”指定HTTP应答状态代码和应答头 
　// （比如指定内容类型，设置Cookie） 

　PrintWriter out = response.getWriter(); 
　// 使用 "out"把应答内容发送到浏览器 
　} 
} 

　　如果某个类要成为Servlet，则它应该从HttpServlet 继承，根据数据是通过GET还是POST发送，覆盖doGet、doPost方法之一或全部。doGet和doPost方法都有两个参数，分别为HttpServletRequest 类型和HttpServletResponse 类型。HttpServletRequest提供访问有关请求的信息的方法，例如表单数据、HTTP请求头等等。HttpServletResponse除了提供用于指定HTTP应答状态（200，404等）、应答头（Content-Type，Set-Cookie等）的方法之外，最重要的是它提供了一个用于向客户端发送数据的PrintWriter 。对于简单的Servlet来说，它的大部分工作是通过println语句生成向客户端发送的页面。 

　　注意doGet和doPost抛出两个异常，因此你必须在声明中包含它们。另外，你还必须导入java.io包（要用到PrintWriter等类）、javax.servlet包（要用到HttpServlet等类）以及javax.servlet.http包（要用到HttpServletRequest类和HttpServletResponse类）。 

　　最后，doGet和doPost这两个方法是由service方法调用的，有时你可能需要直接覆盖service方法，比如Servlet要处理GET和POST两种请求时。 

　　3.2 输出纯文本的简单Servlet 

　　下面是一个输出纯文本的简单Servlet。 

　　3.2.1 HelloWorld.java 

package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 

public class HelloWorld extends HttpServlet { 
　　public void doGet(HttpServletRequest request, 
　　HttpServletResponse response) 
　　throws ServletException, IOException { 
　　　PrintWriter out = response.getWriter(); 
　　　out.println("Hello World"); 
　} 
} 

　　3.2.2 Servlet的编译和安装 

　　不同的Web服务器上安装Servlet的具体细节可能不同，请参考Web服务器文档了解更权威的说明?俣ㄊ褂肑ava Web Server（JWS）2.0，则Servlet应该安装到JWS安装目录的servlets子目录下。在本文中，为了避免同一服务器上不同用户的Servlet命名冲突，我们把所有Servlet都放入一个独立的包hall中；如果你和其他人共用一个服务器，而且该服务器没有“虚拟服务器”机制来避免这种命名冲突，那么最好也使用包。把Servlet放入了包hall之后，HelloWorld.java实际上是放在servlets目录的hall子目录下。 

　　大多数其他服务器的配置方法也相似，除了JWS之外，本文的Servlet和JSP示例已经在BEA WebLogic和IBM WebSphere 3.0下经过测试。WebSphere具有优秀的虚拟服务器机制，因此，如果只是为了避免命名冲突的话并非一定要用包。 

　　对于没有使用过包的初学者，下面我们介绍编译包里面的类的两种方法。 

　　一种方法是设置CLASSPATH，使其指向实际存放Servlet的目录的上一级目录（Servlet主目录），然后在该目录中按正常的方式编译。例如，如果Servlet的主目录是C:\JavaWebServer\servlets，包的名字（即主目录下的子目录名字）是hall，在Windows下，编译过程如下： 

DOS> set CLASSPATH=C:\JavaWebServer\servlets;%CLASSPATH% 
DOS> cd C:\JavaWebServer\servlets\hall 
DOS> javac YourServlet.java 

　 第二种编译包里面的Servlet的方法是进入Servlet主目录，执行“javac directory\YourServlet.java”（Windows）或者“javac directory/YourServlet.java”（Unix）。例如，再次假定Servlet主目录是C:\JavaWebServer\servlets，包的名字是hall，在Windows中编译过程如下： 

DOS> cd C:\JavaWebServer\servlets 
DOS> javac hall\YourServlet.java 

　　注意在Windows下，大多数JDK 1.1版本的javac要求目录名字后面加反斜杠(\)。JDK1.2已经改正这个问题，然而由于许多Web服务器仍旧使用JDK 1.1，因此大量的Servlet开发者仍旧在使用JDK 1.1。 

　　最后，Javac还有一个高级选项用于支持源代码和.class文件的分开放置，即你可以用javac的“-d”选项把.class文件安装到Web服务器所要求的目录。 

　　3.2.3 运行Servlet 

　　在Java Web Server下，Servlet应该放到JWS安装目录的servlets子目录下，而调用Servlet的URL是 http://host/servlet/ServletName。注意子目录的名字是servlets（带“s”），而URL使用的是“servlet”。由于HelloWorld Servlet放入包hall，因此调用它的URL应该是 http://host/servlet/hall.HelloWorld。在其他的服务器上，安装和调用Servlet的方法可能略有不同。 

　　大多数Web服务器还允许定义Servlet的别名，因此Servlet也可能用 http://host/any-path/any-file.html形式的URL调用?咛迦绾谓信渲猛耆览涤诜务器类型，请参考服务器文档了解细节? 

　　3.3 输出HTML的Servlet 

　　大多数Servlet都输出HTML，而不象上例一样输出纯文本。要输出HTML还有两个额外的步骤要做：告诉浏览器接下来发送的是HTML；修改println语句构造出合法的HTML页面。 

　　第一步通过设置Content-Type（内容类型）应答头完成。一般地，应答头可以通过HttpServletResponse的setHeader方法设置，但由于设置内容类型是一个很频繁的操作，因此Servlet API提供了一个专用的方法setContentType。注意设置应答头应该在通过PrintWriter发送内容之前进行。下面是一个实例： 

　　HelloWWW.java 

package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 

public class HelloWWW extends HttpServlet { 
　public void doGet(HttpServletRequest request, 
　HttpServletResponse response) 
　throws ServletException, IOException { 
　　response.setContentType("text/html"); 
　　PrintWriter out = response.getWriter(); 
　　out.println(" 　　　　　　　　"Transitional//EN\">\n" + 
　　　　　　　　"\n" + 
　　　　　　　　"\n" + 
　　　　　　　　"\n" + 
　　　　　　　　"

Hello WWW

\n" + 
　　　　　　　　""); 
　　} 
　} 

　　3.4 几个HTML工具函数 

　　通过println语句输出HTML并不方便，根本的解决方法是使用JavaServer Pages（JSP）。然而，对于标准的Servlet来说，由于Web页面中有两个部分（DOCTYPE和HEAD）一般不会改变，因此可以用工具函数来封装生成这些内容的代码。 

　　虽然大多数主流浏览器都会忽略DOCTYPE行，但严格地说HTML规范是要求有DOCTYPE行的，它有助于HTML语法检查器根据所声明的HTML版本检查HTML文档合法性。在许多Web页面中，HEAD部分只包含\n"); 
　} 

　// 其他工具函数的代码在本文后面介绍 
} 

　　HelloWWW2.java 

　　下面是应用了ServletUtilities之后重写HelloWWW类得到的HelloWWW2： 

package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 

public class HelloWWW2 extends HttpServlet { 
public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
　response.setContentType("text/html"); 
　PrintWriter out = response.getWriter(); 
　out.println(ServletUtilities.headWithTitle("Hello WWW") + 
　　　　　"\n" + 
　　　　　"

Hello WWW

\n" + 
　　　　　""); 
　} 
} 

4 表单 

　　 4.1 表单数据概述 

　　 如果你曾经使用过Web搜索引擎，或者浏览过在线书店、股票价格、机票信息，或许会留意到一些古怪的URL，比如“http://host/path?user=Marty+Hall&origin=bwi&dest=lax”。这个URL中位于问号后面的部分，即“user=Marty+Hall&origin=bwi&dest=lax”，就是表单数据，这是将Web页面数据发送给服务器程序的最常用方法。对于GET请求，表单数据附加到URL的问号后面（如上例所示）；对于POST请求，表单数据用一个单独的行发送给服务器。 

　　 以前，从这种形式的数据提取出所需要的表单变量是CGI编程中最麻烦的事情之一。首先，GET请求和POST请求的数据提取方法不同：对于GET请求，通常要通过QUERY_STRING环境变量提取数据；对于POST请求，则一般通过标准输入提取数据。第二，程序员必须负责在“&”符号处截断变量名字-变量值对，再分离出变量名字（等号左边）和变量值（等号右边）。第三，必须对变量值进行URL反编码操作。因为发送数据的时候，字母和数字以原来的形式发送，但空格被转换成加号，其他字符被转换成“%XX”形式，其中XX是十六进制表示的字符ASCII（或者ISO Latin-1）编码值。例如，如果HTML表单中名为“users”的域值为“~hall, ~gates, and ~mcnealy”，则实际向服务器发送的数据为“users=%7Ehall%2C+%7Egates%2C+and+%7Emcnealy”。最后，即第四个导致解析表单数据非常困难的原因在于，变量值既可能被省略（如“param1=val1＆param2=＆param3=val3”），也有可能一个变量拥有一个以上的值，即同一个变量可能出现一次以上（如“param1=val1＆param2=val2＆param1=val3”）。 

　　 Java Servlet的好处之一就在于所有上述解析操作都能够自动完成。只需要简单地调用一下HttpServletRequest的getParameter方法、在调用参数中提供表单变量的名字（大小写敏感）即可，而且GET请求和POST请求的处理方法完全相同。 

　　 getParameter方法的返回值是一个字符串，它是参数中指定的变量名字第一次出现所对应的值经反编码得到得字符串（可以直接使用）。如果指定的表单变量存在，但没有值，getParameter返回空字符串；如果指定的表单变量不存在，则返回null。如果表单变量可能对应多个值，可以用getParameterValues来取代getParameter。getParameterValues能够返回一个字符串数组。 

　　 最后，虽然在实际应用中Servlet很可能只会用到那些已知名字的表单变量，但在调试环境中，获得完整的表单变量名字列表往往是很有用的，利用getParamerterNames方法可以方便地实现这一点。getParamerterNames返回的是一个Enumeration，其中的每一项都可以转换为调用getParameter的字符串。 

　　 4.2 实例：读取三个表单变量 

　　 下面是一个简单的例子，它读取三个表单变量param1、param2和param3，并以HTML列表的形式列出它们的值。请注意，虽然在发送应答内容之前必须指定应答类型（包括内容类型、状态以及其他HTTP头信息），但Servlet对何时读取请求内容却没有什么要求。 

　　 另外，我们也可以很容易地把Servlet做成既能处理GET请求，也能够处理POST请求，这只需要在doPost方法中调用doGet方法，或者覆盖service方法（service方法调用doGet、doPost、doHead等方法）。在实际编程中这是一种标准的方法，因为它只需要很少的额外工作，却能够增加客户端编码的灵活性。 

　　 如果你习惯用传统的CGI方法，通过标准输入读取POST数据，那么在Servlet中也有类似的方法，即在HttpServletRequest上调用getReader或者getInputStream，但这种方法对普通的表单变量来说太麻烦。然而，如果是要上载文件，或者POST数据是通过专门的客户程序而不是HTML表单发送，那么就要用到这种方法。 

　　 注意用第二种方法读取POST数据时，不能再用getParameter来读取这些数据。 

ThreeParams.java 
package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.util.*; 

public class ThreeParams extends HttpServlet { 
public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
response.setContentType("text/html"); 
PrintWriter out = response.getWriter(); 
String title = "读取三个请求参数"; 
out.println(ServletUtilities.headWithTitle(title) + 
"\n" + 
"

" + title + "

\n" + 
"

\n" + 
"
• param1: " 
  + request.getParameter("param1") + "\n" + 
  "
• param2: " 
  + request.getParameter("param2") + "\n" + 
  "
• param3: " 
  + request.getParameter("param3") + "\n" + 
  "

\n" + 
""); 
} 

public void doPost(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
doGet(request, response); 
} 
} 

　 4.3 实例：输出所有的表单数据 

　 下面这个例子寻找表单所发送的所有变量名字，并把它们放入表格中，没有值或者有多个值的变量都突出显示。 

　 首先，程序通过HttpServletRequest的getParameterNames方法得到所有的变量名字，getParameterNames返回的是一个Enumeration。接下来，程序用循环遍历这个Enumeration，通过hasMoreElements确定何时结束循环，利用nextElement得到Enumeration中的各个项。由于nextElement返回的是一个Object，程序把它转换成字符串后再用这个字符串来调用getParameterValues。 

　 getParameterValues返回一个字符串数组，如果这个数组只有一个元素且等于空字符串，说明这个表单变量没有值，Servlet以斜体形式输出“No Value”；如果数组元素个数大于1，说明这个表单变量有多个值，Servlet以HTML列表形式输出这些值；其他情况下Servlet直接把变量值放入表格。 

　 ShowParameters.java 

　 注意，ShowParameters.java用到了前面介绍过的ServletUtilities.java。 
package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.util.*; 

public class ShowParameters extends HttpServlet { 
public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
response.setContentType("text/html"); 
PrintWriter out = response.getWriter(); 
String title = "读取所有请求参数"; 
out.println(ServletUtilities.headWithTitle(title) + 
"\n" + 
"

" + title + "

\n" + 
"\n" + 
"\n" + 
"

参数名字	参数值");  Enumeration paramNames = request.getParameterNames();  while(paramNames.hasMoreElements()) {  String paramName = (String)paramNames.nextElement();  out.println("
" + paramName + "\n	");  String[] paramValues = request.getParameterValues(paramName);  if (paramValues.length == 1) {  String paramValue = paramValues[0];  if (paramValue.length() == 0)  out.print("No Value");  else  out.print(paramValue);  } else {  out.println(" ");  for(int i=0; i out.println(" " + paramValues[i]);  }  out.println(" ");  }  }  out.println("

\n"); 
} 

public void doPost(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
doGet(request, response); 
} 
} 

　 测试表单 

　 下面是向上述Servlet发送数据的表单PostForm.html?拖袼邪苈胧淙胗虻谋淼ヒ谎帽淼ビ肞OST方法发送数据。我们可以看到，在Servlet中同时实现doGet和doPost这两种方法为表单制作带来了方便。 

 
 
 
 
 

 

用POST方法发送数据的表单

 

METHOD="POST"> 
Item Number: 

 
Quantity: 

 
Price Each: 

 

---

 
First Name: 

 
Last Name: 

 
Middle Initial: 

 
Shipping Address: 

 
Credit Card:
 
VALUE="Visa">Visa
 
VALUE="Master Card">Master Card
 
VALUE="Amex">American Express
 
VALUE="Discover">Discover
 
VALUE="Java SmartCard">Java SmartCard
 
Credit Card Number: 

 
Repeat Credit Card Number: 


 
 
 
 

 

 
 

5 HTTP请求头 

　　 5.1 HTTP请求头概述 

　　HTTP客户程序（例如浏览器），向服务器发送请求的时候必须指明请求类型（一般是GET或者POST）。如有必要，客户程序还可以选择发送其他的请求头。大多数请求头并不是必需的，但Content-Length除外。对于POST请求来说Content-Length必须出现。 

　　下面是一些最常见的请求头 

　　　　Accept：浏览器可接受的MIME类型。 

　　　　Accept-Charset：浏览器可接受的字符集。 

　　　　Accept-Encoding：浏览器能够进行解码的数据编码方式，比如gzip。Servlet能够向支持gzip的浏览器返回经gzip编码的HTML页面。许多情形下这可以减少5到10倍的下载时间。 

　　　　Accept-Language：浏览器所希望的语言种类，当服务器能够提供一种以上的语言版本时要用到。 

　　　　Authorization：授权信息，通常出现在对服务器发送的WWW-Authenticate头的应答中。 

　　　　Connection：表示是否需要持久连接。如果Servlet看到这里的值为“Keep-Alive”，或者看到请求使用的是HTTP 1.1（HTTP 1.1默认进行持久连接），它就可以利用持久连接的优点，当页面包含多个元素时（例如Applet，图片），显著地减少下载所需要的时间。要实现这一点，Servlet需要在应答中发送一个Content-Length头，最简单的实现方法是：先把内容写入ByteArrayOutputStream，然后在正式写出内容之前计算它的大小。 

　　　　Content-Length：表示请求消息正文的长度。 

　　　　Cookie：这是最重要的请求头信息之一，参见后面《Cookie处理》一章中的讨论。 

　　　　From：请求发送者的email地址，由一些特殊的Web客户程序使用，浏览器不会用到它。 

　　　　Host：初始URL中的主机和端口。 

　　　　If-Modified-Since：只有当所请求的内容在指定的日期之后又经过修改才返回它，否则返回304“Not Modified”应答。 

　　　　Pragma：指定“no-cache”值表示服务器必须返回一个刷新后的文档，即使它是代理服务器而且已经有了页面的本地拷贝。 

　　　　Referer：包含一个URL，用户从该URL代表的页面出发访问当前请求的页面。 

　　　　User-Agent：浏览器类型，如果Servlet返回的内容与浏览器类型有关则该值非常有用。 

　　　　UA-Pixels，UA-Color，UA-OS，UA-CPU：由某些版本的IE浏览器所发送的非标准的请求头，表示屏幕大小、颜色深度、操作系统和CPU类型。 

　　有关HTTP头完整、详细的说明，请参见 http://www.w3.org/Protocols/的HTTP规范。 

　　5.2 在Servlet中读取请求头 

　　在Servlet中读取HTTP头是非常方便的，只需要调用一下HttpServletRequest的getHeader方法即可。如果客户请求中提供了指定的头信息，getHeader返回对应的字符串；否则，返回null。部分头信息经常要用到，它们有专用的访问方法：getCookies方法返回Cookie头的内容，经解析后存放在Cookie对象的数组中，请参见后面有关Cookie章节的讨论；getAuthType和getRemoteUser方法分别读取Authorization头中的一部分内容；getDateHeader和getIntHeader方法读取指定的头，然后返回日期值或整数值。 

　　除了读取指定的头之外，利用getHeaderNames还可以得到请求中所有头名字的一个Enumeration对象。 

　　最后，除了查看请求头信息之外，我们还可以从请求主命令行获得一些信息。getMethod方法返回请求方法，请求方法通常是GET或者POST，但也有可能是HEAD、PUT或者DELETE。getRequestURI方法返回URI（URI是URL的从主机和端口之后到表单数据之前的那一部分）。getRequestProtocol返回请求命令的第三部分，一般是“HTTP/1.0”或者“HTTP/1.1”。 

　　5.3 实例：输出所有的请求头 

　　下面的Servlet实例把所有接收到的请求头和它的值以表格的形式输出。另外，该Servlet还会输出主请求命令的三个部分：请求方法，URI，协议/版本。 

　　ShowRequestHeaders.java 

package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.util.*; 

public class ShowRequestHeaders extends HttpServlet { 
　public void doGet(HttpServletRequest request, 
　HttpServletResponse response) 
　throws ServletException, IOException { 
　　response.setContentType("text/html"); 
　　PrintWriter out = response.getWriter(); 
　　String title = "显示所有请求头"; 
　　out.println(ServletUtilities.headWithTitle(title) + 
　　　　　　　"\n" + 
　　　　　　　"

" + title + "

\n" + 
　　　　　　　"Request Method: " + 
　　request.getMethod() + "
\n" +"Request URI: " + 
　　request.getRequestURI() + "
\n" +"Request Protocol: " + 
　　request.getProtocol() + "

\n" +"\n" + 
　　　　　　　　　　　　"\n" + 
　　　　　　　　　　　　"

Header Name	Header Value");  　　Enumeration headerNames = request.getHeaderNames();  　　while(headerNames.hasMoreElements()) {  　　　String headerName = (String)headerNames.nextElement();  　　　out.println("
" + headerName);  　　　out.println("	" + request.getHeader(headerName));  　　}  　　out.println("

\n"); 
　} 

　public void doPost(HttpServletRequest request, 
　　HttpServletResponse response) 
　　throws ServletException, IOException { 
　　　doGet(request, response); 
　　} 
　}

6 CGI变量 

　　 6.1 CGI变量概述 

　　如果你是从传统的CGI编程转而学习Java Servlet，或许已经习惯了“CGI变量”这一概念。CGI变量汇集了各种有关请求的信息： 

　　部分来自HTTP请求命令和请求头，例如Content-Length头； 

　　部分来自Socket本身，例如主机的名字和IP地址； 

　　也有部分与服务器安装配置有关，例如URL到实际路径的映射。 

　　6.2 标准CGI变量的Servlet等价表示 

　　下表假定request对象是提供给doGet和doPost方法的HttpServletRequest类型对象。 

CGI变量 含义 从doGet或doPost访问 
AUTH_TYPE 如果提供了Authorization头，这里指定了具体的模式（basic或者digest）。 request.getAuthType() 
CONTENT_LENGTH 只用于POST请求，表示所发送数据的字节数 严格地讲，等价的表达方式应该是String.valueOf(request.getContentLength())（返回一个字符串）。但更?氖怯胷equest.getContentLength()返回含义相同的整数 
CONTENT_TYPE 如果指定的话，表示后面所跟数据的类型。 request.getContentType() 
DOCUMENT_ROOT 与 http://host/对应的路径。 getServletContext().getRealPath("/") 
注意低版本Servlet规范中的等价表达方式是request.getRealPath("/")。 
HTTP_XXX_YYY 访问任意HTTP头。 request.getHeader("Xxx-Yyy") 
PATH_INFO URL中的附加路径信息，即URL中Servlet路径之后、查询字符串之前的那部分。 request.getPathInfo() 
PATH_TRANSLATED 映射到服务器实际路径之后的路径信息。 request.getPathTranslated() 
QUERY_STRING 这是字符串形式的附加到URL后面的查询字符串，数据仍旧是URL编码的。在Servlet中很少需要用到未经解码的数据，一般使用getParameter访问各个参数。 request.getQueryString() 
REMOTE_ADDR 发出请求的客户机的IP地址。 request.getRemoteAddr() 
REMOTE_HOST 发出请求的客户机的完整的域名，如java.sun.com。如果不能确定该域名，则返回IP地址。 request.getRemoteHost() 
REMOTE_USER 如果提供了Authorization头，则代表其用户部分。它代表发出请求的用户的名字。 request.getRemoteUser() 
REQUEST_METHOD 请求类型。通常是GET或者POST。但偶尔也会出现HEAD，PUT， DELETE，OPTIONS，或者 TRACE. request.getMethod() 
SCRIPT_NAME URL中调用Servlet的那一部分，不包含附加路径信息和查询字符串。 request.getServletPath() 
SERVER_NAME Web服务器名字。 request.getServerName() 
SERVER_PORT String.valueOf服务器监听的端口。 严格地说，等价表达应该是返回字符串的(request.getServerPort())。 但经常使用返回整数值的request.getServerPort()。 
SERVER_PROTOCOL 请求命令中的协议名字和版本（即HTTP/1.0或HTTP/1.1） request.getProtocol() 
SERVER_SOFTWARE Servlet引擎的名字和版本。 getServletContext().getServerInfo() 

　　 6.3 实例：读取CGI变量 

　　 下面这个Servlet创建一个表格，显示除了HTTP_XXX_YYY之外的所有CGI变量。HTTP_XXX_YYY是HTTP请求头信息，请参见上一节介绍。 

ShowCGIVariables.java 
package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.util.*; 

public class ShowCGIVariables extends HttpServlet { 
public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
　response.setContentType("text/html"); 
　PrintWriter out = response.getWriter(); 
　String[][] variables = 
　　{ { "AUTH_TYPE", request.getAuthType() }, 
　　{ "CONTENT_LENGTH", String.valueOf(request.getContentLength()) }, 
　　{ "CONTENT_TYPE", request.getContentType() }, 
　　{ "DOCUMENT_ROOT", getServletContext().getRealPath("/") }, 
　　{ "PATH_INFO", request.getPathInfo() }, 
　　{ "PATH_TRANSLATED", request.getPathTranslated() }, 
　　{ "QUERY_STRING", request.getQueryString() }, 
　　{ "REMOTE_ADDR", request.getRemoteAddr() }, 
　　{ "REMOTE_HOST", request.getRemoteHost() }, 
　　{ "REMOTE_USER", request.getRemoteUser() }, 
　　{ "REQUEST_METHOD", request.getMethod() }, 
　　{ "SCRIPT_NAME", request.getServletPath() }, 
　　{ "SERVER_NAME", request.getServerName() }, 
　　{ "SERVER_PORT", String.valueOf(request.getServerPort()) }, 
　　{ "SERVER_PROTOCOL", request.getProtocol() }, 
　　{ "SERVER_SOFTWARE", getServletContext().getServerInfo() } 
}; 
　String title = "显示CGI变量"; 
　out.println(ServletUtilities.headWithTitle(title) +"\n" + 
　　　　　　"

" + title + "

\n" + 
　　　　　　"\n" + 
　　　　　　"\n" + 
　　　　　　"

CGI Variable Name	Value");  　for(int i=0; i 　　　String varName = variables[i][0];  　　　String varValue = variables[i][1];  　　　if (varValue == null)  　　　　varValue = "Not specified";  　　　　out.println("
" + varName + "	" + varValue);  　}  　out.println("

"); 
} 

public void doPost(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
doGet(request, response); 
} 
} 

7 状态代码 

　　 7.1 状态代码概述 

　　Web服务器响应浏览器或其他客户程序的请求时，其应答一般由以下几个部分组成：一个状态行，几个应答头，一个空行，内容文档。下面是一个最简单的应答： 

HTTP/1.1 200 OK 
Content-Type: text/plain 

Hello World 

　　状态行包含HTTP版本、状态代码、与状态代码对应的简短说明信息。在大多数情况下，除了Content-Type之外的所有应答头都是可选的。但Content-Type是必需的，它描述的是后面文档的MIME类型。虽然大多数应答都包含一个文档，但也有一些不包含，例如对HEAD请求的应答永远不会附带文档。有许多状态代码实际上用来标识一次失败的请求，这些应答也不包含文档（或只包含一个简短的错误信息说明）。 

　　Servlet可以利用状态代码来实现许多功能。例如，可以把用户重定向到另一个网站；可以指示出后面的文档是图片、PDF文件或HTML文件；可以告诉用户必须提供密码才能访问文档；等等。这一部分我们将具体讨论各种状态代码的含义以及利用这些代码可以做些什么。 

　　7.2 设置状态代码 

　　如前所述，HTTP应答状态行包含HTTP版本、状态代码和对应的状态信息。由于状态信息直接和状态代码相关，而HTTP版本又由服务器确定，因此需要Servlet设置的只有一个状态代码。 

　　Servlet设置状态代码一般使用HttpServletResponse的setStatus方法。setStatus方法的参数是一个整数（即状态代码），不过为了使得代码具有更好的可读性，可以用HttpServletResponse中定义的常量来避免直接使用整数。这些常量根据HTTP 1.1中的标准状态信息命名，所有的名字都加上了SC前缀（Status Code的缩写）并大写，同时把空格转换成了下划线。也就是说，与状态代码404对应的状态信息是“Not Found”，则HttpServletResponse中的对应常量名字为SC_NOT_FOUND。但有两个例外：和状态代码302对应的常量根据HTTP 1.0命名，而307没有对应的常量。 

　　设置状态代码并非总是意味着不要再返回文档。例如，虽然大多数服务器返回404应答时会输出简单的“File Not Found”信息，但Servlet也可以定制这个应答。不过，定制应答时应当在通过PrintWriter发送任何内容之前先调用response.setStatus。 

　　虽然设置状态代码一般使用的是response.setStauts(int)方法，但为了简单起见，HttpServletResponse为两种?那樾翁峁┝俗ㄓ梅椒ǎ簊endError方法生成一个404应答，同时生成一个简短的HTML错误信息文档；sendRedirect方法生成一个302应答，同时在Location头中指示新文档的URL。 

　　7.3 HTTP 1.1状态代码及其含义 

　　下表显示了?腍TTP 1.1状态代码以及它们对应的状态信息和含义。 

　　应当谨慎地使用那些只有HTTP 1.1支持的状态代码，因为许多浏览器还只能够支持HTTP 1.0。如果你使用了HTTP 1.1特有的状态代码，最好能够检查一下请求的HTTP版本号（通过HttpServletRequest的getProtocol方法）。 

状态代码 状态信息 含义 
100 Continue 初始的请求已经接受，客户应当继续发送请求的其余部分。（HTTP 1.1新） 
101 Switching Protocols 服务器将遵从客户的请求转换到另外一种协议（HTTP 1.1新） 
200 OK 一切正常，对GET和POST请求的应答文档跟在后面。如果不用setStatus设置状态代码，Servlet默认使用202状态代码。 
201 Created 服务器已经创建了文档，Location头给出了它的URL。 
202 Accepted 已经接受请求，但处理尚未完成。 
203 Non-Authoritative Information 文档已经正常地返回，但一些应答头可能不正确，因为使用的是文档的拷贝（HTTP 1.1新）。 
204 No Content 没有新文档，浏览器应该继续显示原来的文档。如果用户定期地刷新页面，而Servlet可以确定用户文档足够新，这个状态代码是很有用的。 
205 Reset Content 没有新的内容，但浏览器应该重置它所显示的内容。用来强制浏览器清除表单输入内容（HTTP 1.1新）。 
206 Partial Content 客户发送了一个带有Range头的GET请求，服务器完成了它（HTTP 1.1新）。 
300 Multiple Choices 客户请求的文档可以在多个位置找到，这些位置已经在返回的文档内列出。如果服务器要提出优先选择，则应该在Location应答头指明。 
301 Moved Permanently 客户请求的文档在其他地方，新的URL在Location头中给出，浏览器应该自动地访问新的URL。 
302 Found 类似于301，但新的URL应该被视为临时性的替代，而不是永久性的。注意，在HTTP1.0中对应的状态信息是“Moved Temporatily”，而HttpServletResponse中相应的常量是SC_MOVED_TEMPORARILY，而不是SC_FOUND。 
出现该状态代码时，浏览器能够自动访问新的URL，因此它是一个很有用的状态代码。为此，Servlet提供了一个专用的方法，即sendRedirect。使用response.sendRedirect(url)比使用response.setStatus(response.SC_MOVED_TEMPORARILY)和response.setHeader("Location",url)更好。这是因为： 

首先，代码更加简洁。 
第二，使用sendRedirect，Servlet会自动构造一个包含新链接的页面（用于那些不能自动重定向的老式浏览器）。 
最后，sendRedirect能够处理相对URL，自动把它们转换成绝对URL。 
注意这个状态代码有时候可以和301替换使用。例如，如果浏览器错误地请求 http://host/~user（缺少了后面的斜杠），有的服务器返回301，有的则返回302。 

严格地说，我们只能假定只有当原来的请求是GET时浏览器才会自动重定向。请参见307。 
303 See Other 类似于301/302，不同之处在于，如果原来的请求是POST，Location头指定的重定向目标文档应该通过GET提取（HTTP 1.1新）。 
304 Not Modified 客户端有缓冲的文档并发出了一个条件性的请求（一般是提供If-Modified-Since头表示客户只想比指定日期更新的文档）。服务器告诉客户，原来缓冲的文档还可以继续使用。 
305 Use Proxy 客户请求的文档应该通过Location头所指明的代理服务器提取（HTTP 1.1新）。 
307 Temporary Redirect 和302（Found）相同 。许多浏览器会错误地响应302应答进行重定向，即使原来的请求是POST，即使它实际上只能在POST请求的应答是303时才能重定向。由于这个原因，HTTP 1.1新增了307，以便更加清除地区分几个状态代码：当出现303应答时，浏览器可以跟随重定向的GET和POST请求；如果是307应答，则浏览器只能跟随对GET请求的重定向。 注意，HttpServletResponse中没有为该状态代码提供相应的常量。（HTTP 1.1新） 
400 Bad Request 请求出现语法错误。 
401 Unauthorized 客户试图未经授权访问受密码保护的页面。应答中会包含一个WWW-Authenticate头，浏览器据此显示用户名字/密码对话框，然后在填写合适的Authorization头后再次发出请求。 
403 Forbidden 资源不可用。服务器理解客户的请求，但拒绝处理它。通常由于服务器上文件或目录的权限设置导致。 
404 Not Found 无法找到指定位置的资源。这也是一个常用的应答，HttpServletResponse专门提供了相应的方法：sendError(message)。 
405 Method Not Allowed 请求方法（GET、POST、HEAD、DELETE、PUT、TRACE等）对指定的资源不适用。（HTTP 1.1新） 
406 Not Acceptable 指定的资源已经找到，但它的MIME类型和客户在Accpet头中所指定的不兼容（HTTP 1.1新）。 
407 Proxy Authentication Required 类似于401，表示客户必须先经过代理服务器的授权。（HTTP 1.1新） 
408 Request Timeout 在服务器许可的等待时间内，客户一直没有发出任何请求。客户可以在以后重复同一请求。（HTTP 1.1新） 
409 Conflict 通常和PUT请求有关。由于请求和资源的当前状态相冲突，因此请求不能成功。（HTTP 1.1新） 
410 Gone 所请求的文档已经不再可用，而且服务器不知道应该重定向到哪一个地址。它和404的不同在于，返回407表示文档永久地离开了指定的位置，而404表示由于未知的原因文档不可用。（HTTP 1.1新） 
411 Length Required 服务器不能处理请求，除非客户发送一个Content-Length头。（HTTP 1.1新） 
412 Precondition Failed 请求头中指定的一些前提条件失败（HTTP 1.1新）。 
413 Request Entity Too Large 目标文档的大小超过服务器当前愿意处理的大小。如果服务器认为自己能够稍后再处理该请求，则应该提供一个Retry-After头（HTTP 1.1新）。 
414 Request URI Too Long URI太长（HTTP 1.1新）。 
416 Requested Range Not Satisfiable 服务器不能满足客户在请求中指定的Range头。（HTTP 1.1新） 
500 Internal Server Error 服务器遇到了意料不到的情况，不能完成客户的请求。 
501 Not Implemented 服务器不支持实现请求所需要的功能。例如，客户发出了一个服务器不支持的PUT请求。 
502 Bad Gateway 服务器作为网关或者代理时，为了完成请求访问下一个服务器，但该服务器返回了非法的应答。 
503 Service Unavailable 服务器由于维护或者负载过重未能应答。例如，Servlet可能在数据库连接池已满的情况下返回503。服务器返回503时可以提供一个Retry-After头。 
504 Gateway Timeout 由作为代理或网关的服务器使用，表示不能及时地从远程服务器获得应答。（HTTP 1.1新） 
505 HTTP Version Not Supported 服务器不支持请求中所指明的HTTP版本。（HTTP 1.1新） 

　　7.4 实例：访问多个搜索引擎 

　　下面这个例子用到了除200之外的另外两个?刺耄?02和404。302通过sendRedirect方法设置，404通过sendError方法设置。 

　　在这个例子中，首先出现的HTML表单用来选择搜索引擎、搜索字符串、每页显示的搜索结果数量。表单提交后，Servlet提取这三个变量，按照所选择的搜索引擎的要求构造出包含这些变量的URL，然后把用户重定向到这个URL。如果用户不能正确地选择搜索引擎，或者利用其他表单发送了一个不认识的搜索引擎名字，则返回一个提示搜索引擎找不到的404页面。 

　　SearchEngines.java 

　　注意：这个Servlet要用到后面给出的SearchSpec类，SearchSpec的功能是构造适合不同搜索引擎的URL。 

package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.net.*; 

public class SearchEngines extends HttpServlet { 
public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
// getParameter自动解码URL编码的查询字符串。由于我们 
// 要把查询字符串发送给另一个服务器，因此再次使用 
// URLEncoder进行URL编码 
String searchString =URLEncoder.encode(request.getParameter("searchString")); 
String numResults =request.getParameter("numResults"); 
String searchEngine =request.getParameter("searchEngine"); 
SearchSpec[] commonSpecs = SearchSpec.getCommonSpecs(); 
for(int i=0; i 　SearchSpec searchSpec = commonSpecs[i]; 
　if (searchSpec.getName().equals(searchEngine)) { 
　　String url =response.encodeURL(searchSpec.makeURL(searchString,numResults)); 
　　response.sendRedirect(url); 
　return; 
　} 
　} 
　response.sendError(response.SC_NOT_FOUND,"No recognized search engine specified."); 
} 

public void doPost(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
　doGet(request, response); 
} 
} 

　 SearchSpec.java 

package hall; 

class SearchSpec { 
private String name, baseURL, numResultsSuffix; 

private static SearchSpec[] commonSpecs = 
　　{ new SearchSpec("google", 
　　　" http://www.google.com/search?q=";, 
　　　"&num="), 
　　new SearchSpec("infoseek"," http://infoseek.go.com/Titles?qt=";,"&nh="), 
　　new SearchSpec("lycos"," http://lycospro.lycos.com/cgi-bin/pursuit?query=";, 
　　　　　　　　　　"&maxhits="), 
　　new SearchSpec("hotbot"," http://www.hotbot.com/?MT=";,"&DC=") 
　}; 

public SearchSpec(String name,String baseURL,String numResultsSuffix) { 
　this.name = name; 
　this.baseURL = baseURL; 
　this.numResultsSuffix = numResultsSuffix; 
} 

public String makeURL(String searchString, String numResults) { 
　return(baseURL + searchString + numResultsSuffix + numResults); 
} 

public String getName() { 
　return(name); 
} 

public static SearchSpec[] getCommonSpecs() { 
　return(commonSpecs); 
} 
} 

　　SearchEngines.html 

　　下面是调用上述Servlet的HTML表单。 

 
 
 
 
 

 

 
 
搜索关键字: 

 
每页显示几个查询结果: 
VALUE=10 SIZE=3>
 
VALUE="google"> 
Google | 
VALUE="infoseek"> 
Infoseek | 
VALUE="lycos"> 
Lycos | 
VALUE="hotbot"> 
HotBot 

 
 
 

 

 
 

8 HTTP应答头 

　　 8.1 HTTP应答头概述 

　　 Web服务器的HTTP应答一般由以下几项构成：一个状态行，一个或多个应答头，一个空行，内容文档。设置HTTP应答头往往和设置状态行中的状态代码结合起来。例如，有好几个表示“文档位置已经改变”的状态代码都伴随着一个Location头，而401（Unauthorized）状态代码则必须伴随一个WWW-Authenticate头。 

　　 然而，即使在没有设置特殊含义的状态代码时，指定应答头也是很有用的。应答头可以用来完成：设置Cookie，指定修改日期，指示浏览器按照指定的间隔刷新页面，声明文档的长度以便利用持久HTTP连接，……等等许多其他任务。 

　　 设置应答头最常用的方法是HttpServletResponse的setHeader，该方法有两个参数，分别表示应答头的名字和值。和设置状态代码相似，设置应答头应该在发送任何文档内容之前进行。 

　　 setDateHeader方法和setIntHeadr方法专门用来设置包含日期和整数值的应答头，前者避免了把Java时间转换为GMT时间字符串的麻烦，后者则避免了把整数转换为字符串的麻烦。 

　　 HttpServletResponse还提供了许多设置?Υ鹜返募虮惴椒ǎ缦滤荆? 

setContentType：设置Content-Type头。大多数Servlet都要用到这个方法。 
setContentLength：设置Content-Length头。对于支持持久HTTP连接的浏览器来说，这个函数是很有用的。 
addCookie：设置一个Cookie（Servlet API中没有setCookie方法，因为应答往往包含多个Set-Cookie头）。 
另外，如上节介绍，sendRedirect方法设置状态代码302时也会设置Location头。 

　　 有关HTTP头详细和完整的说明，请参见 http://www.w3.org/Protocols/规范。 

应答头 说明 
Allow 服务器支持哪些请求方法（如GET、POST等）。 
Content-Encoding 文档的编码（Encode）方法。只有在解码之后才可以得到Content-Type头指定的内容类型。利用gzip压缩文档能够显著地减少HTML文档的下载时间。Java的GZIPOutputStream可以很方便地进行gzip压缩，但只有Unix上的Netscape和Windows上的IE 4、IE 5才支持它。因此，Servlet应该通过查看Accept-Encoding头（即request.getHeader("Accept-Encoding")）检查浏览器是否支持gzip，为支持gzip的浏览器返回经gzip压缩的HTML页面，为其他浏览器返回普通页面。 
Content-Length 表示内容长度。只有当浏览器使用持久HTTP连接时才需要这个数据。如果你想要利用持久连接的优势，可以把输出文档写入ByteArrayOutputStram，完成后查看其大小，然后把该值放入Content-Length头，最后通过byteArrayStream.writeTo(response.getOutputStream()发送内容。 
Content-Type 表示后面的文档属于什么MIME类型。Servlet默认为text/plain，但通常需要显式地指定为text/html。由于经常要设置Content-Type，因此HttpServletResponse提供了一个专用的方法setContentTyep。 
Date 当前的GMT时间。你可以用setDateHeader来设置这个头以避免转换时间格式的麻烦。 
Expires 应该在什么时候认为文档已经过期，从而不再缓存它？ 
Last-Modified 文档的最后改动时间。客户可以通过If-Modified-Since请求头提供一个日期，该请求将被视为一个条件GET，只有改动时间迟于指定时间的文档才会返回，否则返回一个304（Not Modified）状态。Last-Modified也可用setDateHeader方法来设置。 
Location 表示客户应当到哪里去提取文档。Location通常不是直接设置的，而是通过HttpServletResponse的sendRedirect方法，该方法同时设置状态代码为302。 
Refresh 表示浏览器应该在多少时间之后刷新文档，以秒计。除了刷新当前文档之外，你还可以通过setHeader("Refresh", "5; URL=http://host/path")让浏览器读取指定的页面。注意这种功能通常是通过设置HTML页面HEAD区的实现，这是因为，自动刷新或重定向对于那些不能使用CGI或Servlet的HTML编写者十分重要。但是，对于Servlet来说，直接设置Refresh头更加方便。注意Refresh的意义是“N秒之后刷新本页面或访问指定页面”，而不是“每隔N秒刷新本页面或访问指定页面”。因此，连续刷新要求每次都发送一个Refresh头，而发送204状态代码则可以阻止浏览器继续刷新，不管是使用Refresh头还是。注意Refresh头不属于HTTP 1.1正式规范的一部分，而是一个扩展，但Netscape和IE都支持它。 
Server 服务器名字。Servlet一般不设置这个值，而是由Web服务器自己设置。 
Set-Cookie 设置和页面关联的Cookie。Servlet不应使用response.setHeader("Set-Cookie", ...)，而是应使用HttpServletResponse提供的专用方法addCookie。参见下文有关Cookie设置的讨论。 
WWW-Authenticate 客户应该在Authorization头中提供什么类型的授权信息？在包含401（Unauthorized）状态行的应答中这个头是必需的。例如，response.setHeader("WWW-Authenticate", "BASIC realm=\"executives\"")。注意Servlet一般不进行这方面的处理，而是让Web服务器的专门机制来控制受密码保护页面的访问（例如.htaccess）。 

　　 8.3 实例：内容改变时自动刷新页面 

　　 下面这个Servlet用来计算大素数。因为计算非常大的数字（例如500位）可能要花不少时间，所以Servlet将立即返回已经找到的结果，同时在后台继续计算。后台计算使用一个优先级较低的线程以避免过多地影响Web服务器的性能。如果计算还没有完成，Servlet通过发送Refresh头指示浏览器在几秒之后继续请求新的内容。 

　　 注意，本例除了说明HTTP应答头的用处之外，还显示了Servlet的另外两个很有价值的功能。首先，它表明Servlet能够处理多个并发的连接，每个都有自己的线程。Servlet维护了一份已有素数计算请求的Vector表，通过查找素数个数（素数列表的长度）和数字个数（每个素数的长度）将当前请求和已有请求相匹配，把所有这些请求同步到这个列表上。第二，本例证明，在Servlet中维持请求之间的状态信息是非常容易的。维持状态信息在传统的CGI编程中是一件很麻烦的事情。由于维持了状态信息，浏览器能够在刷新页面时访问到正在进行的计算过程，同时也使得Servlet能够保存一个有关最近请求结果的列表，当一个新的请求指定了和最近请求相同的参数时可以立即返回结果。 

　　 PrimeNumbers.java 

　　 注意，该Servlet要用到前面给出的ServletUtilities.java。另外还要用到：PrimeList.java，用于在后台线程中创建一个素数的Vector；Primes.java，用于随机生成BigInteger类型的大数字，检查它们是否是素数。（此处略去PrimeList.java和Primes.java的代码。） 
package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.util.*; 

public class PrimeNumbers extends HttpServlet { 
private static Vector primeListVector = new Vector(); 
private static int maxPrimeLists = 30; 

public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
int numPrimes = ServletUtilities.getIntParameter(request, "numPrimes", 50); 
int numDigits = ServletUtilities.getIntParameter(request, "numDigits", 120); 
PrimeList primeList = findPrimeList(primeListVector, numPrimes, numDigits); 
if (primeList == null) { 
primeList = new PrimeList(numPrimes, numDigits, true); 
synchronized(primeListVector) { 
if (primeListVector.size() >= maxPrimeLists) 
primeListVector.removeElementAt(0); 
primeListVector.addElement(primeList); 
} 
} 
Vector currentPrimes = primeList.getPrimes(); 
int numCurrentPrimes = currentPrimes.size(); 
int numPrimesRemaining = (numPrimes - numCurrentPrimes); 
boolean isLastResult = (numPrimesRemaining == 0); 
if (!isLastResult) { 
response.setHeader("Refresh", "5"); 
} 
response.setContentType("text/html"); 
PrintWriter out = response.getWriter(); 
String title = "Some " + numDigits + "-Digit Prime Numbers"; 
out.println(ServletUtilities.headWithTitle(title) + 
"\n" + 
"

" + title + "

\n" + 
"

Primes found with " + numDigits + 
" or more digits: " + numCurrentPrimes + ".

"); 
if (isLastResult) 
out.println("Done searching."); 
else 
out.println("Still looking for " + numPrimesRemaining + 
" more..."); 
out.println("

"); 
for(int i=0; i out.println("
1. " + currentPrimes.elementAt(i)); 
   } 
   out.println("

"); 
out.println(""); 
} 

public void doPost(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
doGet(request, response); 
} 

// 检查是否存在同类型请求（已经完成，或者正在计算）。 
// 如存在，则返回现有结果而不是启动新的后台线程。 
private PrimeList findPrimeList(Vector primeListVector, 
int numPrimes, 
int numDigits) { 
synchronized(primeListVector) { 
for(int i=0; i PrimeList primes = (PrimeList)primeListVector.elementAt(i); 
if ((numPrimes == primes.numPrimes()) && 
(numDigits == primes.numDigits())) 
return(primes); 
} 
return(null); 
} 
} 
} 

　　 PrimeNumbers.html 

 
 
 
 
 
 
 

 
要计算几个素数: 

 
每个素数的位数: 

 
 

 
 
 

9 Cookie 

　　 9.1 Cookie概述 

　　 Cookie是服务器发送给浏览器的体积很小的纯文本信息，用户以后访问同一个Web服务器时浏览器会把它们原样发送给服务器。通过让服务器读取它原先保存到客户端的信息，网站能够为浏览者提供一系列的方便，例如在线交易过程中标识用户身份、安全要求不高的场合避免用户重复输入名字和密码、门户网站的主页定制、有针对性地投放广告，等等。 

　　 Cookie的目的就是为用户带来方便，为网站带来增值。虽然有着许多误传，事实上Cookie并不会造成严重的安全威胁。Cookie永远不会以任何方式执行，因此也不会带来病毒或攻击你的系统。另外，由于浏览器一般只允许存放300个Cookie，每个站点最多存放20个Cookie，每个Cookie的大小限制为4 KB，因此Cookie不会塞满你的硬盘，更不会被用作“拒绝服务”攻击手段。 

　　 9.2 Servlet的Cookie API 

　　 要把Cookie发送到客户端，Servlet先要调用new Cookie(name,value)用合适的名字和值创建一个或多个Cookie（2.1节），通过cookie.setXXX设置各种属性（2.2节），通过response.addCookie(cookie)把cookie加入应答头（2.3节）。 

　　 要从客户端读入Cookie，Servlet应该调用request.getCookies()，getCookies()方法返回一个Cookie对象的数组。在大多数情况下，你只需要用循环访问该数组的各个元素寻找指定名字的Cookie，然后对该Cookie调用getValue方法取得与指定名字关联的值，这部分内容将在2.4节讨论。 

　　 9.2.1 创建Cookie 

　　 调用Cookie对象的构造函数可以创建Cookie。Cookie对象的构造函数有两个字符串参数：Cookie名字和Cookie值。名字和值都不能包含空白字符以及下列字符： 
[ ] ( ) = , " / ? @ : ; 

　　 9.2.2 读取和设置Cookie属性 

　　 把Cookie加入待发送的应答头之前，你可以查看或设置Cookie的各种属性。下面摘要介绍这些方法： 

　　　getComment/setComment 
　　　　获取/设置Cookie的注释。 

　　　getDomain/setDomain 
　　　　获取/设置Cookie适用的域。一般地，Cookie只返回给与发送它的服务器名字完全相同的服务器。使用这里的方法可以指示浏览器把Cookie返回给同一域内的其他服务器。注意域必须以点开始（例如.sitename.com），非国家类的域（如.com，.edu，.gov）必须包含两个点，国家类的域（如.com.cn，.edu.uk）必须包含三个点。 

　　　getMaxAge/setMaxAge 
　　　　获取/设置Cookie过期之前的时间，以秒计。如果不设置该值，则Cookie只在当前会话内有效，即在用户关闭浏览器之前有效，而且这些Cookie不会保存到磁盘上。参见下面有关LongLivedCookie的说明。 

　　　getName/setName 
　　　　获取/设置Cookie的名字。本质上，名字和值是我们始终关心的两个部分。由于HttpServletRequest的getCookies方法返回的是一个Cookie对象的数组，因此通常要用循环来访问这个数组查找特定名字，然后用getValue检查它的值。 

　　　getPath/setPath 
　　　　获取/设置Cookie适用的路径。如果不指定路径，Cookie将返回给当前页面所在目录及其子目录下的所有页面。这里的方法可以用来设定一些更一般的条件。例如，someCookie.setPath("/")，此时服务器上的所有页面都可以接收到该Cookie。 

　　　getSecure/setSecure 
　　　　获取/设置一个boolean值，该值表示是否Cookie只能通过加密的连接（即SSL）发送。 

　　　getValue/setValue 
　　　　获取/设置Cookie的值。如前所述，名字和值实际上是我们始终关心的两个方面。不过也有一些例外情况，比如把名字作为逻辑标记（也就是说，如果名字存在，则表示true）。 

　　　getVersion/setVersion 
　　　　获取/设置Cookie所遵从的协议版本。默认版本0（遵从原先的Netscape规范）；版本1遵从RFC 2109 ， 但尚未得到广泛的支持。 

　　 9.2.3 在应答头中设置Cookie 

　　 Cookie可以通过HttpServletResponse的addCookie方法加入到Set-Cookie应答头。下面是一个例子： 

Cookie userCookie = new Cookie("user", "uid1234"); 
response.addCookie(userCookie); 

　　 9.2.4 读取保存到客户端的Cookie 

　　 要把Cookie发送到客户端，先要创建Cookie，然后用addCookie发送一个Set-Cookie HTTP应答头。这些内容已经在上面的2.1节介绍。从客户端读取Cookie时调用的是HttpServletRequest的getCookies方法。该方法返回一个与HTTP请求头中的内容对应的Cookie对象数组。得到这个数组之后，一般是用循环访问其中的各个元素，调用getName检查各个Cookie的名字，直至找到目标Cookie。然后对这个目标Cookie调用getValue，根据获得的结果进行其他处理。 

　　 上述处理过程经常会遇到，为方便计下面我们提供一个getCookieValue方法。只要给出Cookie对象数组、Cookie名字和默认值，getCookieValue方法就会返回匹配指定名字的Cookie值，如果找不到指定Cookie，则返回默认值。 

　　 9.3 几个Cookie工具函数 

　　 下面是几个工具函数。这些函数虽然简单，但是，在和Cookie打交道的时候很有用。 

　　 9.3.1 获取指定名字的Cookie值 

　　 该函数是ServletUtilities.java的一部分。getCookieValue通过循环依次访问Cookie对象数组的各个元素，寻找是否有指定名字的Cookie，如找到，则返回该Cookie的值；否则，返回参数中给出的默认值。getCookieValue能够在一定程度上简化Cookie值的提取。 

public static String getCookieValue(Cookie[] cookies, 
String cookieName, 
String defaultValue) { 
for(int i=0; i Cookie cookie = cookies[i]; 
if (cookieName.equals(cookie.getName())) 
return(cookie.getValue()); 
} 
return(defaultValue); 
} 

　　 9.3.2自动保存的Cookie 

　　 下面是LongLivedCookie类的代码。如果你希望Cookie能够在浏览器退出的时候自动保存下来，则可以用这个LongLivedCookie类来取代标准的Cookie类。 

package hall; 

import javax.servlet.http.*; 

public class LongLivedCookie extends Cookie { 
public static final int SECONDS_PER_YEAR = 60*60*24*365; 
public LongLivedCookie(String name, String value) { 
super(name, value); 
setMaxAge(SECONDS_PER_YEAR); 
} 
} 

　　 9.4.实例：定制的搜索引擎界面 

　　 下面也是一个搜索引擎界面的例子，通过修改前面HTTP状态代码的例子得到。在这个Servlet中，用户界面是动态生成而不是由静态HTML文件提供的。Servlet除了负责读取表单数据并把它们发送给搜索引擎之外，还要把包含表单数据的Cookie发送给客户端。以后客户再次访问同一表单时，这些Cookie的值将用来预先填充表单，使表单自动显示最近使用过的数据。 

　　 SearchEnginesFrontEnd.java 

　　 该Servlet构造一个主要由表单构成的用户界面。第一次显示的时候，它和前面用静态HTML页面提供的界面差不多。然而，用户选择的值将被保存到Cookie（本页面将数据发送到CustomizedSearchEngines Servlet，由后者设置Cookie）。用户以后再访问同一页面时，即使浏览器是退出之后再启动，表单中也会自动填好上一次搜索所填写的内容。 

　　 注意该Servlet用到了ServletUtilities.java，其中getCookieValue前面已经介绍过，headWithTitle用于生成HTML页面的一部分。另外，这里也用到了前面已经说明的LongLiveCookie类，我们用它来创建作废期限很长的Cookie。 

package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.net.*; 

public class SearchEnginesFrontEnd extends HttpServlet { 
public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
Cookie[] cookies = request.getCookies(); 
String searchString = 
ServletUtilities.getCookieValue(cookies, 
"searchString", 
"Java Programming"); 
String numResults = 
ServletUtilities.getCookieValue(cookies, 
"numResults", 
"10"); 
String searchEngine = 
ServletUtilities.getCookieValue(cookies, 
"searchEngine", 
"google"); 
response.setContentType("text/html"); 
PrintWriter out = response.getWriter(); 
String title = "Searching the Web"; 
out.println(ServletUtilities.headWithTitle(title) + 
"\n" + 
"

Searching the Web

\n" + 
"\n" + 
"

\n" + 
"\n" + 
"Search String:\n" + 
" " VALUE=\"" + searchString + "\">
\n" + 
"Results to Show Per Page:\n" + 
" " VALUE=" + numResults + " SIZE=3>
\n" + 
" " VALUE=\"google\"" + 
checked("google", searchEngine) + ">\n" + 
"Google |\n" + 
" " VALUE=\"infoseek\"" + 
checked("infoseek", searchEngine) + ">\n" + 
"Infoseek |\n" + 
" " VALUE=\"lycos\"" + 
checked("lycos", searchEngine) + ">\n" + 
"Lycos |\n" + 
" " VALUE=\"hotbot\"" + 
checked("hotbot", searchEngine) + ">\n" + 
"HotBot\n" + 
"
\n" + 
"\n" + 
"\n" + 
"

\n" + 
"\n" + 
"\n" + 
"\n"); 
} 

private String checked(String name1, String name2) { 
if (name1.equals(name2)) 
return(" CHECKED"); 
else 
return(""); 
} 
} 

　　 CustomizedSearchEngines.java 

　　 前面的SearchEnginesFrontEnd Servlet把数据发送到CustomizedSearchEngines Servlet。本例在许多方面与前面介绍HTTP状态代码时的例子相似，区别在于，本例除了要构造一个针对搜索引擎的URL并向用户发送一个重定向应答之外，还要发送保存用户数据的Cookies。 
package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.net.*; 

public class CustomizedSearchEngines extends HttpServlet { 
public void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 

String searchString = request.getParameter("searchString"); 
Cookie searchStringCookie = 
new LongLivedCookie("searchString", searchString); 
response.addCookie(searchStringCookie); 
searchString = URLEncoder.encode(searchString); 
String numResults = request.getParameter("numResults"); 
Cookie numResultsCookie = 
new LongLivedCookie("numResults", numResults); 
response.addCookie(numResultsCookie); 
String searchEngine = request.getParameter("searchEngine"); 
Cookie searchEngineCookie = 
new LongLivedCookie("searchEngine", searchEngine); 
response.addCookie(searchEngineCookie); 
SearchSpec[] commonSpecs = SearchSpec.getCommonSpecs(); 
for(int i=0; i SearchSpec searchSpec = commonSpecs[i]; 
if (searchSpec.getName().equals(searchEngine)) { 
String url = 
searchSpec.makeURL(searchString, numResults); 
response.sendRedirect(url); 
return; 
} 
} 
response.sendError(response.SC_NOT_FOUND, 
"No recognized search engine specified."); 
} 

public void doPost(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException { 
doGet(request, response); 
} 
} 

10 会话 

　　 10.1 会话状态概述 

　　HTTP协议的“无状态”（Stateless）特点带来了一系列的问题。特别是通过在线商店购物时，服务器不能顺利地记住以前的事务就成了严重的问题。它使得“购物篮”之类的应用很难实现：当我们把商品加入购物篮时，服务器如何才能知道篮子里原先有些什么？即使服务器保存了上下文信息，我们仍旧会在电子商务应用中遇到问题。例如，当用户从选择商品的页面（由普通的服务器提供）转到输入信用卡号和送达地址的页面（由支持SSL的安全服务器提供），服务器如何才能记住用户买了些什么？ 

　　这个问题一般有三种解决方法： 

　　Cookie。利用HTTP Cookie来存储有关购物会话的信息，后继的各个连接可以查看当前会话，然后从服务器的某些地方提取有关该会话的完整信息。这是一种优秀的，也是应用最广泛的方法。然而，即使Servlet提供了一个高级的、使用方便的Cookie接口，仍旧有一些繁琐的细节问题需要处理： 

　　从其他Cookie中分别出保存会话标识的Cookie。 

　　为Cookie设置合适的作废时间（例如，中断时间超过24小时的会话一般应重置）。 

　　把会话标识和服务器端相应的信息关联起来。（实际保存的信息可能要远远超过保存到Cookie的信息，而且象信用卡号等敏感信息永远不应该用Cookie来保存。） 

　　改写URL。你可以把一些标识会话的数据附加到每个URL的后面，服务器能够把该会话标识和它所保存的会话数据关联起来。这也是一个很好的方法，而且还有当浏览器不支持Cookie或用户已经禁用Cookie的情况下也有效这一优点。然而，大部分使用Cookie时所面临的问题同样存在，即服务器端的程序要进行许多简单但单调冗长的处理。另外，还必须十分小心地保证每个URL后面都附加了必要的信息（包括非直接的，如通过Location给出的重定向URL）。如果用户结束会话之后又通过书签返回，则会话信息会丢失。 

　　隐藏表单域。HTML表单中可以包含下面这样的输入域：。这意味着，当表单被提交时，隐藏域的名字和数据也被包含到GET或POST数据里，我们可以利用这一机制来维持会话信息。然而，这种方法有一个很大的缺点，它要求所有页面都是动态生成的，因为整个问题的核心就是每个会话都要有一个唯一标识符。 

　　Servlet为我们提供了一种与众不同的方案：HttpSession API。HttpSession API是一个基于Cookie或者URL改写机制的高级会话状态跟踪接口：如果浏览器支持Cookie，则使用Cookie；如果浏览器不支持Cookie或者Cookie功能被关闭，则自动使用URL改写方法。Servlet开发者无需关心细节问题，也无需直接处理Cookie或附加到URL后面的信息，API自动为Servlet开发者提供一个可以方便地存储会话信息的地方。 

　　10.2 会话状态跟踪API 

　　在Servlet中使用会话信息是相当简单的，主要的操作包括：查看和当前请求关联的会话对象，必要的时候创建新的会话对象，查看与某个会话相关的信息，在会话对象中保存信息，以及会话完成或中止时释放会话对象。 

　　10.2.1 查看当前请求的会话对象 

　　查看当前请求的会话对象通过调用HttpServletRequest的getSession方法实现。如果getSession方法返回null，你可以创建一个新的会话对象。但更经常地，我们通过指定参数使得不存在现成的会话时自动创建一个会话对象，即指定getSession的参数为true。因此，访问当前请求会话对象的第一个步骤通常如下所示： 

HttpSession session = request.getSession(true); 

　　10.2.2 查看和会话有关的信息 

　　HttpSession对象生存在服务器上，通过Cookie或者URL这类后台机制自动关联到请求的发送者。会话对象提供一个内建的数据结构，在这个结构中可以保存任意数量的键-值对。在2.1或者更早版本的Servlet API中，查看以前保存的数据使用的是getValue("key")方法。getValue返回Object，因此你必须把它转换成更加具体的数据类型。如果参数中指定的键不存在，getValue返回null。 

　　API 2.2版推荐用getAttribute来代替getValue，这不仅是因为getAttribute和setAttribute的名字更加匹配（和getValue匹配的是putValue，而不是setValue），同时也因为setAttribute允许使用一个附属的HttpSessionBindingListen er 来监视数值，而putValue则不能。 

　　但是，由于目前还只有很少的商业Servlet引擎支持2.2，下面的例子中我们仍旧使用getValue。这是一个很典型的例子，假定ShoppingCart是一个保存已购买商品信息的类： 

HttpSession session = request.getSession(true); 
ShoppingCart previousItems =(ShoppingCart)session.getValue("previousItems"); 
if (previousItems != null) { 
　doSomethingWith(previousItems); 
} else { 
　previousItems = new ShoppingCart(...); 
　doSomethingElseWith(previousItems); 
} 

　　大多数时候我们都是根据特定的名字寻找与它关联的值，但也可以调用getValueNames得到所有属性的名字。getValuesNames返回的是一个String数组。API 2.2版推荐使用getAttributeNames，这不仅是因为其名字更好，而且因为它返回的是一个Enumeration，和其他方法（比如HttpServletRequest的getHeaders和getParameterNames）更加一致。 

　　虽然开发者最为关心的往往是保存到会话对象的数据，但还有其他一些信息有时也很有用。 

　　getID：该方法返回会话的唯一标识。有时该标识被作为键-值对中的键使用，比如会话中只保存一个值时，或保存上一次会话信息时。 

　　isNew：如果客户（浏览器）还没有绑定到会话则返回true，通常意味着该会话刚刚创建，而不是引用自客户端的请求。对于早就存在的会话，返回值为false。 

　　getCreationTime：该方法返回建立会话的以毫秒计的时间，从1970.01.01（GMT）算起。要得到用于打印输出的时间值，可以把该值传递给Date构造函数，或者GregorianCalendar的setTimeInMillis方法。 

　　getLastAccessedTime：该方法返回客户最后一次发送请求的以毫秒计的时间，从1970.01.01（GMT）算起。 

　　getMaxInactiveInterval：返回以秒计的最大时间间隔，如果客户请求之间的间隔不超过该值，Servlet引擎将保持会话有效。负数表示会话永远不会超时。 

　　10.2.3 在会话对象中保存数据 

　　如上节所述，读取保存在会话中的信息使用的是getValue方法（或，对于2.2版的Servlet规范，使用getAttribute）。保存数据使用putValue（或setAttribute）方法，并指定键和相应的值。注意putValue将替换任何已有的值。有时候这正是我们所需要的（如下例中的referringPage），但有时我们却需要提取原来的值并扩充它（如下例previousItems）。示例代码如下： 

HttpSession session = request.getSession(true); 
session.putValue("referringPage", request.getHeader("Referer")); 
ShoppingCart previousItems = (ShoppingCart)session.getValue("previousItems"); 
if (previousItems == null) { 
　　previousItems = new ShoppingCart(...); 
} 
String itemID = request.getParameter("itemID"); 
previousItems.addEntry(Catalog.getEntry(itemID)); 

session.putValue("previousItems", previousItems); 

　　10.3 实例：显示会话信息 

　　下面这个例子生成一个Web页面，并在该页面中显示有关当前会话的信息。 

package hall; 

import java.io.*; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.net.*; 
import java.util.*; 

public class ShowSession extends HttpServlet { 
　public void doGet(HttpServletRequest request,HttpServletResponse response) 
　throws ServletException, IOException { 
　　HttpSession session = request.getSession(true); 
　　response.setContentType("text/html"); 
　　PrintWriter out = response.getWriter(); 
　　String title = "Searching the Web"; 
　　String heading; 
　　Integer accessCount = new Integer(0);; 
　　if (session.isNew()) { 
　　　heading = "Welcome, Newcomer"; 
　　} else { 
　　　heading = "Welcome Back"; 
　　　Integer oldAccessCount = 
　　　// 在Servlet API 2.2中使用getAttribute而不是getValue 
　　　(Integer)session.getValue("accessCount"); 
　　if (oldAccessCount != null) { 
　　　accessCount = 
　　　new Integer(oldAccessCount.intValue() + 1); 
　　} 
　} 
　// 在Servlet API 2.2中使用putAttribute 
　session.putValue("accessCount", accessCount); 

　out.println(ServletUtilities.headWithTitle(title) +"\n" + 
　　　　　"

" + heading + "

\n" + 
　　　　　"

Information on Your Session:

\n" + 
　　　　　"\n" + 
　　　　　"\n" + 
　　　　　" \n" + 
　　　　　" \n" + 
　　　　　" \n" + 
　　　　　" \n" + 
　　　　　"

Info Type	Value\n" +  　　　　　"
ID\n" +  　　　　　"	" + session.getId() + "\n" +  　　　　　"
Creation Time\n" +  　　　　　"	" + new Date(session.getCreationTime()) + "\n" +  　　　　　"
Time of Last Access\n" +  　　　　　"	" + new Date(session.getLastAccessedTime()) + "\n" +  　　　　　"
Number of Previous Accesses\n" +  　　　　　"	" + accessCount + "\n" +  　　　　　"

\n" + 
　　　　　""); 
　} 
　public void doPost(HttpServletRequest request, 
　　HttpServletResponse response) 
　　throws ServletException, IOException { 
　　　doGet(request, response); 
　} 
}

11 JSP 

　　 11.1 JSP概述 

　　JavaServer Pages（JSP）使得我们能够分离页面的静态HTML和动态部分。HTML可以用任何通常使用的Web制作工具编写，编写方式也和原来的一样；动态部分的代码放入特殊标记之内，大部分以“<%”开始，以“%>”结束。例如，下面是一个JSP页面的片断，如果我们用 http://host/OrderConfirmation.jsp?title=Core+Web+Programming这个URL打开该页面，则结果显示“Thanks for ordering Core Web Programming”。 

Thanks for ordering 
<%= request.getParameter("title") %> 

　　JSP页面文件通常以.jsp为扩展名，而且可以安装到任何能够存放普通Web页面的地方。虽然从代码编写来看，JSP页面更象普通Web页面而不象Servlet，但实际上，JSP最终会被转换成正规的Servlet，静态HTML直接输出到和Servlet service方法关联的输出流。 

　　JSP到Servlet的转换过程一般在出现第一次页面请求时进行。因此，如果你希望第一个用户不会由于JSP页面转换成Servlet而等待太长的时间，希望确保Servlet已经正确地编译并装载，你可以在安装JSP页面之后自己请求一下这个页面。 

　　另外也请注意，许多Web服务器允许定义别名，所以一个看起来指向HTML文件的URL实际上可能指向Servlet或JSP页面。 

　　除了普通HTML代码之外，嵌入JSP页面的其他成分主要有如下三种：脚本元素（Scripting Element），指令（Directive），动作（Action）。脚本元素用来嵌入Java代码，这些Java代码将成为转换得到的Servlet的一部分；JSP指令用来从整体上控制Servlet的结构；动作用来引入现有的组件或者控制JSP引擎的行为。为了简化脚本元素，JSP定义了一组可以直接使用的变量（预定义变量），比如前面代码片断中的request就是其中一例。 

　　注意本文以JSP 1.0规范为基础。和0.92版相比，新版本的JSP作了许多重大的改动。虽然这些改动只会使JSP变得更好，但应注意1.0的JSP页面几乎和早期的JSP引擎完全不兼容。 

　　11.2 JSP语法概要表 

JSP元素 语法 说明 备注 
JSP表达式 <%= expression %> 计算表达式并输出结果 等价的XML表达是： 
 
expression 
 

　可以使用的预定义变量包括：request，response，out，session，application，config，pageContext。这些预定义变量也可以在JSP Scriptlet中使用。 
JSP Scriptlet <% code %> 插入到service方法的代码。 等价的XML表达是： 
 
code 
 

JSP声明 <%! code %> 代码被插入到Servlet类（在service方法之外） 等价的XML表达是： 

 
code 
 
page指令 <%@ page att="val" %> 作用于Servlet引擎的全局性指令 等价的XML表达是 
 

　合法的属性如下表，其中粗体表示默认值： 
import="package.class" 
contentType="MIME-Type" 
isThreadSafe="true|false" 
session="true|false" 
buffer="size kb|none" 
false" 
extends="package.class" 
info="message" 
errorPage="url" 
isErrorPage="true|false" 
language="java" 
include指令 <%@ include file="url" %> 当JSP转换成Servlet时，应当包含本地系统上的指定文件 等价的XML表达是： 
 

　　其中URL必须是相对URL。 

　　利用jsp:include动作可以在请求的时候（而不是JSP转换成Servlet时）引入文件。 
JSP注释 <%-- comment --%> 注释；JSP转换成Servlet时被忽略 如果要把注释嵌入结果HTML文档，使用普通的HTML注释标记<-- comment -->。 
jsp:include动作 当Servlet被请求时，引入指定的文件 如果你希望在页面转换的时候包含某个文件，使用JSP include指令 

注意：在某些服务器上，被包含文件必须是HTML文件或JSP文件，具体由服务器决定（通常根据文件扩展名判断）。 
jsp:useBean动作 或者 
 
... 
寻找或实例化一个Java Bean 可能的属性包括： 
id="name" 
scope="page|request 
|session|application" 
class="package.class" 
type="package.class" 
beanName="package.class" 
jsp:setProperty动作 设置Bean的属性，既可以设置一个确定的值，也可以指定属性值来自请求参数。 合法的属性包括： 
name="beanName" 
property="propertyName|*" 
param="parameterName" 
value="val" 

jsp:getProperty动作 name="propertyName" 
value="val"/> 提取并输出Bean的属性。 
jsp:forward动作 page="relative URL"/> 把请求转到另外一个页面。 
jsp:plugin动作 attribute="value"*> 
... 
　 根据浏览器类型生成OBJECT或者EMBED标记，以便通过Java Plugin运行Java Applet。 
　　 
　　11.3 关于模板文本（静态HTML） 

　　许多时候，JSP页面的很大一部分都由静态HTML构成，这些静态HTML也称为“模板文本”。模板文本和普通HTML几乎完全相同，它们都遵从相同的语法规则，而且模板文本也是被Servlet直接发送到客户端。此外，模板文本也可以用任何现有的页面制作工具来编写。 

　　唯一的例外在于，如果要输出“<%”，则模板文本中应该写成“<\%”。 

12 脚本元素、指令和预定义变量

　　12.1 JSP脚本元素 

　　JSP脚本元素用来插入Java代码，这些Java代码将出现在由当前JSP页面生成的Servlet中。脚本元素有三种格式： 

　　　表达式格式<%= expression %>：计算表达式并输出其结果。 

　　　Scriptlet格式<% code %>：把代码插入到Servlet的service方法。 

　　　声明格式<%! code %>：把声明加入到Servlet类（在任何方法之外）。 

　　下面我们详细说明它们的用法。 

　　12.1.1 JSP表达式 

　　JSP表达式用来把Java数据直接插入到输出。其语法如下： 

<%= Java Expression %> 

　　计算Java表达式得到的结果被转换成字符串，然后插入到页面?扑阍谠诵惺苯校ㄒ趁姹磺肭笫保虼丝梢苑梦屎颓肭笥泄氐娜啃畔ⅰ＠纾旅娴拇胂允疽趁姹磺肭蟮娜掌?时间： 
Current time: <%= new java.util.Date() %> 

　　为简化这些表达式，JSP预定义了一组可以直接使用的对象变量。后面我们将详细介绍这些隐含声明的对象，但对于JSP表达式来说，最重要的几个对象及其类型如下： 

request：HttpServletRequest; 
response：HttpServletResponse; 
session：和request关联的HttpSession 
out：PrintWriter（带缓冲的版本，JspWriter），用来把输出发送到客户端 

　　下面是一个例子： 

Your hostname: <%= request.getRemoteHost() %> 

　　最后，如果使用XML的话，JSP表达式也可以写成下面这种形式： 

 
Java Expression 
 

　　请记住XML元素和HTML不一样。XML是大小写敏感的，因此务必使用小写。有关XML语法的说明，请参见《XML教程 》 

　　12.1.2 JSP Scriptlet 

　　如果你要完成的任务比插入简单的表达式更加复杂，可以使用JSP Scriptlet。JSP Scriptlet允许你把任意的Java代码插入Servlet。JSP Scriptlet语法如下： 

<% Java Code %> 

　　和JSP表达式一样，Scriptlet也可以访问所有预定义的变量。例如，如果你要向结果页面输出内容，可以使用out变量： 

<% 
String queryData = request.getQueryString(); 
out.println("Attached GET data: " + queryData); 
%> 

　　注意Scriptlet中的代码将被照搬到Servlet内，而Scriptlet前面和后面的静态HTML（模板文本）将被转换成println语句。这就意味着，Scriptlet内的Java语句并非一定要是完整的，没有关闭的块将影响Scriptlet外的静态HTML。例如，下面的JSP片断混合了模板文本和Scriptlet： 

<% if (Math.random() < 0.5) { %> 
Have a nice day! 
<% } else { %> 
Have a lousy day! 
<% } %> 

　　上述JSP代码将被转换成如下Servlet代码： 

if (Math.random() < 0.5) { 
out.println("Have a nice day!"); 
} else { 
out.println("Have a lousy day!"); 
} 

　　如果要在Scriptlet内部使用字符“%>”，必须写成“%\>”。另外，请注意<% code %>的XML等价表达是： 

 
Code 
 

　　12.1.3 JSP声明 

　　JSP声明用来定义插入Servlet类的方法和成员变量，其语法如下： 

<%! Java Code %> 

　　由于声明不会有任何输出，因此它们往往和JSP表达式或Scriptlet结合在一起使用。例如，下面的JSP代码片断输出自从服务器启动（或Servlet类被改动并重新装载以来）当前页面被请求的次数： 

<%! private int accessCount = 0; %> 

　　自从服务器启动以来页面访问次数为： 

<%= ++accessCount %> 

　　和Scriptlet一样，如果要使用字符串“%>”，必须使用“%\>”代替。最后，<%! code %>的XML等价表达方式为： 

 
Code 
 

　　12.2 JSP指令 

　　JSP指令影响Servlet类的整体结构，它的语法一般如下： 

<%@ directive attribute="value" %> 

　　另外，也可以把同一指令的多个属性结合起来，例如： 

<%@ directive attribute1="value1" 
attribute2="value2" 
... 
attributeN="valueN" %> 

　　JSP指令分为两种类型：第一是page指令，用来完成下面这类任务：导入指定的类，自定义Servlet的超类，等等；第二是include指令，用来在JSP文件转换成Servlet时引入其他文件。JSP规范也提到了taglib指令，其目的是让JSP开发者能够自己定义标记，但JSP 1.0不支持该指令，有希望它将成为JSP 1.1的主要改进之一。 

　　12.2.1 page指令 

　　page指令的作用是定义下面一个或多个属性，这些属性大小写敏感。 

import="package.class"，或者import="package.class1,...,package.classN"： 

　　用于指定导入哪些包，例如：<%@ page import="java.util.*" %>。import是唯一允许出现一次以上的属性。 

contentType="MIME-Type" 或contentType="MIME-Type; charset=Character-Set"： 

　　该属性指定输出的MIME类型。默认是text/html。例如，下面这个指令： 

<%@ page contentType="text/plain" %>。 

和下面的Scriptlet效果相同： 

<% response.setContentType("text/plain"); %> 
isThreadSafe="true|false" 

　　默认值true表明Servlet按照标准的方式处理，即假定开发者已经同步对实例变量的访问，由单个Servlet实例同时地处理多个请求。如果取值false，表明Servlet应该实现SingleThreadModel，请求或者是逐个进入，或者多个并行的请求分别由不同的Servlet实例处理。 

session="true|false" 

　　默认值true表明预定义变量session（类型为HttpSession）应该绑定到已有的会话，如果不存在已有的会话，则新建一个并绑定session变量。如果取值false，表明不会用到会话，试图访问变量session将导致JSP转换成Servlet时出错。 

buffer="size kb|none" 

　　该属性指定JspWrite out的缓存大小。默认值和服务器有关，但至少应该是8 KB。 

false" 

　　默认值true表明如果缓存已满则刷新它。autoflush很少取false值，false值表示如果缓存已满则抛出异常。如果buffer="none"，autoflush不能取false值。 

extends="package.class" 

　　该属性指出将要生成的Servlet使用哪个超类。使用该属性应当十分小心，因为服务器可能已经在用自定义的超类。 

info="message" 

　　该属性定义一个可以通过getServletInfo方法提取的字符串。 

errorPage="url" 

　　该属性指定一个JSP页面，所有未被当前页面捕获的异?筛靡趁娲怼? 

isErrorPage="true|false" 

　　该属性指示当前页面是否可以作为另一JSP页面的错误处理页面。默认值false。 

language="java" 

　　该属性用来指示所使用的语言。目前没有必要关注这个属性，因为默认的Java是当前唯一可用的语言。 

　　定义指令的XML语法为： 

 

　　例如，下面这个指令： 

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

　　它的XML等价表达是： 

 

　　12.2.2 include指令 

　　include指令用于JSP页面转换成Servlet时引入其他文件。该指令语法如下： 

<%@ include file="relative url" %> 

　　这里所指定的URL是和发出引用指令的JSP页面相对的URL，然而，与通常意义上的相对URL一样，你可以利用以“/”开始的URL告诉系统把URL视为从Web服务器根目录开始。包含文件的内容也是JSP代码，即包含文件可以包含静态HTML、脚本元素、JSP指令和动作。 

　　例如，许多网站的每个页面都有一个小小的导航条。由于HTML框架存在不少问题，导航条往往用页面顶端或左边的一个表格制作，同一份HTML代码重复出现在整个网站的每个页面上。include指令是实现该功能的非常理想的方法。使用include指令，开发者不必再把导航HTML代码拷贝到每个文件中，从而可以更轻松地完成维护工作。 

　　由于include指令是在JSP转换成Servlet的时候引入文件，因此如果导航条改变了，所有使用该导航条的JSP页面都必须重新转换成Servlet。如果导航条改动不频繁，而且你希望包含操作具有尽可能好的效率，使用include指令是最好的选择。然而，如果导航条改动非常频繁，你可以使用jsp:include动作。jsp:include动作在出现对JSP页面请求的时候才会引用指定的文件，请参见本文后面的具体说明。 

　　12.3 实例：脚本元素和指令的应用 

　　下面是一个使用JSP表达式、Scriptlet、声明、指令的简单例子。 

 
 
 
 
 

VLINK="#551A8B" ALINK="#FF0000"> 
 
 

JSP应用实例

 
 

 
下面是一些利用各种JSP功能生成的动态内容: 

 

• 表达式.
   
  你的主机名: <%= request.getRemoteHost() %>. 
  
• JSP Scriptlet.
   
  <% out.println("查询字符串: " + 
  request.getQueryString()); %> 
  
• 声明（和表达式）.
   
  <%! private int accessCount = 0; %> 
  服务器启动以来访问次数: <%= ++accessCount %> 
  
• 指令（和表达式）.
   
  <%@ page import = "java.util.*" %> 
  当前日期: <%= new Date() %> 
  

 

 
 

　　12.4 JSP预定义变量 

　　为了简化JSP表达式和Scriptlet的代码，JSP提供了8个预先定义的变量（或称为隐含对象）。这些变量是request、response、out、session、application、config、pageContext和page。 

　　12.4.1 request 

　　这是和请求关联的HttpServletRequest，通过它可以查看请求参数（调用getParameter），请求类型（GET，POST，HEAD，等），以及请求的HTTP头（Cookie，Referer，等）。严格说来，如果请求所用的是HTTP之外的其他协议，request可以是ServletRequest的子类（而不是HttpServletRequest），但在实践中几乎不会用到。 

　　12.4.2 response 

　　这是和应答关联的HttpServletResponse。注意，由于输出流（参见下面的out）是带缓冲的，因此，如果已经向客户端发送了输出内容，普通Servlet不允许再设置HTTP状态代码，但在JSP中却是合法的。 

　　12.4.3 out 

　　这是用来向客户端发送内容的PrintWriter。然而，为了让response对象更为实用，out是带缓存功能的PrintWriter，即JspWriter。JSP允许通过page指令的buffer属性调整缓存的大小，甚至允许关闭缓存。 

　　out一般只在Scriptlet内使用，这是因为JSP表达式是自动发送到输出流的，很少需要显式地引用out。 

　　12.4.4 session 

　　这是和请求关联的HttpSession对象。前面我们已经介绍过会话的自动创建，我们知道，即使不存在session引用，这个对象也是自动绑定的。但有一个例外，这就是如果你用page指令的session属性关闭了会话，此时对session变量的引用将导致JSP页面转换成Servlet时出错。 

　　12.4.5 application 

　　这是一个ServletContext，也可以通过getServletConfig().getContext()获得。 

　　12.4.6 config 

　　这是当前页面的ServletConfig对象。 

　　12.4.7 pageContext 

　　主要用来管理页面的属性。 

　　12.4.8 page 

　　它是this的同义词，当前用处不大。它是为了Java不再是唯一的JSP编程语言而准备的占位符。 

　　 JSP动作利用XML语法格式的标记来控制Servlet引擎的行为。利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。 

　　 JSP动作包括： 

　　　jsp:include：在页面被请求的时候引入一个文件。 

　　　jsp:useBean：寻找或者实例化一个JavaBean。 

　　　jsp:setProperty：设置JavaBean的属性。 

　　　jsp:getProperty：输出某个JavaBean的属性。 

　　　jsp:forward：把请求转到一个新的页面。 

　　　jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。 

13 JSP动作

　　 13.1 jsp:include动作 

　　 该动作把指定文件插入正在生成的页面。其语法如下： 

 

　　 前面已经介绍过include指令，它是在JSP文件被转换成Servlet的时候引入文件，而这里的jsp:include动作不同，插入文件的时间是在页面被请求的时候。jsp:include动作的文件引入时间决定了它的效率要稍微差一点，而且被引用文件不能包含某些JSP代码（例如不能设置HTTP头），但它的灵活性却要好得多。 

　　 例如，下面的JSP页面把4则新闻摘要插入一个“What's New ?”页面。改变新闻摘要时只需改变这四个文件，而主JSP页面却可以不作修改： 

　　 WhatsNew.jsp 

 
 
 
 
 

VLINK="#551A8B" ALINK="#FF0000"> 

 
 

What's New at JspNews.com

 
 

 
Here is a summary of our four most recent news stories: 

 

1.  
   
2.  
   
3.  
   
4.  
   

 
 
 

　　 13.2 jsp:useBean动作 

　　 jsp:useBean动作用来装载一个将在JSP页面中使用的JavaBean。这个功能非常有用，因为它使得我们既可以发挥Java组件重用的优势，同时也避免了损失JSP区别于Servlet的方便性。jsp:useBean动作最简单的语法为： 

 

　　 这行代码的含义是：“创建一个由class属性指定的类的实例，然后把它绑定到其名字由id属性给出的变量上”。不过，就象我们接下来会看到的，定义一个scope属性可以让Bean关联到更多的页面。此时，jsp:useBean动作只有在不存在同样id和scope的Bean时才创建新的对象实例，同时，获得现有Bean的引用就变得很有必要。 

　　 获得Bean实例之后，要修改Bean的属性既可以通过jsp:setProperty动作进行，也可以在Scriptlet中利用id属性所命名的对象变量，通过调用该对象的方法显式地修改其属性。这使我们想起，当我们说“某个Bean有一个类型为X的属性foo”时，就意味着“这个类有一个返回值类型为X的getFoo方法，还有一个setFoo方法以X类型的值为参数”。 

　　 有关jsp:setProperty动作的详细情况在后面讨论。但现在必须了解的是，我们既可以通过jsp:setProperty动作的value属性直接提供一个值，也可以通过param属性声明Bean的属性值来自指定的请求参数，还可以列出Bean属性表明它的值应该来自请求参数中的同名变量。 

　　 在JSP表达式或Scriptlet中读取Bean属性通过调用相应的getXXX方法实现，或者更一般地，使用jsp:getProperty动作。 

　　 注意包含Bean的类文件应该放到服务器正式存放Java类的目录下，而不是保留给修改后能够自动装载的类的目录。例如，对于Java Web Server来说，Bean和所有Bean用到的类都应该放入classes目录，或者封装进jar文件后放入lib目录，但不应该放到servlets下。 

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

　　 BeanTest.jsp 

 
 
 
 
 

 
 
 

Reusing JavaBeans in JSP

 
 

 

 
property="message" 
value="Hello WWW" /> 

Message:  
 

 

 
 

　　 SimpleBean.java 

　　 BeanTest页面用到了一个SimpleBean。SimpleBean的代码如下： 

package hall; 

public class SimpleBean { 
private String message = "No message specified"; 

public String getMessage() { 
return(message); 
} 

public void setMessage(String message) { 
this.message = message; 
} 
} 

　　 13.3 关于jsp:useBean的进一步说明 

　　 使用Bean最简单的方法是先用下面的代码装载Bean： 

 

　　 然后通过jsp:setProperty和jsp:getProperty修改和提取Bean的属性。不过有两点必须注意。第一，我们还可以用下面这种格式实例化Bean： 

 
Body 
 

　　 它的意思是，只有当第一次实例化Bean时才执行Body部分，如果是利用现有的Bean实例则不执行Body部分。正如下面将要介绍的，jsp:useBean并非总是意味着创建一个新的Bean实例。 

　　 第二，除了id和class外，jsp:useBean还有其他三个属性，即：scope，type，beanName。下表简要说明这些属性的用法。 

表示该Bean在当前的客户请求内有效（保存在ServletRequest对象内）。 属性 用法 
id 命名引用该Bean的变量。如果能够找到id和scope相同的Bean实例，jsp:useBean动作将使用已有的Bean实例而不是创建新的实例。 
class 指定Bean的完整包名。 
scope 　指定Bean在哪种上下文内可用，可以取下面的四个值之一：page，request，session和application。默认值是page，表示该Bean只在当前页面内可用（保存在当前页面的PageContext内）。request表示该Bean在当前的客户请求内有效（保存在ServletRequest对象内）。session表示该Bean对当前HttpSession内的所有页面都有效。最后，如果取值application，则表示该Bean对所有具有相同ServletContext的页面都有效。scope之所以很重要，是因为jsp:useBean只有在不存在具有相同id和scope的对象时才会实例化新的对象；如果已有id和scope都相同的对象则直接使用已有的对象，此时jsp:useBean开始标记和结束标记之间的任何内容都将被忽略。 
type 指定引用该对象的变量的类型，它必须是Bean类的名字、超类名字、该类所实现的接口名字之一。请记住变量的名字是由id属性指定的。 
beanName 指定Bean的名字。如果提供了type属性和beanName属性，允许省略class属性。 

　　 13.4 jsp:setProperty动作 

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

 
... 
property="someProperty" ... /> 

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

 
... 
property="someProperty" ... /> 
 

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

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

属性 说明 
name name属性是必需的。它表示要设置属性的是哪个Bean。 
property property属性是必需的。它表示要设置哪个属性。有一个特殊用法：如果property的值是“*”，表示所有名字和Bean属性名字匹配的请求参数都将被传递给相应的属性set方法。 
value value属性是可选的。该属性用来指定Bean属性的值。字符串数据会在目标类中通过标准的valueOf方法自动转换成数字、boolean、Boolean、byte、Byte、char、Character。例如，boolean和Boolean类型的属性值（比如“true”）通过Boolean.valueOf转换，int和Integer类型的属性值（比如“42”）通过Integer.valueOf转换。value和param不能同时使用，但可以使用其中任意一个。 
param param是可选的。它指定用哪个请求参数作为Bean属性的值。如果当前请求没有参数，则什么事情也不做，系统不会把null传递给Bean属性的set方法。因此，你可以让Bean自己提供默认属性值，只有当请求参数明确指定了新值时才修改默认属性值。 

　　例如，下面的代码片断表示：如果存在numItems请求参数的话，把numberOfItems属性的值设置为请求参数numItems的值；否则什么也不做。 

property="numberOfItems" 
param="numItems" /> 

　　如果同时省略value和param，其效果相当于提供一个param且其值等于property的值。进一步利用这种借助请求参数和属性名字相同进行自动赋值的思想，你还可以在property（Bean属性的名字）中指定“*”，然后省略value和param。此时，服务器会查看所有的Bean属性和请求参数，如果两者名字相同则自动赋值。 

　　 下面是一个利用JavaBean计算素数的例子。如果请求中有一个numDigits参数，则该值被传递给Bean的numDigits属性；numPrimes也类似。 

　　 JspPrimes.jsp 

 
 
 
 
 

 

 
 

在JSP中使用JavaBean

 
 

 

 
 
 

Some  
digit primes: 
 

 
 

　　 注：NumberedPrimes的代码略。 

　　 13.5 jsp:getProperty动作 

　　 jsp:getProperty动作提取指定Bean属性的值，转换成字符串，然后输出。jsp:getProperty有两个必需的属性，即：name，表示Bean的名字；property，表示要提取哪个属性的值。下面是一个例子，更多的例子可以在前文找到。 

 
... 

 

• Number of items: 
   
  
• Cost of each: 
   
  

 

　　 13.6 jsp:forward动作 

　　 jsp:forward动作把请求转到另外的页面。jsp:forward标记只有一个属性page。page属性包含的是一个相对URL。page的值既可以直接给出，也可以在请求的时候动态计算，如下面的例子所示： 

 
 

　　 13.7 jsp:plugin动作 

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

　　 附录：JSP注释和字符引用约定 

　　 下面是一些特殊的标记或字符，你可以利用它们插入注释或可能被视为具有特殊含义的字符。 

语法 用途 
<%-- comment --%> JSP注释，也称为“隐藏注释”。JSP引擎将忽略它。标记内的所有JSP脚本元素、指令和动作都将不起作用。 
HTML注释，也称为“输出的注释”，直接出现在结果HTML文档中。标记内的所有JSP脚本元素、指令和动作正常执行。 
<\% 在模板文本（静态HTML）中实际上希望出现“<%”的地方使用。 
%\> 在脚本元素内实际上希望出现“%>”的地方使用。 
\' 使用单引号的属性内的单引号。不过，你既可以使用单引号也可以使用双引号，而另外一种引号将具有普通含义。 
\" 使用双引号的属性内的双引号。参见“\'”的说明。