将Web应用部署到Tomcat中后，从理论上说Web应用就已经可以通过Tomcat正常访问了。但是为了能够灵活地配置Web应用以及向Web应用中添加更加丰富的内容（例如Servlet），读者还应该了解Web应用部署描述符web.xml。

在第6章介绍Tomcat的配置时已经提到了，在Tomcat中每个Web应用都拥有一个对Web应用进行配置的web.xml文件，它位于Web应用根目录的WEB-INF目录下。由于Web应用的许多配置在各个Web应用之间是通用的，所以Tomcat使用${TOMCAT_HOME}\conf\web.xml文件（称通用部署描述符）来配置通用部分，各个Web应用将自己Web应用特有的配置内容放置在Web应用根目录下的WEB-INF\web.xml文件（称特有部署描述符）中。每个Web应用通过将通用部署描述符和特有部署描述符中的配置项合并起来进行配置，假如通用部署描述符和特有部署描述符中的某些配置项有冲突，则特有部署描述符中的配置项优先。

不管是通用部署描述符还是特有部署描述符，它们都是一个XML文件，都遵循Web应用部署描述符的结构。

• 上一节
• 本书简介
• 下一节

web-app元素是Web应用部署描述符的根元素，它包含了若干个子元素，每个子元素对应于Web应用一个方面的配置，这些子元素的顺序是任意的。根据Web应用部署描述符2.5版本的XML Schema定义，web-app元素所有的属性和子元素如图7.2所示。

web-app元素包含三个主要属性：version、id和metadata-complete，其中最常用的是version，它表示Web描述文件兼容的最高版本。每个版本的Tomcat都有其兼容的Servlet标准版本号，例如Tomcat 6.x最高兼容Servlet 2.5，Tomcat 5.5最高兼容Servlet 2.4。每个Web应用也有其使用的版本号，该版本号与Servlet版本号一致，高版本的Web应用不能在只兼容低版本的Tomcat中使用，例如web-app元素version属性为2.5的Web应用不能应用于Tomcat 5.5中。

图7.2  Web部署描述符2.5版本Schema定义

web-app元素中可以定义许多元素，每一种元素对应一个Web应用的一项配置。其中最常用的有以下五种。

1．welcome-file-list：该元素定义了一个welcome文件列表，例如：

<welcome-file-list>

<welcome-file>index.html</welcome-file>

<welcome-file>index.htm</welcome-file>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

welcome文件是目录的默认访问文件，即当请求URL指向的是一个目录而不是一个文件时，目录中的默认访问文件就会成为目标访问文件。在welcome文件列表中的文件是有序的，排在前面的文件将被优先返回，当前面的文件在目录中不存在时才会依次寻找排在后面的文件。例如，在welcome-file-list为上面所示配置时，假如在上下文路径为test的Web应用的根目录中有index.html和index.jsp两个文件，那么请求URL为http://localhost:8080/test的请求相当于请求URL为http://localhost:8080/test/index. html的请求。

2．servlet和servlet-mapping：这两个元素用于向Web应用中添加Servlet。servlet元素用于定义Servlet的名称、实现类等属性，servlet-mapping用于定义Servlet的路径映射方式。具体的实现和配置方式将在后面介绍Servlet技术时详细介绍。

3．filter和filter-mapping：这两个元素用于向Web应用中添加过滤器。filter用于定义过滤器的名称、实现类等属性，filter-mapping用于定义filter的路径映射方式。具体的实现和配置方式将在介绍Servlet过滤器技术时详细介绍。

4．mime-mapping：该元素用于定义在Web应用中，如何根据文件名后缀映射文件的mime类型。例如：

<mime-mapping>

<extension>htm</extension>

<mime-type>text/html</mime-type>

</mime-mapping>

表示将所有后缀名为htm的文件映射为text/html类型。

【注意】

MIME是Multipurpose Internet Mail Extensions（多用途Internet邮件扩展）的简称，最初作为电子邮件非文本格式附件传输方式被提出和使用，现在这种方式被广泛应用于使用HTTP协议传输的各种应用中。MIME类型由内容类型（大类型）和子类型（小类型）组成，被用于判断二进制数文件的内容和打开方式。

5．session-config：用于配置session的一些参数，例如session的超时时间：

<session-config>

<session-timeout>30</session-timeout>

</session-config>

• 上一节
• 本书简介
• 下一节

Tomcat默认的通用Web应用部署描述符的初始内容如下：

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_ 5.xsd"

version="2.5">

<servlet>

<servlet-name>default</servlet-name>

<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>

<init-param>

<param-name>debug</param-name>

<param-value>0</param-value>

</init-param>

<init-param>

<param-name>listings</param-name>

<param-value>false</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet>

<servlet-name>jsp</servlet-name>

<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>

<init-param>

<param-name>fork</param-name>

<param-value>false</param-value>

</init-param>

<init-param>

<param-name>xpoweredBy</param-name>

<param-value>false</param-value>

</init-param>

<load-on-startup>3</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>default</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

<servlet-mapping>

<servlet-name>jsp</servlet-name>

<url-pattern>*.jsp</url-pattern>

</servlet-mapping>

<servlet-mapping>

<servlet-name>jsp</servlet-name>

<url-pattern>*.jspx</url-pattern>

</servlet-mapping>

<session-config>

<session-timeout>30</session-timeout>

</session-config>

<mime-mapping>

<extension>abs</extension>

<mime-type>audio/x-mpeg</mime-type>

</mime-mapping>

<mime-mapping>

<extension>ai</extension>

<mime-type>application/postscript</mime-type>

</mime-mapping>

<mime-mapping>

<extension>aif</extension>

<mime-type>audio/x-aiff</mime-type>

</mime-mapping>

...

<mime-mapping>

<extension>doc</extension>

<mime-type>application/vnd.ms-word</mime-type>

</mime-mapping>

<mime-mapping>

<extension>ppt</extension>

<mime-type>application/vnd.ms-powerpoint</mime-type>

</mime-mapping>

<welcome-file-list>

<welcome-file>index.html</welcome-file>

<welcome-file>index.htm</welcome-file>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

</web-app>

可以发现，该默认的部署描述符中定义了两个Servlet（名称分别为default和jsp）、一个session-config、若干个mime-mapping和一个welcome-file-list。

1．default Servlet

这里配置的default Servlet是使用于所有Web应用的默认Servlet，即假如在Host中没有定义Servlet或者到达的请求无法根据匹配规则分发到任何一个Servlet时，请求就会被分发到default Servlet。部署描述符中的如下部分对default Servlet进行了设置：

<servlet>

<servlet-name>default</servlet-name>

<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>

<init-param>

<param-name>debug</param-name>

<param-value>0</param-value>

</init-param>

<init-param>

<param-name>listings</param-name>

<param-value>false</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

...

<servlet-mapping>

<servlet-name>default</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

servlet-name定义了这个Servlet的名称，为default，用于标识这个Servlet；servlet-class是该Servlet使用的Java类，这里配置的是Tomcat提供的默认default Servlet的实现，正是这个Servlet实现了对静态Web对象的访问，使Tomcat能够支持静态Web对象访问；init-param定义了一些参数，这些参数在org.apache.catalina.servlets.DefaultServlet中使用；load-on-startup定义了一个整数值，当该值是0或正整数时，Tomcat在启动时必须加载和初始化该Servlet，而且保证该值越小的Servlet越早被加载并初始化；当该值是负数或该配置项不存在时Tomcat可以选择不在启动时加载和初始化Servlet。

url-pattern定义了一个请求URI模板，请求URI与该模板相匹配的请求将被分发到对应的Servlet。default Servlet的url-pattern是/，它可以与任意URI匹配，所以当没有其他Servlet的url-pattern更合适时，请求就会被分发到default Servlet。

2．jsp Servlet

jsp Servlet是Tomcat提供的用于处理所有JSP文件的Servlet，这也是Tomcat能正确处理JSP文件请求的原因。部署描述符中对于jsp Servlet的配置如下：

<servlet>

<servlet-name>jsp</servlet-name>

<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>

<init-param>

<param-name>fork</param-name>

<param-value>false</param-value>

</init-param>

<init-param>

<param-name>xpoweredBy</param-name>

<param-value>false</param-value>

</init-param>

<load-on-startup>3</load-on-startup>

</servlet>

...

<servlet-mapping>

<servlet-name>jsp</servlet-name>

<url-pattern>*.jsp</url-pattern>

</servlet-mapping>

<servlet-mapping>

<servlet-name>jsp</servlet-name>

<url-pattern>*.jspx</url-pattern>

</servlet-mapping>

在Servlet配置的结构上，jsp Servlet与default Servlet一致，其含义也相同。这里需要强调的是url-pattern，有两个servlet-mapping中定义的两个url-pattern都对应jsp Servlet，这在web.xml中是允许的。这两个servlet-mappin*生的效果就是所有访问*.jsp和*.jspx的文件都被分发到jsp Servlet进行处理，也就是说，Tomcat中的JSP文件支持*.jsp和*.jspx两种格式。

3．session-config

session-config用于配置在Web应用中与session有关的设置，部署描述符中对于session-config的配置如下：

<session-config>

<session-timeout>30</session-timeout>

</session-config>

session-timeout用于设置session的超时时间，这里设置为30分钟。

4．mime-mapping

在部署描述符中预设了很多mime-mapping，用于将特定的文件后缀与一种MIME类型对应起来。开发人员可以通过在这里设置映射关系将Web应用中的某些文件映射为特定的MIME类型，以便客户端在接收到此类文件时可以使用适当的应用程序打开。部署描述符中对于mime-mapping的设置如下例所示：

<mime-mapping>

<extension>htm</extension>

<mime-type>text/html</mime-type>

</mime-mapping>

extension表示这种文件的后缀，mime-type表示将这种文件映射为MIME类型，该例将htm文件映射为text/html类型。

5．welcome-file-list

welcome-file-list定义了欢迎文件列表，即当请求URI指向一个目录时，那么就在目录中依次寻找欢迎文件列表中的文件，将找到的第一个返回。部署描述符中默认定义了三个欢迎文件：index.html、index.htm和index.jsp。

开发人员可以使用部署描述符对Web应用的许多方面进行配置，如果开发人员希望修改的配置对所有Web应用都有效，例如Session的超时时间，那么就可以直接在通用Web应用部署描述符中进行设置；如果开发人员只希望对某一个Web应用有效，例如某一个Servlet，那么就在该Web应用的特有部署描述符中进行设置。这样也简化了Web应用的配置。

• 上一节
• 本书简介
• 下一节

Tomcat中可以同时部署多个Web应用，Tomcat通过Web应用的上下文路径区分各个Web应用。将Web应用部署到Tomcat中的方法有两类：将Web应用根目录复制到webapps目录中或通过在Tomcat配置文件中添加Context元素。在Tomcat中每个Web应用都可以使用一个web.xml文件对Web应用进行配置。

• 上一节
• 本书简介
• 下一节

Servlet是Java Web开发最重要的基础技术，绝大多数Java Web开发技术都是基于Servlet基础的，所以了解Servlet技术是深入理解其他Java Web开发技术的前提。同时Servlet也是Tomcat支持的最主要技术之一。

本章将简单介绍Servlet的基本概念、原理以及使用方法。重点介绍其中主要的一些接口和对象，包括使用广泛的ServletRequest和ServletResponse，以及Servlet中的高级概念——Servlet过滤器。最后通过大量实例应用为读者分别介绍Servlet开发、ServletConfig的使用、ServletContext的使用、HttpSession的使用、Cookie的使用以及如何在应用中使用Servlet Filter。

Servlet是Java Web开发技术中最主要和最基础的技术，希望初学者能够认真学习本章的内容，并且根据所学的内容多做一些实验。

Servlet是一种可以配置进Servlet容器（如Tomcat）中用于处理客户端请求的特殊Java对象。Servlet Specification（Servlet规范）规定了Servlet对象和Servlet容器的协作方式，以及Servlet体系中相关的API；其中最关键的是Servlet接口，它规定了一个Servlet应该具有的行为；开发人员开发出符合Servlet接口的Java对象，并将其部署到Servlet容器中就可以使Servlet容器具有该Servlet实现的功能。Servlet通过配置Servlet容器被部署到Servlet容器中，多种多样的Servlet为Servlet容器添加了丰富的Web处理功能；同时也丰富了与Servlet容器相结合的Web服务器的功能。Tomcat是具有普通Web服务器功能的最典型的Servlet容器，通过配置Tomcat的配置文件可以将Servlet部署到Tomcat中。本章就将Tomcat作为默认的Servlet容器进行讲解和实验。

• 上一节
• 本书简介
• 下一节

一个Servlet就是一个Java对象，一般来讲它与其他Java对象没有本质的区别，唯一特殊的是，它的实现类必须实现Servlet体系中的javax.servlet.Servlet接口，该接口规定了程序员实现的Servlet必须满足的一种标准格式，只有满足该格式的Servlet才能被部署到 Servlet容器中。举一个形象的例子，国家规定两孔圆头插座的规格标准是227IEC42（RVB）2×0.5mm2 6A250V标准，所有厂商生产的两孔圆头插座必须符合该标准，所有生产两孔圆头插头的厂商也必须符合该标准，否则生产出来的插头和插座就无法匹配。

同样道理，Servlet容器与Servlet之间的关系也相当于插座和插头的关系，Servlet规范规定了所有的Servlet必须符合javax.servlet.Servlet接口规范，所有的Servlet容器必须使用该规范规定的格式调用Servlet，所以程序员编写的Servlet也必须符合该规范。这样，编写的Servlet被部署到Servlet容器中后Servlet容器才能够与Servlet协调工作。

插头标准可能规定了插头的大小、电流、电压等参数，Servlet接口标准则规定了Servlet类必须实现的方法。Servlet接口规定的一个最主要的方法就是Servlet的执行方法，service()方法，该方法是一个Servlet用于处理请求和响应的全部代码。任何一个实现了Servlet接口的Java类都必须实现该方法，所以Servlet容器不需要知道部署到其中的每个Servlet的具体实现，当有请求到达时，Servlet容器只需要调用该Servlet类的service()方法即可。

或者也可以反过来说，一个实现了javax.servlet.Servlet接口的Java类的对象就是一个Servlet。所以实现javax.servlet.Servlet接口与一个Java类是一个Servlet的充分必要条件。

• 上一节
• 本书简介
• 下一节

程序员在开发Servlet时，首先开发一个实现了Servlet接口的Java类，暂称其为Servlet类；然后将该Servlet类部署到Tomcat中，此时Servlet还是以Java类的形式存在，并不具有任何实例；启动Tomcat，Tomcat实例化一个该Servlet的对象并且对其进行初始化；当有客户请求指向该Servlet时，Tomcat调用该Servlet对象的执行方法对请求和响应进行处理；处理完后销毁该Servlet对象。所以一个Servlet对象的生命周期包括三个阶段：初始化阶段、执行阶段和销毁阶段。如图8.1所示。

图8.1  Servlet工作过程示意图

如图8.1所示，Servlet在被初始化后才会进入Tomcat的地址空间中响应客户端的请求，在服务结束后在适当的时机Tomcat会销毁Servlet，将Servlet从地址空间中清除。

Tomcat初始化Servlet包括两个动作：将Servlet实例化并加载到Tomcat地址空间中；调用Servlet的初始化方法对Servlet进行初始化。

【注意】

实例化和初始化是两个不同的概念。实例化是指根据Java类生成一个该类的对象，在实例化时会调用Java对象的构造方法，任意一个非抽象的Java类都可以被实例化；初始化是一个特殊的概念，并不是所有Java类都有初始化的概念，Servlet的初始化是指在从一个Servlet类实例化一个Servlet对象后再调用该Servlet对象的初始化方法对其进行初始化。可见初始化的前提必须是先实例化。所以这里提到的Tomcat对Servlet的初始化默认就包括了从Servlet类实例化一个Servlet对象。

Tomcat初始化Servlet的时机可能有三个：

启动Tomcat时：在前面介绍web.xml文件配置时，介绍了在配置Servlet时有一个load-on-startup子标签，该标签的值是一个整数值。如果某个Servlet的该标签值是0或正整数，那么该Servlet就会在Tomcat启动时被初始化，而且值越小初始化得越早；如果某个Servlet没有配置该标签或者该标签的值为负数，那么该Servlet在Tomcat启动时就不会被初始化。所以，对于所有load-on-startup子标签值为正整数的Servlet都会在Tomcat启动时被初始化。

有请求访问Servlet时：如上所述，所有load-on-startup子标签值没有配置为正整数的Servlet都不会在Tomcat启动时被初始化；它们采用的是Lazy初始化机制，就是只有当Servlet需要被使用时才初始化，也就是有请求访问Servlet时才初始化。

在Servlet所在Web应用的/WEB-INF/classes或/WEB-INF/lib目录发生变化时：在前面介绍的使用Context元素将Web应用部署到Tomcat中的方法时，介绍了Context元素有一个属性reloadable，当将该属性设置为true时，Tomcat就会监控该Web应用的/WEB-INF/classes 和 /WEB-INF/lib目录的变化，如果这两个目录发生了变化，Tomcat就会重新载入该Web应用，这时该Web应用中的所有Servlet就会被重新初始化。

Servlet被销毁的时机由Tomcat指定，Tomcat并不会在Servlet响应完请求后就立即销毁Servlet，而是选择一个适当的时机销毁Servlet，销毁Servlet时Tomcat会调用Servlet的销毁方法。通常Tomcat销毁一个Servlet的时机可能有如下几种情况：

Servlet已处理完所有请求，并且长期处在闲置状态；

Servlet已处理完所有请求，并且当前Tomcat的空间资源相对紧张，需要销毁一些Servlet释放空间；

Servlet已处理完所有请求，并且当前Servlet需要被重启。

• 上一节
• 本书简介
• 下一节

根据前面对Servlet生命周期的介绍，Servlet真正用于处理客户端请求的阶段是Servlet的执行阶段。Servlet采用Request/Response模式进行工作。如图8.1所示，在Servlet被初始化前直到处理完请求被销毁，其执行过程如下（假设Servlet在Tomcat启动时不被初始化）。

（1）在有指向Servlet的请求到达Tomcat时，Tomcat对Servlet进行实例化，并且调用Servlet的init()方法对Servlet对象进行初始化。

（2）Tomcat将客户端的请求构造成一个Request对象，同时构造一个输出指向客户端的Response对象，将Request对象和Response对象同时作为参数传递给Servlet的service()方法，并执行该方法。

（3）Servlet的service()方法解析Request对象，执行相应的操作，并且根据执行结果设置Response对象。

（4）Tomcat根据Servlet设置的Response对象，构造相应的响应消息返回给客户端。

（5）Servlet完成对请求的处理后，在适当的时候Tomcat会调用Servlet的destroy()方法将Servlet销毁。

• 上一节
• 本书简介
• 下一节

Tomcat中可以配置若干个主机，一个主机可以配置若干个Web应用，一个Web应用中又可以配置若干个Servlet。那当有请求到达Tomcat时，Tomcat如何判断请求所要访问的Servlet呢？每个请求都有其所访问资源的URL，URL是全局资源定位符，用于说明请求所访问资源的位置，而且一个URL在同一时刻所指向的网络资源位置也是唯一的。Tomcat根据请求的URL确定请求所访问的Servlet。

根据Tomcat的层次结构：Server → Service → Host → Context → Servlet，请求在到达Tomcat后首先根据请求的主机名（域名）被分发到某个Host；再根据请求URI以及Host中各Context（Web应用）的上下文路径被分发到某个Web应用；最后将请求URI与Web应用中所有Servlet的URL Pattern进行匹配，匹配成功的Servlet将处理该请求。主机的主机名在Tomcat的server.xml文件中设置（Host标签表示一个主机）。Web应用上下文路径在Context标签中配置（webapps路径下的Web应用的上下文路径就是Web应用的根目录名），Context标签的path属性表示该应用的上下文路径，Context标签的配置信息可能存在于多个位置（参见7.2.2节）。Servlet在Web应用部署描述符web.xml文件中通过servlet标签和servlet-mapping标签配置，这里的Web应用部署描述符包括Tomcat的通用部署描述符和各个Web应用中的特有部署描述符。

Tomcat在启动时，Tomcat分别读取和解析server.xml文件、各个Context描述文件和各个web.xml文件，获取其中关于Host、Context和Servlet的配置信息，构建一个从Host到Servlet的树形结构，并将其保存在Tomcat的内存空间中。当有新请求到达Tomcat时，Tomcat解析请求的URL根据URL的格式将请求从该树顶端以级分发到Servlet。

一种配置情况的示例如图8.2所示。

如图8.2的示例所示，Tomcat中配置了两个Host：localhost和csai.cn；localhost中配置了两个Web应用：user-manage和book；user-manage和book中又分别定义了三个Servlet，每个Servlet的URL Pattern如图中所示。针对该例的配置情况，考虑具有如下几个URL请求的分发情况。

（1）http://localhost/user-manage/login/setup

首先根据域名localhost将请求分发到localhost主机，然后将请求URI“/user-manage/login/setup”与主机中所有Web应用的上下文路径进行匹配，该URI与上下文路径为user-manage的Web应用匹配成功，然后将相对路径“/login/setup”与user-manage中所有Servlet的URL Pattern进行匹配，与“/login/*”匹配成功，所以该请求将由URL Pattern为“/login/*”的Servlet处理。

（2）http://localhost/book/store/query.do?id=12432

主机和Web应用上下文路径的匹配情况类似于上例，但特殊的是该例中包含了查询参数。没关系，在匹配时可以不用管查询参数，直接忽略就可以了。所以很明确，该请求被分发到book中的“*.do”Servlet。

（3）http://localhost/book/buy

根据域名和Web应用可以将该请求分发到localhost的book应用，但是该应用的所有模板都无法与相对路径“/buy”相匹配。在这种情况下，请求会被分发给default Servlet处理。default Servlet是每个Web应用都有的一个比较特殊的Servlet，它的URL Pattern是“/”，这是由Tomcat默认提供的web.xml中配置的。

（4）http://localhost/webpage/setup.html

根据域名可以将该请求分发到localhost主机，但localhost中并不存在名为webpage的Web应用。对于这种情况，Tomcat将该请求分发到localhost主机的默认应用。在${TOMCAT_HOME}/webapps/目录中有一个特殊的目录ROOT，该目录表示了一个localhost的默认应用，当请求URI无法与任何Web应用的上下文路径相匹配时就会被分发到该应用。由于该应用默认并没有配置任何Servlet，所以该请求最终还是被分发到default Servlet。

default Servlet是Tomcat自带的一个用于处理静态文件请求的Servlet。由于default Servlet的URL Pattern是“/”，它可以匹配任何相对路径，所以如果某个请求的URL无法与任何其他Servlet的URL Pattern相匹配时，请求就会被分发到default Servlet。default Servlet将分发到它的请求都作为静态文件请求处理，例如上面第三个URL被分发到default Servlet中后，default Servlet就会认为该请求是想请求book应用根目录下面的buy文件，假如book应用根目录下不存在buy文件，Tomcat就会返回一个错误，指示请求的资源不存在；如上面第四个URL，default Servlet会认为该请求是想请求ROOT目录下webpage目录中的setup.html文件，如果ROOT目录下存在webpage目录，并且webpage目录中存在setup.html文件，那么该文件将被返回，否则Tomcat会返回一个错误，指示请求的资源不存在。

在上面的例子中，读者已经发现在URL Pattern中可以用*代表任意字符，很多读者肯定会很快将这个模式与正则表达式联系起来。但可惜的是URL Pattern并不支持使用正则表达式描述。实质上，在Servlet规范中已经对URL Pattern的写法、意义以及当有多个URL Pattern时匹配次序的选择都是有明确规定的。在Servlet规范中定义了URL Pattern支持的四种格式：

（1）以“/”开头和以“/*”结尾：这种模式用于匹配一个路径前缀，比如“/login/*”可以匹配“/login/aaa”、“/login/bb/a.html”和“/login/cc/dd/q?x=5”等。

（2）以前缀“*.”开始：这种模式用于匹配以一种后缀结束的路径，比如“*.do”可以匹配“/aaa.do”、“/bb/cc/d.do”和“/bb/cc/q.do?x=5”等。

（3）字符“/”：这种模式只用来表示default Servlet。

（4）一个以“/”开头的字符串，并且不符合以上的任何一种格式：除了上面三种格式以外，其他格式都被用于精确匹配。比如“/register”只被用于匹配路径“/register”，而无法匹配“/register/default”；即使形如“/register/*.do”也只能匹配路径“/register/*.do”，而无法匹配“/register/start.do”。

除了以上规定的四类URL Pattern，其他格式都会被认为是非法格式，如果Tomcat在启动时探测到非法格式，Tomcat会在启动窗口中打印错误。

如果在一个Web应用中，这几类URL Pattern都存在，那么Tomcat会按照一定的优先顺序逐个匹配，即使有一个相对路径同时与多个URL Pattern相匹配，Tomcat也会选择优先顺序在先的Servlet处理请求。顺序如下：

首先Tomcat会从精确匹配模式（以上第4）类模式）中寻找是否有相匹配的模式。比如分别有模式“/aa”、“/aa/bb”和“/aa/*”，对于相对路径为“/aa/bb”的请求就会与模式“/aa/bb”相匹配；

如果没有匹配成功则从属于以上第（1）类模式的各种URL Pattern中寻找相匹配的模式。比如分别有模式“/aa”、“/aa/bb”和“/aa/*”，对于相对路径为“/aa/bb/cc”的请求就会与模式“/aa/*”相匹配。而且，假如这种匹配是最长匹配原则，比如分别有模式“/aa/*”和“/aa/bb/*”，对于相对路径为“/aa/bb/cc”的请求会与模式“/aa/bb/*”相匹配；

如果没有匹配成功则从属于以上第（2）类模式的各种URL Pattern中寻找相匹配的模式。比如分别有模式“/aa”、“/aa/bb”、“/aa/*”和“*.do”，对于相对路径为“/bb/cc.do”的请求就会与模式“*.do”相匹配；

如果以上各类模式都没有匹配成功，那么就会与“/”匹配成功，并最终由default Servlet处理。

• 上一节
• 本书简介
• 下一节

作者一直认为，学习编程最主要的是实践。在学习的过程中，不断构造适当代码并进行不断实验是最好的学习过程。学习Servlet也一样。在开始学习之前，读者先搭建好实验环境，在学习过程中可以将实例直接放进测试环境中测试。

本书中将Eclipse作为Servlet的开发环境，将Tomcat作为Servlet的运行环境。前面已经介绍了Eclipse和Tomcat的配置和使用，本节将介绍如何构建Servlet工程，并且将实现一个Servlet的Hello World工程、将该工程部署到Tomcat中、以及运行测试该Servlet。

1．新建工程

新建一个能够开发和测试Servlet的工程——ServletTest。在介绍Eclipse的使用时已经提到，用于开发Servlet应用的工程应该是动态Web工程。根据前面介绍的新建动态Web工程的步骤在Eclipse中新建一个动态Web工程ServletTest，建成的ServletTest工程在工程浏览视图中的内容如图8.3所示：

图8.3  新建ServletTest工程

新建的Web工程搭建了一个动态Web工程的基本架构，但是没有定义任何具有实质功能的内容。

2．编辑Servlet

工程建好后就可以直接新建待开发的Servlet。根据第5章中介绍的步骤新建一个TestServlet，所属的包为cn.csai.web.servlet。Eclipse为TestServlet自动生成的初始内容如下：

package cn.csai.web.servlet;

import java.io.IOException;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

public class TestServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {

static final long serialVersionUID = 1L;

public TestServlet() {

super();

}

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

}

}

其中自动生成的方法中，除了默认构造方法外还有两个重要的方法doGet()和doPost()，这是大部分Servlet都会覆盖的方法。doGet()用于处理客户端的GET请求，doPost()用于处理客户端的POST。也就是说，当客户端使用GET方法的HTTP消息访问Servlet时，Servlet就将请求和响应传递给doGet()方法，由doGet()方法处理请求和响应；当客户端使用POST方法的HTTP消息访问Servlet时，Servlet就将请求和响应传递给doPost()方法，由doPost()方法处理请求和响应。

这两个方法的方法体中初始没有任何内容，程序员就将自己的代码添加到方法体中，所谓Servlet的不同主要也就是这两个方法的方法体有所不同。对于Hello World应用，读者可以在doGet()方法中添加输出“Hello World”的语句。将如下所示的HelloWorld代码体添加到doGet()方法中：

PrintWriter pw = response.getWriter();

pw.write("Hello World");

pw.flush();

pw.close();

这段代码从response对象获得一个Writer对象，然后利用Writer对象向客户端输出一个“Hello World”字符串，最后刷新和关闭Writer对象。所以这段代码的作用就是向客户端浏览器输出一个“Hello World”字符串。

Servlet需要被添加到Web应用中才能进行工作。使用Eclipse向导新建Servlet时，Eclipse已经自动将Servlet的配置信息写入到应用的web.xml文件中（参见第5章）。web.xml文件的内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www. w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/ j2ee http://java.sun.com /xml/ns/j2ee/web-app_2_4.xsd">

<display-name>

ServletTest</display-name>

<servlet>

<description>

</description>

<display-name>

TestServlet</display-name>

<servlet-name>TestServlet</servlet-name>

<servlet-class>

cn.csai.web.servlet.TestServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>TestServlet</servlet-name>

<url-pattern>/TestServlet</url-pattern>

</servlet-mapping>

<welcome-file-list>

<welcome-file>index.html</welcome-file>

<welcome-file>index.htm</welcome-file>

<welcome-file>index.jsp</welcome-file>

<welcome-file>default.html</welcome-file>

<welcome-file>default.htm</welcome-file>

<welcome-file>default.jsp</welcome-file>

</welcome-file-list>

</web-app>

3．部署Web应用

新建的工程必须被部署到Tomcat中才能够通过Tomcat测试，将Web工程部署到Tomcat中包括以下步骤：

（1）新建适用于Tomcat的Web应用：在${TOMCAT_HOME}/webapps目录下新建ServletTest目录；

（2）将Web工程的所有class文件和WEB-INF目录复制到Tomcat Web工程的适当目录中：打开ServletTest工程在文件系统中的目录（记为${ECLIPSE_PROJECTS}），将WebContent子目录中的WEB-INF目录整个复制到${TOMCAT_HOME}/webapps/ServletTest目录中；再将${ECLIPSE_ PROJECTS}/ServletTest/build中的classes目录复制到${TOMCAT_HOME}/webapps/ ServletTest/WEB- INF目录中；

（3）重新启动Tomcat。

4．运行Servlet

运行Servlet是相对比较容易的。在将Web工程部署到Tomcat中后，确保Tomcat已正常启动。然后打开浏览器，键入如下URL便会看到TestServlet的执行结果，如图8.4所示。

http://localhost:8080/ServletTest/TestServlet

图8.4  运行TestServlet

以上展示了新建、编辑、部署和运行Servlet工程和Servlet的步骤，读者在今后的学习中可以将该ServletTest工程作为测试环境，不断地修改TestServlet的doGet()方法和doPost()，以用于测试学到的新内容，而不需要重新建立新的工程和新的Servlet。步骤如下：

（1）在Eclipse中修改TestServlet的内容，保存并编译；

（2）删除${TOMCAT_HOME}/webapps/ServletTest/WEB-INF目录中的classes目录，将${TOMCAT_ HOME}/webapps/ServletTest/WEB-INF目录中的classes目录复制到${TOMCAT_HOME} /webapps/ ServletTest/WEB-INF目录中；

（3）重启Tomcat；

（4）输入URL测试。

• 上一节
• 本书简介
• 下一节

在面向对象的系统中，理解系统的第一步首先需要理解系统中的一些关键概念，这些概念以及概念之间的关系构筑了系统的基础框架。对概念的理解有助于把握系统的结构。

在面向对象的系统中，通常一个类就表示了一个具体的概念，但是在设计比较完善的系统中通常会将重要和稳定的概念用接口表示，这种设计方法在JDK中随处可见。在Java Servlet体系中也不例外，其中一些关键的概念都被定义成相应的接口，然后再用一些具体类提供对这些接口的实现。

Java Servlet中定义了如下几个关键接口。

• 上一节
• 本书简介
• 下一节

Servlet接口代表一个Servlet。这在介绍Servlet的概念时已经做了阐述。service()方法是Servlet接口最核心的方法，但Servlet接口并不仅仅定义了这一个方法，Servlet接口的定义如下：

package javax.servlet;

import java.io.IOException;

public interface Servlet

{

public abstract void init(ServletConfig servletconfig)

throws ServletException;

public abstract ServletConfig getServletConfig();

public abstract void service(ServletRequest servletrequest, ServletResponse servletresponse) throws ServletException, IOException;

public abstract String getServletInfo();

public abstract void destroy();

}

其中：

init()：该方法对应Servlet生命周期的初始化阶段，它在Tomcat初始Servlet时被调用。实质上，所谓Tomcat对Servlet初始化就是Tomcat调用Servlet的init()方法。该方法提供了一个ServletConfig作为参数，这是为了便于Servlet开发者能够在init()方法中获得关于Servlet的配置信息，该参数在Tomcat调用init()方法时由Tomcat提供，Tomcat可以通过调用getServletConfig()方法获得。同时，在初始化时还允许抛出ServletException，即开发人员在编写init()方法时可以将未处理的异常情况抛出为ServletException；

service()：该方法对应于Servlet生命周期的执行阶段，在该Servlet的请求到达时被调用，任何到达该Servlet的请求都会执行这同一段代码，只是不同请求的输入参数不同；输入参数ServletRequest代表到达Servlet的请求，ServletResponse代表Servlet对请求的响应，Tomcat构造一个到客户端的ServletResponse对象并将其传给service()方法，方法在执行期间对该ServletResponse进行设置和操作，service()方法执行完后Servlet也就完成了对客户端的响应。该方法不仅可以抛出ServletException异常还可以抛出IOException，那是因为service()方法中经常会通过ServletResponse对象向客户端传输响应数据，在这个过程中可能会发生输入输出错误；

destroy()：该方法对应于Servlet生命周期的销毁阶段，在Servlet执行结束后Tomcat可以适时地将其销毁，在Servlet被销毁时Tomcat会调用该方法。通常该方法中可以进行诸如释放资源等一些收尾工作；

getServletConfig()：返回与该Servlet相关的ServletConfig对象；

getServletInfo()：返回该Servlet的描述，通常该描述信息是Servlet实现者提供的用于描述Servlet的信息。

【注意】

由于Servlet基本上都被用于处理HTTP请求和响应，所以需要程序员就将Servlet等同于处理HTTP请求和响应的HttpServlet，但实际上Servlet接口所表示的是一种普遍概念的Servlet，它不仅表示处理HTTP请求和响应的HttpServlet，也可以用于表示处理其他通用请求和响应的Servlet。同样ServletRequest和ServletResponse不能将其狭义理解为HTTP请求和HTTP响应。

• 上一节
• 本书简介
• 下一节

ServletConfig接口代表对一个Servlet的配置信息，对应于web.xml中对该Servlet的配置项，如下是web.xml中default Servlet的配置信息：

<servlet>

<servlet-name>default</servlet-name>

<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>

<init-param>

<param-name>debug</param-name>

<param-value>0</param-value>

</init-param>

<init-param>

<param-name>listings</param-name>

<param-value>false</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>default</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

ServletConfig接口表示了一个Servlet的配置信息，在一个Servlet中可以通过ServletConfig接口的对象获得Servlet的这些配置信息。

ServletConfig接口的定义如下：

package javax.servlet;

import java.util.Enumeration;

public interface ServletConfig

{

public abstract String getServletName();

public abstract ServletContext getServletContext();

public abstract String getInitParameter(String s);

public abstract Enumeration getInitParameterNames();

}

其中：

getServletName()：该方法获得该Servlet的名称，对应于web.xml中该Servlet的servlet-name标签的内容，例如default；

getServletContext()：该方法返回该ServletConfig对象对应的ServletContext对象；

getInitParameter()：该方法返回具有指定名称的初始参数的值。对应于Servlet的配置中，通过init-param标签定义的Servlet初始化参数，param-name是参数名，param-value是参数值。getInitParameter()方法可以通过参数名获得参数值，例如getInitParameter（“debug”）→ 0；

getInitParameterNames ()：该方法返回一个Enumeration类型的对象，该对象中包含了该Servlet定义的所有初始化参数的参数名。

• 上一节
• 本书简介
• 下一节

ServletContext接口代表了Servlet所运行的上下文信息，定义了一个Servlet环境对象。Tomcat在加载Web应用时，为每个Web应用创建唯一的ServletContext对象，Web应用中的Servlet通过该ServletContext对象与Servlet容器进行通信。定义如下：

package javax.servlet;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.Enumeration;

import java.util.Set;

public interface ServletContext

{

public abstract ServletContext getContext(String s);

public abstract int getMajorVersion();

public abstract int getMinorVersion();

public abstract String getMimeType(String s);

public abstract Set getResourcePaths(String s);

public abstract URL getResource(String s) throws MalformedURLException;

public abstract InputStream getResourceAsStream(String s);

public abstract RequestDispatcher getRequestDispatcher(String s);

public abstract RequestDispatcher getNamedDispatcher(String s);

public abstract Servlet getServlet(String s) throws ServletException;

public abstract Enumeration getServlets();

public abstract Enumeration getServletNames();

public abstract void log(String s);

public abstract void log(Exception exception, String s);

public abstract void log(String s, Throwable throwable);

public abstract String getRealPath(String s);

public abstract String getServerInfo();

public abstract String getInitParameter(String s);

public abstract Enumeration getInitParameterNames();

public abstract Object getAttribute(String s);

public abstract Enumeration getAttributeNames();

public abstract void setAttribute(String s, Object obj);

public abstract void removeAttribute(String s);

public abstract String getServletContextName();

}

其中：

getContext（String s）：该方法通过提供URI获得Server上其他ServletContext对象。参数是一个以“/”开始的字符串，表示相对于Server根路径的相对路径；

getMajorVersion()：返回该Servlet容器支持的Servlet规范的主版本号；

getMinorVersion()：返回该Servlet容器支持的Servlet规范的次版本号；

getMimeType（String s）：根据提供的文件类型返回该文件类型对应的MIME类型；

getResourcePaths（String s）：根据提供的子路径返回Web应用中的该子路径下的所有一级资源；例如Web应用中有如下文件：

/index.html

/images/bg.jpg

/WEB-INF/web.xml

/WEB-INF/lib/my.lib

那么：

getResourcePaths（“/”）将返回“/index.html”、“/images/”和“/WEB-INF/”；

getResourcePaths（“/WEB-INF”）将返回“/WEB-INF/web.xml”和“/WEB-INF/lib/”。

getResource（String s）：根据给定的路径返回表示路径所指向资源的URL对象，提供的路径必须以“/”开头，表示以Web应用根路径计算的相对路径；

getResourceAsStream（String s）：将给定路径所指向资源作为InputStream的对象返回。路径的格式和意义同getResource()方法；

getRequestDispatcher（String s）：返回一个到给定路径所指向资源的RequestDispatcher对象。RequestDispatcher对象可以用于将请求转到资源或者将资源包含到响应中；

getNamedDispatcher（String s）：返回一个到给定Servlet的RequestDispatcher对象，参数为Servlet名称；

getServlet（String s）：已过时。返回名称为给定参数的Servlet对象；

getServlets()：已过时。返回一个Enumeration，包含该ServletContext中所有的Servlet对象；

getServletNames()：已过时。返回一个Enumeration，包含该ServletContext中所有Servlet的名称；

log（String s）：记录日志，将参数字符串记录到日志文件中；

log（Exception exception，String s）：记录日志，将给定Exception对象的stack trace和给定字符串所表示的解释字符串记录到日志文件中；

log（String s, Throwable throwable）：将给定的解释字符串和给定Throwable对象的stack trace记录到日志文件中；

getRealPath（String s）：返回给定路径所指向资源在文件系统中的绝对路径。路径的表现方式取决于Servlet容器所运行的操作系统；

getServerInfo()：返回所运行的Servlet容器的名称版本号，输出格式为server-name/server-version；

getInitParameter（String s）：返回给定具有给定名称的初始化参数的值，假如不存在给定名称的初始化参数则返回null；

getInitParameterNames()：返回一个Enumeration对象，包含所有初始化参数的名称；

getAttribute（String s）：Servlet容器可能为Servlet还提供了除该接口定义的属性以外的其他属性，该方法提供了一个扩展方法允许Servlet容器为Servlet提供其他可访问的属性。该方法根据属性名返回属性值，属性值可以是任何Object对象或其子对象；

getAttributeNames()：返回一个Enumeration对象，包含Servlet容器提供的所有属性的名称；

setAttribute（String s, Object obj）：在该ServletContext中设置属性名/值对，如果设置的属性名已经存在则用新值替换旧值，如果设置的属性值为null，则删除该属性；

removeAttribute（String s）：在该ServletContext中删除具有给定名称的属性；

getServletContextName()：在配置Web应用的web.xml时，可以通过display-name指定Web应用的名称，该方法返回配置的该名称。

• 上一节
• 本书简介
• 下一节

RequestDispatcher接口表示一个请求转发器，它接收客户端的请求并把请求转发到任何Web资源，可以是：Servlet、JSP、HTML等。

定义如下：

package javax.servlet;

import java.io.IOException;

public interface RequestDispatcher {

void forward(ServletRequest arg0, ServletResponse arg1) throws ServletException, IOException;

void include(ServletRequest arg0, ServletResponse arg1) throws ServletException, IOException;

}

其中：

forward()：将请求从一个Servlet转发到Server上的任何其他Web资源。该方法的出现允许一个Servlet对请求进行预处理，然后在响应消息发出前将请求转发给另一个Web资源，由另一个Web资源完成对请求的响应；

include()：将资源的内容包含到响应消息中。

• 上一节
• 本书简介
• 下一节

在Servlet接口、ServletConfig接口和ServletContext接口的方法中，虽然使用Servlet的getServletConfig()可以获得一个ServletConfig接口的对象，再通过ServletConfig接口的getServletContext()方法可以获得一个ServletContext接口的对象，但是这几个接口所表示的概念并不具有类似的层叠关系。

这几个接口分别属于不同的层面，ServletContext处于最高层，Servlet和ServletConfig属于同一层，在下层。每个Web应用有一个ServletContext对象，每个Servlet有一个ServletConfig对象，所以当一个Web应用中有多个Servlet时，从多个Servlet中获得的ServletContext对象是同一个，就是它们所在的Web应用的ServletContext对象。其关系如图8.5所示。

图8.5  Servlet、ServletConfig和ServletContext关系图

从各个概念所定义的方法也可以看出这种区别，ServletConfig中的方法可以用来获取单个Servlet相关的配置信息，而ServletContext中的方法可以用来获取Web应用或者Servlet容器相关的配置信息，这也是该接口被命名为ServletContext的原因，因为它代表了Servlet所运行环境的信息。RequestDispatcher接口与这几个概念之间没有明确的层次关系，它仅代表一个请求转发器。

除了这几个关键概念外，还有两个接口所表达的概念也非常重要，它们是ServletRequest和ServletResponse，这两个接口分别表示Servlet的请求和Servlet返回给客户端的响应。它们被广泛应用于Servlet的各个处理场合和概念中。这两个概念将在本章的后续小节中介绍。

• 上一节
• 本书简介
• 下一节

接口只表示一个概念，接口及其之间的关系构筑了系统的概念体系，这是抽象层面。在具体层面，所有的概念都由具体的类实现，继承自同一接口的不同类体现了这种概念的侧面或者不同子类。

在Servlet体系中实现了Servlet接口的最主要的类是GenericServlet类和HttpServlet类，它们的类继承层次关系如图8.6所示。

图8.6  GenericServlet和HttpServlet类的继承层次图

• 上一节
• 本书简介
• 下一节

GenericServlet实现了Servlet接口和ServletConfig接口，它表示一种通用的Servlet可代表处理各种类型请求的Servlet；它只是抽象类，不能直接用于处理Servlet请求，所以只能通过实现继承自GenericServlet的子类来完成处理特定请求的功能。值得注意的是，GenericServlet类不仅实现了Servlet接口，而且还实现了ServletConfig接口，所以GenericServlet类还包含了对Servlet配置信息的操作。

GenericServlet对Servlet接口和ServletConfig接口的实现只是一种最简单的默认实现，实质上并不具备实际意义，GenericServlet存在的意义就是用来被其他类继承的。GenericServlet的定义如下：

package javax.servlet;

import java.io.IOException;

import java.io.Serializable;

import java.util.Enumeration;

public abstract class GenericServlet

implements Servlet, ServletConfig, Serializable

{

private transient ServletConfig config;

public GenericServlet()

{

}

public void init(ServletConfig config) throws ServletException

{

this.config = config;

init();

}

public void init() throws ServletException

{

}

public abstract void service(ServletRequest servletrequest, ServletResponse servletresponse) throws ServletException, IOException;

public void destroy()

{

}

public ServletConfig getServletConfig()

{

return config;

}

public String getServletInfo()

{

return "";

}

public String getServletName()

{

return config.getServletName();

}

public String getInitParameter(String name)

{

return getServletConfig().getInitParameter(name);

}

public Enumeration getInitParameterNames()

{

return getServletConfig().getInitParameterNames();

}

public ServletContext getServletContext()

{

return getServletConfig().getServletContext();

}

public void log(String msg)

{

getServletContext().log((new StringBuilder()).append(getServletName()).append(":").append(msg). toString());

}

public void log(String message, Throwable t)

{

getServletContext().log((new StringBuilder()).append(getServletName()).append(":").append(message).toString(), t);

}

}

从代码中可以发现，GenericServlet定义了一个ServletConfig对象的私有成员，并将从init(ServletConfig config)方法中传入的ServletConfig对象做了封装，然后增加了一个不带任何参数的init()方法供子类继承，这样可以简化子类的实现；对于init()、destroy()、getServletConfig()和getServletInfo()方法提供了实现，但是没有在方法体中提供任何实质性内容，这实际上只是搭建了一个Servlet的框架供子类使用，子类只需要覆盖其关心的方法即可；对于service()方法，GenericServlet将其定义为抽象方法，没有提供默认实现，因为service()方法是一个Servlet的核心处理代码，也是一个Servlet区别于其他Servlet的关键部分，所以GenericServlet将其定义为抽象方法，强制其具体子类提供该方法的具体实现。

对于ServletConfig接口的几个方法，GenericServlet也提供了最简单的实现。从代码体中可以发现，这种实现实际上只是对其封装的config的接口的一种调用，所以这种实现并没有实质作用，具体所执行的工作只能由交给传递进来的实现了ServletConfig接口的类来实现。

除此之外，GenericServlet类提供了两个log()方法，它们利用ServletContext对象的log()方法提供日志功能，它们虽然也没有实现任何实质内容，但是它们提供了一个进行日志工作的方便途径。

总而言之，GenericServlet类是一个抽象类，虽然只有一个抽象方法，但是它实现的其他方法都只仅仅提供了最基本的、无实质内容的实现，所以GenericServlet只能作为一种Servlet的父类进行继承，而且在子类中还应该将关心的相关方法进行覆盖，并提供相应实现。

• 上一节
• 本书简介
• 下一节

HttpServlet类是GenericServlet类的子类，它比GenericServlet类所涵盖的范围要小得多，它仅表示处理HTTP请求/响应的Servlet。但是同GenericServlet一样，HttpServlet也是一个抽象类，它覆盖了GenericServlet的一些方法，而且对GenericServlet的service()方法提供了实现。HttpServlet的实现如下：

package javax.servlet.http;

import java.io.IOException;

import java.io.Serializable;

import java.lang.reflect.Method;

import java.text.MessageFormat;

import java.util.Enumeration;

import java.util.ResourceBundle;

import javax.servlet.*;

public abstract class HttpServlet extends GenericServlet

implements Serializable

{

public HttpServlet()

{

}

protected void doGet(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

String protocol = req.getProtocol();

String msg = lStrings.getString("http.method_get_not_supported");

if(protocol.endsWith("1.1"))

resp.sendError(405, msg);

else

resp.sendError(400, msg);

}

protected long getLastModified(HttpServletRequest req)

{

return -1L;

}

protected void doHead(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

NoBodyResponse response = new NoBodyResponse(resp);

doGet(req, response);

response.setContentLength();

}

protected void doPost(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

String protocol = req.getProtocol();

String msg = lStrings.getString("http.method_post_not_supported");

if(protocol.endsWith("1.1"))

resp.sendError(405, msg);

else

resp.sendError(400, msg);

}

protected void doPut(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

String protocol = req.getProtocol();

String msg = lStrings.getString("http.method_put_not_supported");

if(protocol.endsWith("1.1"))

resp.sendError(405, msg);

else

resp.sendError(400, msg);

}

protected void doDelete(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

String protocol = req.getProtocol();

String msg = lStrings.getString("http.method_delete_not_supported");

if(protocol.endsWith("1.1"))

resp.sendError(405, msg);

else

resp.sendError(400, msg);

}

private static Method[] getAllDeclaredMethods(Class c)

{

if(c.equals(javax/servlet/http/HttpServlet))

return null;

Method parentMethods[] = getAllDeclaredMethods(c.getSuperclass());

Method thisMethods[] = c.getDeclaredMethods();

if(parentMethods != null && parentMethods.length > 0)

{

Method allMethods[] = new Method[parentMethods.length + thisMethods.length];

System.arraycopy(parentMethods, 0, allMethods, 0, parentMethods.length);

System.arraycopy(thisMethods, 0, allMethods, parentMethods.length, thisMethods.length);

thisMethods = allMethods;

}

return thisMethods;

}

protected void doOptions(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

Method methods[] = getAllDeclaredMethods(getClass());

boolean ALLOW_GET = false;

boolean ALLOW_HEAD = false;

boolean ALLOW_POST = false;

boolean ALLOW_PUT = false;

boolean ALLOW_DELETE = false;

boolean ALLOW_TRACE = true;

boolean ALLOW_OPTIONS = true;

for(int i = 0; i < methods.length; i++)

{

Method m = methods[i];

if(m.getName().equals("doGet"))

{

ALLOW_GET = true;

ALLOW_HEAD = true;

}

if(m.getName().equals("doPost"))

ALLOW_POST = true;

if(m.getName().equals("doPut"))

ALLOW_PUT = true;

if(m.getName().equals("doDelete"))

ALLOW_DELETE = true;

}

String allow = null;

if(ALLOW_GET && allow == null)

allow = "GET";

if(ALLOW_HEAD)

if(allow == null)

allow = "HEAD";

else

allow = (new StringBuilder()).append(allow).append(", HEAD").toString();

if(ALLOW_POST)

if(allow == null)

allow = "POST";

else

allow = (new StringBuilder()).append(allow).append(", POST").toString();

if(ALLOW_PUT)

if(allow == null)

allow = "PUT";

else

allow = (new StringBuilder()).append(allow).append(", PUT").toString();

if(ALLOW_DELETE)

if(allow == null)

allow = "DELETE";

else

allow = (new StringBuilder()).append(allow).append(", DELETE").toString();

if(ALLOW_TRACE)

if(allow == null)

allow = "TRACE";

else

allow = (new StringBuilder()).append(allow).append(", TRACE").toString();

if(ALLOW_OPTIONS)

if(allow == null)

allow = "OPTIONS";

else

allow = (new StringBuilder()).append(allow).append(", OPTIONS").toString();

resp.setHeader("Allow", allow);

}

protected void doTrace(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

String CRLF = "\r\n";

String responseString = (new StringBuilder()).append("TRACE ").append(req.getRequestURI()). append(" ").append(req.getProtocol()).toString();

for(Enumeration reqHeaderEnum = req.getHeaderNames(); reqHeaderEnum.hasMoreElements();)

{

String headerName = (String)reqHeaderEnum.nextElement();

responseString = (new StringBuilder()).append(responseString).append(CRLF).append(header Name).append(": ").append(req.getHeader(headerName)).toString();

}

responseString = (new StringBuilder()).append(responseString).append(CRLF).toString();

int responseLength = responseString.length();

resp.setContentType("message/http");

resp.setContentLength(responseLength);

ServletOutputStream out = resp.getOutputStream();

out.print(responseString);

out.close();

}

protected void service(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException

{

String method = req.getMethod();

if(method.equals("GET"))

{

long lastModified = getLastModified(req);

if(lastModified == -1L)

{

doGet(req, resp);

} else

{

long ifModifiedSince = req.getDateHeader("If-Modified-Since");

if(ifModifiedSince < (lastModified / 1000L) * 1000L)

{

maybeSetLastModified(resp, lastModified);

doGet(req, resp);

} else

{

resp.setStatus(304);

}

}

} else if(method.equals("HEAD"))

{

long lastModified = getLastModified(req);

maybeSetLastModified(resp, lastModified);

doHead(req, resp);

} else if(method.equals("POST"))

doPost(req, resp);

else if(method.equals("PUT"))

doPut(req, resp);

else if(method.equals("DELETE"))

doDelete(req, resp);

else if(method.equals("OPTIONS"))

doOptions(req, resp);

else if(method.equals("TRACE"))

{

doTrace(req, resp);

} else

{

String errMsg = lStrings.getString("http.method_not_implemented");

Object errArgs[] = new Object[1];

errArgs[0] = method;

errMsg = MessageFormat.format(errMsg, errArgs);

resp.sendError(501, errMsg);

}

}

private void maybeSetLastModified(HttpServletResponse resp, long lastModified)

{

if(resp.containsHeader("Last-Modified"))

return;

if(lastModified >= 0L)

resp.setDateHeader("Last-Modified", lastModified);

}

public void service(ServletRequest req, ServletResponse res)

throws ServletException, IOException

{

HttpServletRequest request;

HttpServletResponse response;

try

{

request = (HttpServletRequest)req;

response = (HttpServletResponse)res;

}

catch(ClassCastException e)

{

throw new ServletException("non-HTTP request or response");

}

service(request, response);

}

private static final String METHOD_DELETE = "DELETE";

private static final String METHOD_HEAD = "HEAD";

private static final String METHOD_GET = "GET";

private static final String METHOD_OPTIONS = "OPTIONS";

private static final String METHOD_POST = "POST";

private static final String METHOD_PUT = "PUT";

private static final String METHOD_TRACE = "TRACE";

private static final String HEADER_IFMODSINCE = "If-Modified-Since";

private static final String HEADER_LASTMOD = "Last-Modified";

private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";

private static ResourceBundle lStrings =

ResourceBundle.getBundle("javax.servlet.http.LocalStrings");

}

其中所定义的方法及其含义如下。

public void service（ServletRequest req, ServletResponse res）throws ServletException, IOException：该方法是对GenericServlet的抽象方法service（ServletRequest req, ServletResponse res）的实现。由于所有到达HttpServlet的请求都是HTTP请求，而且对HTTP请求的响应也都是HTTP响应，所以在该方法中分别将参数req和res造型成HttpServletRequest和HttpServletResponse；并且用造型后的参数调用service（HttpServletRequest req, HttpServletResponse res）方法。

protected void service（HttpServletRequest req, HttpServletResponse resp）throws ServletException, IOException：与上一个service()方法不同的是上一个方法只是为了提供对抽象方法的实现，而这个方法实质上是提供对HTTP请求的处理，所有对上一个方法的调用都会被传递到该方法；该方法会对req参数进行分析，根据HTTP请求消息的方法是GET、HEAD、POST、PUT、DELETE、OPTIONS或TRACE分别调用方法doGet()、doHead()、doPost()、doPut()、doDelete()、doOptions()、doTrace()对请求进行处理。

protected void doGet（HttpServletRequest req, HttpServletResponse resp） throws ServletException, IOException：提供对GET方法HTTP请求的处理。

protected void doHead（HttpServletRequest req, HttpServletResponse resp） throws ServletException, IOException：提供对HEAD方法HTTP请求的处理。

protected void doPost（HttpServletRequest req, HttpServletResponse resp）throws ServletException, IOException：提供对POST方法HTTP请求的处理。

protected void doPut（HttpServletRequest req, HttpServletResponse resp）throws ServletException, IOException：提供对PUT方法HTTP请求的处理。

protected void doDelete（HttpServletRequest req, HttpServletResponse resp）throws ServletException, IOException：提供对DELETE方法HTTP请求的处理。

protected void doOptions（HttpServletRequest req, HttpServletResponse resp）throws ServletException, IOException：提供对OPTIONS方法HTTP请求的处理。

protected void doTrace（HttpServletRequest req, HttpServletResponse resp） throws ServletException, IOException：提供对TRACE方法HTTP请求的处理。

protected long getLastModified（HttpServletRequest req）：返回对HTTP请求的最后修改时间。

虽然该类中没有定义任何抽象方法，但是由于该类也是抽象类，所以也只能被继承，而无法直接实例化。通常在实现HttpServlet的子类时，不需要覆盖HttpServlet对service（ServletRequest req, ServletResponse res）方法、service（HttpServletRequest req, HttpServletResponse res）方法、doOptions()方法和doTrace()方法，因为HttpServlet对这几个方法的实现对几乎所有处理HTTP消息的Servlet都是适用的，除非有些Servlet有特别的要求。而HttpServlet对doGet()方法、doHead()方法、doPost()方法、doPut()方法、doDelete()方法和getLastModified()方法的实现都是默认的最小实现，比如在doGet()、doHead()、doPost()、doPut()和doDelete()方法中只是发送错误信息说明该方法不被支持，而在getLastModified()方法中只是返回一个无效的时间，所以这几个方法都需要HttpServlet的子类来实现，如果实现的Servlet只希望提供给客户端通过GET方法获取资源，那么就只需要覆盖doGet()方法，如果还希望支持通过POST方法提交资源，那么就再覆盖doPost()方法，依此类推。对于没有实现的方法，如果接收到此类消息将返回一个错误消息，提示该方法没有被实现。

在Java Web开发中，绝大多数Servlet都继承自HttpServlet类，子类再根据各自业务需要分别实现do***()方法以覆盖父类的实现。

• 上一节
• 本书简介
• 下一节

Servlet采用请求/响应模式进行工作，接受来自客户端的请求，对请求进行处理，然后将对请求的回复通过响应消息发送给客户端。可见请求和响应消息在Servlet的工作过程中起着很重要的作用。在Servlet体系中，用ServletRequest对象表示通用请求、HttpServletRequest对象表示Http请求；用ServletResponse对象表示通用响应、HttpServletResponse对象表示Http响应。

• 上一节
• 本书简介
• 下一节

ServletRequest是Servlet体系中又一个重要的接口，它表示Servlet请求，不仅仅对请求消息作了封装，而且还代表一次请求过程，ServletRequest对象的生命周期就是从Servlet容器接收到请求到请求被处理结束。其定义如下：

package javax.servlet;

import java.io.*;

import java.util.*;

public interface ServletRequest

{

public abstract Object getAttribute(String s);

public abstract Enumeration getAttributeNames();

public abstract String getCharacterEncoding();

public abstract void setCharacterEncoding(String s)

throws UnsupportedEncodingException;

public abstract int getContentLength();

public abstract String getContentType();

public abstract ServletInputStream getInputStream()

throws IOException;

public abstract String getParameter(String s);

public abstract Enumeration getParameterNames();

public abstract String[] getParameterValues(String s);

public abstract Map getParameterMap();

public abstract String getProtocol();

public abstract String getScheme();

public abstract String getServerName();

public abstract int getServerPort();

public abstract BufferedReader getReader()

throws IOException;

public abstract String getRemoteAddr();

public abstract String getRemoteHost();

public abstract void setAttribute(String s, Object obj);

public abstract void removeAttribute(String s);

public abstract Locale getLocale();

public abstract Enumeration getLocales();

public abstract boolean isSecure();

public abstract RequestDispatcher getRequestDispatcher(String s);

public abstract String getRealPath(String s);

public abstract int getRemotePort();

public abstract String getLocalName();

public abstract String getLocalAddr();

public abstract int getLocalPort();

}

其中：

getAttribute（String s）：获取具有给定名称属性的值。属性可能通过两种方式进行设置，一种是Servlet容器设置一些属性，使得Servlet容器可以与Servlet进行通信，另一种是在Servlet中自己调用setAttribute()方法设置；

getAttributeNames()：返回一个Enumeration对象，包含所有属性的名称；

getCharacterEncoding()：返回请求所使用的字符编码；

setCharacterEncoding（String s）：设置字符编码，在将字符编码设置后，Servlet通过Reader读取Request的内容时就会以新的字符编码进行读取；

getContentLength()：返回请求体的长度，以字节为单位。如果长度未知则返回 –1；

getContentType()：返回请求内容的MIME类型；

getInputStream()：返回一个ServletInputStream对象，通过该对象可以以二进制的形式读取Request的内容；

getParameter（String s）：获取请求携带的参数中名称为s的参数值，如果没有该参数则返回null。在HTTP请求中，请求携带的查询字符串被作为参数，例如http://localhost:8080/query?num= 1&type=apple中的查询字符串有两个参数，参数名为num的值为1，参数名为type的值为apple。还有，从表单中提交的数据也作为参数，参数名为表单元素的名称，参数值为表单元素的值；

getParameterNames()：返回一个Enumeration对象，包含所有参数的名称；

getParameterValues（String s）：该方法与getParameter(String s)的作用一样，也是用于获取给定参数名的值。因为同一参数名可能具有多个参数值，所以getPatameter（String s）一般用来获得确信只有一个值的参数，getParameterValues（String s）一般用来获得可能有多个值的参数。多个值以字符串数组的形式返回；

getParameterMap()：以Map的形式返回请求携带的所有参数的参数名和参数值。Map的键是String类型，表示参数名；Map的值是String数组类型，表示参数值；

getProtocol()：返回请求所使用的协议及其版本，格式为：Protocol/MajorVersion.MinorVersion，例如，HTTP消息所使用的协议通常都是HTTP/1.0或HTTP/1.1；

getScheme()：不同的模式（HTTP、HTTPS、FTP等）对于请求的格式有不同的形成规则。该方法返回请求所使用的模式名称；

getServerName()：返回该请求的目的主机服务器的名称，通常为请求URL中的域名、主机名或IP地址；

getServerPort()：返回请求的目的端口，通常在请求URL中域名后，用“：”与域名隔开。默认是80；

getReader()：返回一个BufferedReader对象，通过该对象可以以字符形式读取请求的内容，如果在该方法被调用前已经使用setCharacterEncoding（String s）设置了编码，那么就使用设置的编码解析请求中的二进制形式内容，否则使用默认的编码解析；

getRemoteAddr()：获得发出该请求的主机的IP地址，可能是客户机也可能是转发的代理服务器；

getRemoteHost()：获得发出该请求的主机名称；

setAttribute（String s, Object obj）：将名为s值为obj的属性设置到请求中；

removeAttribute（String s）：删除请求中名为s的属性；

getLocale()：返回客户端期望使用的本地化设置。根据HTTP请求消息头的Accept-Language头域的值进行判断；

getLocales()：返回一个Enumeration对象，包含客户端可以接受的所有本地化设置，从期望的本地化设置开始按优先顺序排列；

isSecure()：返回该请求是否使用了安全通道进行传输，比如HTTPS；

getRequestDispatcher（String s）：s表示一个路径，该方法返回一个到s所指定资源的RequestDispatcher对象。与ServletContext的getRequestDispatcher（String s）不同的是，该方法的路径可以是相对路径；

getRemotePort()：获得发出该请求的主机所使用的端口；

getLocalName()：获得接收该请求的主机名；

getLocalAddr()：获得接收该请求的主机IP地址；

getLocalPort()：获得接收该请求的主机使用的端口。

从ServletRequest接口提供的方法可以看出，ServletRequest对象提供了一种对请求的封装，可以通过该接口中的方法获取请求相关的信息，例如请求的参数、发出和接收请求的主机的相关信息等；同时也提供了一些请求相关的操作，例如设置和获取作用域为本请求的属性，获取相对于请求的RequestDispatcher对象等。

• 上一节
• 本书简介
• 下一节

虽然从设计上来说Servlet不仅仅局限于处理HTTP消息，但从Servlet诞生到现在不得不承认Servlet主要还是被用于处理HTTP消息。所以学习Servlet重点还是学习HTTP Servlet，同样学习ServletRequest重点还是学习HttpServletRequest。

HttpServletRequest表示HTTP请求，它是ServletRequest的子接口，所以ServletRequest中定义的方法也都是HttpServletRequest的方法。除此之外，HttpServletRequest还定义了一些HTTP请求特有的方法。定义如下：

package javax.servlet.http;

import java.security.Principal;

import java.util.Enumeration;

import javax.servlet.ServletRequest;

public interface HttpServletRequest

extends ServletRequest

{

public static final String BASIC_AUTH = "BASIC";

public static final String FORM_AUTH = "FORM";

public static final String CLIENT_CERT_AUTH = "CLIENT_CERT";

public static final String DIGEST_AUTH = "DIGEST";

public abstract String getAuthType();

public abstract Cookie[] getCookies();

public abstract long getDateHeader(String s);

public abstract String getHeader(String s);

public abstract Enumeration getHeaders(String s);

public abstract Enumeration getHeaderNames();

public abstract int getIntHeader(String s);

public abstract String getMethod();

public abstract String getPathInfo();

public abstract String getPathTranslated();

public abstract String getContextPath();

public abstract String getQueryString();

public abstract String getRemoteUser();

public abstract boolean isUserInRole(String s);

public abstract Principal getUserPrincipal();

public abstract String getRequestedSessionId();

public abstract String getRequestURI();

public abstract StringBuffer getRequestURL();

public abstract String getServletPath();

public abstract HttpSession getSession(boolean flag);

public abstract HttpSession getSession();

public abstract boolean isRequestedSessionIdValid();

public abstract boolean isRequestedSessionIdFromCookie();

public abstract boolean isRequestedSessionIdFromURL();

}

其中：

getAuthType()：返回Servlet容器用于保护Servlet所使用的验证模式，返回的字符串可以是常量BASIC_AUTH、FORM_AUTH、CLIENT_CERT_AUTH和DIGEST_AUTH中之一；

getCookies()：返回一个Cookie数组，包含请求所携带的所有Cookie对象；

getDateHeader（String s）：获得HTTP请求消息头中日期类型的头域的值，参数为头域的名称，返回long表示的日期；

getHeader（String s）：获得HTTP请求消息头中名为s的头域的值，返回String类型；

getHeaders（String s）：因为在HTTP消息头中，允许多个头域具有相同的名称。该方法返回一个Enumeration对象，包含名为s的所有头域的值；

getHeaderNames()：返回一个Enumeration对象，包含所有头域的名称；

getIntHeader（String s）：获得Int类型头域的值；

getMethod()：获得该HTTP请求所使用的HTTP方法，例如GET、POST等；

getPathInfo()：返回URL中Servlet名和查询字符串之间的路径，以“/”开头；

getPathTranslated()：获得URL中Servlet名和查询字符串之间的路径并且将其翻译成真实路径返回；

getContextPath()：返回该请求URL所指向应用的上下文路径；

getQueryString()：返回请求URL中的查询字符串；

getRemoteUser()：如果发出该请求的终端用户进行了登录，则返回用户的登录信息，否则返回null；

isUserInRole（String s）：如果终端用户进行了登录，则验证用户是否在指定的角色里，如果是则返回true，否则返回false；

getUserPrincipal()：返回一个java.security.Principal 对象，该对象包含当前验证用户的名称；如果该用户没有经过验证则返回null；

getRequestedSessionId()：返回指定给客户端的Session ID；

getRequestURI()：返回请求消息中请求URI，就是在HTTP请求消息头中第一行出现的所请求资源的路径；

getRequestURL()：请求的URL，包含协议、域名/IP、端口、服务器上的相对路径，但不包含查询字符串；

getServletPath()：返回URL中用于进行Servlet映射的路径；

getSession（boolean flag）：返回与当前Request相关联的HttpSession，如果没有与当前Request相关联的HttpSession且flag为true时就新建一个Session；

getSession()：相当于getSession（true）；

isRequestedSessionIdValid()：检查请求的Session ID是否还有效；

isRequestedSessionIdFromCookie()：检查请求的Session ID是否来自于Cookie；

isRequestedSessionIdFromURL()：检查请求的Session ID是否来自于URL。

• 上一节
• 本书简介
• 下一节

实验是学习编程的最好方法，本节将介绍一个实验用来学习ServletRequest和HttpServletRequest。本实验实现一个Servlet，该Servlet用于打印输出HTTP请求所对应的HttpServletRequest对象的相关方法的值。

直接在前面建成的ServletTest工程中进行实验。修改TestServlet，将TestServlet的内容修改如下：

示例8.1  HttpServletRequestPrinter

package cn.csai.web.servlet;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.Enumeration;

import java.util.Map;

import javax.servlet.ServletException;

import javax.servlet.http.Cookie;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

/**

* Servlet implementation class for Servlet: TestServlet

*

*/

public class TestServlet extends javax.servlet.http.HttpServlet implements

javax.servlet.Servlet

{

static final long serialVersionUID = 1L;

private PrintWriter pw;

/*

* (non-Java-doc)

*

* @see javax.servlet.http.HttpServlet#HttpServlet()

*/

public TestServlet() {

super();

}

/*

* (non-Java-doc)

*

* @see javax.servlet.http.HttpServlet#doGet(HttpServletRequest request,

*      HttpServletResponse response)

*/

protected void doGet(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException

{

pw = response.getWriter();

writeln("--- Attributes --------------------");

Enumeration<String> attrNames = request.getAttributeNames();

for (String attr = ""; attrNames.hasMoreElements(); attr = attrNames

.nextElement())

{

writeln(attr + " = " + request.getAttribute(attr));

}

writeln("--- HTTP Message --------------------");

writeln("getScheme(): " + request.getScheme());

writeln("getProtocol(): " + request.getProtocol());

writeln("getMethod(): " + request.getMethod());

writeln("--- URL --------------------");

writeln("getRequestURI(): " + request.getRequestURI());

writeln("getRequestURL(): " + request.getRequestURL());

writeln("getPathInfo(): " + request.getPathInfo());

writeln("getPathTranslated(): " + request.getPathTranslated());

writeln("getQueryString(): " + request.getQueryString());

writeln("--- Parameters --------------------");

Map params = request.getParameterMap();

for(Object key : params.keySet()) {

String[] values = (String[]) params.get(key);

for(String v : values){

writeln(key + " = " + v);

}

}

writeln("--- Headers --------------------");

Enumeration<String> headerNames = request.getHeaderNames();

for (String header = headerNames.nextElement();

null != header && headerNames.hasMoreElements();

header = headerNames.nextElement())

{

writeln(header + " = " + request.getHeader(header));

}

writeln("--- Server Information --------------------");

writeln("getLocale(): " + request.getLocale());

writeln("getLocalAddr(): " + request.getLocalAddr());

writeln("getLocalName(): " + request.getLocalName());

writeln("getLocalPort(): " + request.getLocalPort());

writeln("getServerName(): " + request.getServerName());

writeln("getServerPort(): " + request.getServerPort());

writeln("getContextPath(): " + request.getContextPath());

writeln("getServletPath(): " + request.getServletPath());

writeln("--- Client Information --------------------");

writeln("getRemoteAddr(): " + request.getRemoteAddr());

writeln("getRemoteHost(): " + request.getRemoteHost());

writeln("getRemoteUser(): " + request.getRemoteUser());

writeln("--- Cookies --------------------");

Cookie[] cookies = request.getCookies();

if (null != cookies) {

for (Cookie cookie : cookies) {

writeln(cookie.getName() + "=" + cookie.getValue()+

";expires=" + cookie.getMaxAge() +

";domain="+ cookie.getDomain() +

";path=" + cookie.getPath());

}

}

writeln("--- Request Information --------------------");

writeln("getContentLength(): " + request.getContentLength());

writeln("getContentType(): " + request.getContentType());

writeln("getAuthType(): " + request.getAuthType());

writeln("getCharacterEncoding(): " + request.getCharacterEncoding());

writeln("getRequestedSessionId(): " + request.getRequestedSessionId());

pw.flush();

pw.close();

}

private void writeln(String str) {

pw.write(str + "<br>");

}

}

该Servlet将请求生成的HttpServletRequest对象的各个方法的值输出到客户端浏览器。按照以上内容编辑好TestServlet，并修改ServletTest工程的web.xml文件，将TestServlet的url-mapping修改为“/TestServlet/*”，即让所有相对路径以TestServlet开始的请求都分发到TestServlet。

重新部署Web应用并重新启动Tomcat，在浏览器中输入如下URL：

http://localhost:8080/ServletTest/TestServlet/a?b=1&c=tt

返回的页面内容如下：

--- Attributes --------------------

--- HTTP Message --------------------

getScheme(): http

getProtocol(): HTTP/1.1

getMethod(): GET

--- URL --------------------

getRequestURI(): /ServletTest/TestServlet/a

getRequestURL(): http://localhost:8080/ServletTest/TestServlet/a

getPathInfo(): /a

getPathTranslated(): D:\tomcat\MyWebapps\ServletTest\a

getQueryString(): b=1&c=tt

--- Parameters --------------------

c = tt

b = 1

--- Headers --------------------

accept = */*

accept-language = zh-cn,en-us;q=0.5

accept-encoding = gzip, deflate

user-agent = Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)

host = localhost:8080

--- Server Information --------------------

getLocale(): zh_CN

getLocalAddr(): 127.0.0.1

getLocalName(): localhost

getLocalPort(): 8080

getServerName(): localhost

getServerPort(): 8080

getContextPath(): /ServletTest

getServletPath(): /TestServlet

--- Client Information --------------------

getRemoteAddr(): 127.0.0.1

getRemoteHost(): 127.0.0.1

getRemoteUser(): null

--- Cookies --------------------

--- Request Information --------------------

getContentLength(): -1

getContentType(): null

getAuthType(): null

getCharacterEncoding(): null

getRequestedSessionId(): null

从返回的页面内容中可以发现各个方法所获得的值，对照输入的URL可以很清晰地明确每个方法所获取的内容。其中由于测试环境没有设置任何属性，所以Attributes项没有任何内容；同样原因Cookies项也没有内容。许多输出为null的就表示请求中没有设置该属性。

在学习其他部分内容时，读者也可以采用同样的实验方法，通过构造适当的Servlet内容，将Servlet实际部署到Tomcat中，通过运行Servlet观察输出结果；比较不同Servlet的不同输出结果可以很清楚的了解很多内容。