Servlet 3.0特性详解

Servlet 3.0作为 Java  EE6规范体系中一员，随着Java EE6规范一起发布。之前51CTO也曾报导过

《 Java EE  6新特性之Servlet 3.0的异步处理》的相关内容，而本文将比较全面的、并结合代码

实例介绍Servlet 3.0的新特性。

关于Java EE 6平台的更多内容，51CTO推荐阅读：Java EE 6平台指南

异步处理支持：有了该特性，Servlet线程不再需要一直阻塞，直到业务处理完毕才能再输出响

应，最后才结束该Servlet线程。在接收到请求之后，Servlet线程可以将耗时的操作委派给另一

个线程来完成，自己在不生成响应的情况下返回至容器。针对业务处理较耗时的情况，这将大大

减少服务器资源的占用，并且提高并发处理速度。

新增的注解支持：该版本新增了若干注解，用于简化Servlet、过滤器（Filter）和监听器

（Listener）的声明，这使得 web.xml部署描述文件从该版本开始不再是必选的了。可插性支持

：熟悉Struts2的开发者一定会对其通过插件的方式与包括 spring 在内的各种常用框架的整合特

性记忆犹新。

将相应的插件封装成JAR包并放在类路径下，Struts2运行时便能自动加载这些插件。现在

Servlet 3.0提供了类似的特性，开发者可以通过插件的方式很方便的扩充已有Web应用的功能，

而不需要修改原有的应用。下面我们将逐一讲解这些新特性，通过下面的学习，读者将能够明晰

了解Servlet 3.0的变化，并能够顺利使用它进行日常的开发工作。

异步处理支持

Servlet 3.0之前，一个普通Servlet的主要工作流程大致如下：首先，Servlet接收到请求之后

，可能需要对请求携带的数据进行一些预处理；接着，调用业务接口的某些方法，以完成业务处

理；最后，根据处理的结果提交响应，Servlet线程结束。

其中第二步的业务处理通常是最耗时的，这主要体现在 数据库 操作，以及其它的跨网络调用等，

在此过程中，Servlet线程一直处于阻塞状态，直到业务方法执行完毕。在处理业务的过程中，

Servlet资源一直被占用而得不到释放，对于并发较大的应用，这有可能造成性能的瓶颈。对此

，在以前通常是采用私有解决方案来提前结束Servlet线程，并及时释放资源。

Servlet 3.0针对这个问题做了开创性的工作，现在通过使用Servlet 3.0的异步处理支持，之前

的Servlet处理流程可以调整为如下的过程：首先，Servlet接收到请求之后，可能首先需要对请

求携带的数据进行一些预处理；接着，Servlet线程将请求转交给一个异步线程来执行业务处理

，线程本身返回至容器，此时Servlet还没有生成响应数据，异步线程处理完业务以后，可以直

接生成响应数据（异步线程拥有ServletRequest和ServletResponse对象的引用），或者将请求

继续转发给其它 Servlet。如此一来，Servlet线程不再是一直处于阻塞状态以等待业务逻辑的

处理，而是启动异步线程之后可以立即返回。

异步处理特性可以应用于Servlet和过滤器两种组件，由于异步处理的工作模式和普通工作模式

在实现上有着本质的区别，因此默认情况下，Servlet和过滤器并没有开启异步处理特性，如果

希望使用该特性，则必须按照如下的方式启用：

对于使用传统的部署描述文件(web.xml)配置Servlet和过滤器的情况，Servlet 3.0为<servlet>

和<filter>标签增加了<async-supported>子标签，该标签的默认取值为false，要启用异步处理

支持，则将其设为true即可。以Servlet为例，其配置方式如下所示：

   1. <servlet> 
   2. <servlet-name>DemoServlet</servlet-name> 
   3. <servlet-class>footmark.servlet.DemoServlet</servlet-class> 
   4. <async-supported>true</async-supported> 
   5. </servlet> 

对于使用Servlet 3.0提供的@WebServlet和@WebFilter进行Servlet或过滤器配置的情况，这两

个注解都提供了asyncSupported属性，默认该属性的取值为false，要启用异步处理支持，只需

将该属性设置为true即可。以@WebFilter为例，其配置方式如下所示：

   1. @WebFilter(urlPatterns="/demo",asyncSupported=true)  
   2. publicclassDemoFilterimplementsFilter{...} 

一个简单的模拟异步处理的Servlet示例如下：

   1. @WebServlet(urlPatterns="/demo",asyncSupported=true)  
   2. publicclassAsyncDemoServletextendsHttpServlet{  
   3. @Override  
   4. publicvoiddoGet(HttpServletRequestreq,HttpServletResponseresp)  
   5. throwsIOException,ServletException{  
   6. resp.setContentType("text/html;charset=UTF-8");  
   7. PrintWriterout=resp.getWriter();  
   8. out.println("进入Servlet的时间："+newDate()+".");  
   9. out.flush();  
  10.  
  11. //在子线程中执行业务调用，并由其负责输出响应，主线程退出  
  12. AsyncContextctx=req.startAsync();  
  13. newThread(newExecutor(ctx)).start();  
  14. out.println("结束Servlet的时间："+newDate()+".");  
  15. out.flush();  
  16. }  
  17. } 

   1. publicclassExecutorimplementsRunnable{  
   2. privateAsyncContextctx=null;  
   3. publicExecutor(AsyncContextctx){  
   4. this.ctx=ctx;  
   5. }  
   6.  
   7. publicvoidrun(){  
   8. try{  
   9. //等待十秒钟，以模拟业务方法的执行  
  10. Thread.sleep(10000);  
  11. PrintWriterout=ctx.getResponse().getWriter();  
  12. out.println("业务处理完毕的时间："+newDate()+".");  
  13. out.flush();  
  14. ctx.complete();  
  15. }catch(Exceptione){  
  16. e.printStackTrace();  
  17. }  
  18. }  
  19. } 

除此之外，Servlet 3.0还为异步处理提供了一个监听器，使用AsyncListener接口表示。它可以

监控如下四种事件：

1.异步线程开始时，调用AsyncListener的onStartAsync(AsyncEventevent)方法；

2.异步线程出错时，调用AsyncListener的onError(AsyncEventevent)方法；

3.异步线程执行超时，则调用AsyncListener的onTimeout(AsyncEventevent)方法；

4.异步执行完毕时，调用AsyncListener的onComplete(AsyncEventevent)方法；

要注册一个AsyncListener，只需将准备好的AsyncListener对象传递给AsyncContext对象的 

addListener()方法即可，如下所示：

   1. AsyncContextctx=req.startAsync();  
   2. ctx.addListener(newAsyncListener(){  
   3. publicvoidonComplete(AsyncEventasyncEvent)throwsIOException{  
   4. //做一些清理工作或者其他  
   5. }  
   6. ...  
   7. }); 

新增的注解支持

Servlet 3.0的部署描述文件web.xml的顶层标签<web-app>有一个metadata-complete属性，该属

性指定当前的部署描述文件是否是完全的。如果设置为true，则容器在部署时将只依赖部署描述

文件，忽略所有的注解（同时也会跳过web-fragment.xml的扫描，亦即禁用可插性支持，具体请

看后文关于可插性支持的讲解）；如果不配置该属性，或者将其设置为false，则表示启用注解

支持（和可插性支持）。

@WebServlet

@WebServlet用于将一个类声明为Servlet，该注解将会在部署时被容器处理，容器将根据具体的

属性配置将相应的类部署为 Servlet。该注解具有下表给出的一些常用属性（以下所有属性均为

可选属性，但是vlaue或者urlPatterns通常是必需的，且二者不能共存，如果同时指定，通常是

忽略value的取值）：

属性名类型描述

1.nameString指定Servlet的name属性，等价于<servlet-name>。如果没有显式指定，则该 

Servlet的取值即为类的全限定名。

2.valueString[]该属性等价于urlPatterns属性。两个属性不能同时使用。

3.urlPatternsString[]指定一组Servlet的URL匹配模式。等价于<url-pattern>标签。

4.loadOnStartupint指定Servlet的加载顺序，等价于<load-on-startup>标签。

5.initParamsWebInitParam[]指定一组Servlet初始化参数，等价于<init-param>标签。

6.asyncSupportedboolean声明Servlet是否支持异步操作模式，等价于<async-supported> 标签

。

7.descriptionString该Servlet的描述信息，等价于<description>标签。

8.displayNameString该Servlet的显示名，通常配合工具使用，等价于<display-name>标签。

下面是一个简单的示例：

   1. @WebServlet(urlPatterns={"/simple"},asyncSupported=true,  
   2. loadOnStartup=-1,name="SimpleServlet",displayName="ss",  
   3. initParams={@WebInitParam(name="username",value="tom")}  
   4. )  
   5. publicclassSimpleServletextendsHttpServlet{…} 

如此配置之后，就可以不必在web.xml中配置相应的<servlet>和<servlet-mapping>元素了，容

器会在部署时根据指定的属性将该类发布为Servlet。它的等价的web.xml配置形式如下：

   1. <servlet> 
   2. <display-name>ss</display-name> 
   3. <servlet-name>SimpleServlet</servlet-name> 
   4. <servlet-class>footmark.servlet.SimpleServlet</servlet-class> 
   5. <load-on-startup>-1</load-on-startup> 
   6. <async-supported>true</async-supported> 
   7. <init-param> 
   8. <param-name>username</param-name> 
   9. <param-value>tom</param-value> 
  10. </init-param> 
  11. </servlet> 
  12. <servlet-mapping> 
  13. <servlet-name>SimpleServlet</servlet-name> 
  14. <url-pattern>/simple</url-pattern> 
  15. </servlet-mapping> 

@WebInitParam

该注解通常不单独使用，而是配合@WebServlet或者@WebFilter使用。它的作用是为Servlet或者

过滤器指定初始化参数，这等价于web.xml中<servlet>和<filter>的<init-param>子标签。 

@WebInitParam具有下表给出的一些常用属性：

属性名类型是否可选描述

◆nameString否指定参数的名字，等价于<param-name>。
◆valueString否指定参数的值，等价于<param-value>。
◆descriptionString是关于参数的描述，等价于<description>。

@WebFilter

@WebFilter用于将一个类声明为过滤器，该注解将会在部署时被容器处理，容器将根据具体的属

性配置将相应的类部署为过滤器。该注解具有下表给出的一些常用属性(以下所有属性均为可选

属性，但是value、urlPatterns、servletNames三者必需至少包含一个，且value 和

urlPatterns不能共存，如果同时指定，通常忽略value的取值)：


属性名类型描述

1.filterNameString指定过滤器的name属性，等价于<filter-name>。

2.valueString[]该属性等价于urlPatterns属性。但是两者不应该同时使用。

3.urlPatternsString[]指定一组过滤器的URL匹配模式。等价于<url-pattern>标签。

4.servletNamesString[]指定过滤器将应用于哪些Servlet。取值是@WebServlet中的name属性的

取值，或者是web.xml中<servlet-name>的取值。

5.dispatcherTypesDispatcherType指定过滤器的转发模式。具体取值包括：

◆ASYNC、ERROR、FORWARD、INCLUDE、REQUEST。

◆initParamsWebInitParam[]指定一组过滤器初始化参数，等价于<init-param>标签。

◆asyncSupportedboolean声明过滤器是否支持异步操作模式，等价于<async-supported>标签。

◆descriptionString该过滤器的描述信息，等价于<description>标签。

◆displayNameString该过滤器的显示名，通常配合工具使用，等价于<display-name>标签。

下面是一个简单的示例：

   1. @WebFilter(servletNames={"SimpleServlet"},filterName="SimpleFilter")  
   2. publicclassLessThanSixFilterimplementsFilter{...} 

如此配置之后，就可以不必在web.xml中配置相应的<filter>和<filter-mapping>元素了，容器

会在部署时根据指定的属性将该类发布为过滤器。它等价的web.xml中的配置形式为：

   1. <filter> 
   2. <filter-name>SimpleFilter</filter-name> 
   3. <filter-class>xxx</filter-class> 
   4. </filter> 
   5. <filter-mapping> 
   6. <filter-name>SimpleFilter</filter-name> 
   7. <servlet-name>SimpleServlet</servlet-name> 
   8. </filter-mapping> 

@WebListener

该注解用于将类声明为监听器，被@WebListener标注的类必须实现以下至少一个接口：

   1. ServletContextListener  
   2. ServletContextAttributeListener  
   3. ServletRequestListener  
   4. ServletRequestAttributeListener  
   5. HttpSessionListener  
   6. HttpSessionAttributeListener 

该注解使用非常简单，其属性如下：

属性名类型是否可选描述

valueString是该监听器的描述信息。

一个简单示例如下：

   1. @WebListener("Thisisonlyademolistener")  
   2. publicclassSimpleListenerimplementsServletContextListener{...} 

如此，则不需要在web.xml中配置<listener>标签了。它等价的web.xml中的配置形式如下：

   1. <listener> 
   2. <listener-class>footmark.servlet.SimpleListener</listener-class> 
   3. </listener> 

@MultipartConfig

该注解主要是为了辅助Servlet 3.0中HttpServletRequest提供的对上传文件的支持。该注解标

注在Servlet上面，以表示该Servlet希望处理的请求的 MIME类型是multipart/form-data。另外

，它还提供了若干属性用于简化对上传文件的处理。具体如下：

属性名类型是否可选描述

◆fileSizeThresholdint是当数据量大于该值时，内容将被写入文件。

◆locationString是存放生成的文件地址。

◆maxFileSizelong是允许上传的文件最大值。默认值为-1，表示没有限制。

◆maxRequestSizelong是针对该multipart/form-data请求的最大数量，默认值为-1，表示没有

限制。

可插性支持

如果说3.0版本新增的注解支持是为了简化Servlet/过滤器/监听器的声明，从而使得web.xml变

为可选配置，那么新增的可插性 (pluggability)支持则将Servlet配置的灵活性提升到了新的高

度。熟悉Struts2的开发者都知道，Struts2通过插件的形式提供了对包括Spring在内的各种开发

框架的支持，开发者甚至可以自己为Struts2开发插件，而Servlet的可插性支持正是基于这样的

理念而产生的。使用该特性，现在我们可以在不修改已有Web应用的前提下，只需将按照一定格

式打成的JAR包放到WEB-INF/lib目录下，即可实现新功能的扩充，不需要额外的配置。

Servlet 3.0引入了称之为“Web模块部署描述符片段”的web-fragment.xml部署描述文件，该文

件必须存放在JAR文件的META-INF目录下，该部署描述文件可以包含一切可以在web.xml中定义的

内容。JAR包通常放在WEB-INF/lib目录下，除此之外，所有该模块使用的资源，包括class文件

、配置文件等，只需要能够被容器的类加载器链加载的路径上，比如classes目录等。

现在，为一个Web应用增加一个Servlet配置有如下三种方式(过滤器、监听器与Servlet三者的配

置都是等价的，故在此以Servlet 配置为例进行讲述，过滤器和监听器具有与之非常类似的特性

)：

1.编写一个类继承自HttpServlet，将该类放在classes目录下的对应包结构中，修改web.xml，

在其中增加一个Servlet 声明。这是最原始的方式；

2.编写一个类继承自HttpServlet，并且在该类上使用@WebServlet注解将该类声明为Servlet，

将该类放在classes 目录下的对应包结构中，无需修改web.xml文件。

3.编写一个类继承自HttpServlet，将该类打成JAR包，并且在JAR包的META-INF目录下放置一个

web- fragment.xml文件，该文件中声明了相应的Servlet配置。web-fragment.xml文件示例如下

：

   1. <?xmlversionxmlversion="1.0"encoding="UTF-8"?> 
   2. <web-fragment 
   3. xmlns=http://java.sun.com/xml/ns/javaee  
   4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"version="3.0"  
   5. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
   6. http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd"  
   7. metadata-complete="true"> 
   8. <servlet> 
   9. <servlet-name>fragment</servlet-name> 
  10. <servlet-class>footmark.servlet.FragmentServlet</servlet-class> 
  11. </servlet> 
  12. <servlet-mapping> 
  13. <servlet-name>fragment</servlet-name> 
  14. <url-pattern>/fragment</url-pattern> 
  15. </servlet-mapping> 
  16. </web-fragment> 

从上面的示例可以看出，web-fragment.xml与web.xml除了在头部声明的XSD引用不同之外，其主

体配置与web.xml是完全一致的。由于一个Web应用中可以出现多个web-fragment.xml声明文件，

加上一个web.xml文件，加载顺序问题便成了不得不面对的问题。Servlet规范的专家组在设计的

时候已经考虑到了这个问题，并定义了加载顺序的规则。

web-fragment.xml包含了两个可选的顶层标签，<name>和<ordering>，如果希望为当前的文件指

定明确的加载顺序，通常需要使用这两个标签，<name>主要用于标识当前的文件，而<ordering>

则用于指定先后顺序。一个简单的示例如下：

   1. <web-fragment...> 
   2. <name>FragmentA</name> 
   3. <ordering> 
   4. <after> 
   5. <name>FragmentB</name> 
   6. <name>FragmentC</name> 
   7. </after> 
   8. <before> 
   9. <others/> 
  10. </before> 
  11. </ordering> 
  12. ...  
  13. </web-fragment> 

如上所示，<name>标签的取值通常是被其它web-fragment.xml文件在定义先后顺序时引用的，在

当前文件中一般用不着，它起着标识当前文件的作用。在<ordering>标签内部，我们可以定义当

前web-fragment.xml文件与其他文件的相对位置关系，这主要通过<ordering>的<after>和

<before>子标签来实现的。在这两个子标签内部可以通过<name>标签来指定相对应的文件。比如

：

   1. <after> 
   2. <name>FragmentB</name> 
   3. <name>FragmentC</name> 
   4. </after> 

以上片段则表示当前文件必须在FragmentB和FragmentC之后解析。<before>的使用于此相同，它

所表示的是当前文件必须早于<before>标签里所列出的web-fragment.xml文件。除了将所比较的

文件通过<name> 在<after>和<begin>中列出之外，Servlet还提供了一个简化的标签<others/>

。它表示除了当前文件之外的其他所有的web-fragment.xml文件。该标签的优先级要低于使用

<name>明确指定的相对位置关系。


ServletContext的性能增强

除了以上的新特性之外，ServletContext对象的功能在新版本中也得到了增强。现在，该对象支

持在运行时动态部署Servlet、过滤器、监听器，以及为Servlet和过滤器增加URL映射等。以

Servlet为例，过滤器与监听器与之类似。ServletContext为动态配置 Servlet增加了如下方法

：

◆ServletRegistration.DynamicaddServlet(StringservletName,Class<?

extendsServlet>servletClass)

◆ServletRegistration.DynamicaddServlet(StringservletName,Servletservlet)

◆ServletRegistration.DynamicaddServlet(StringservletName,StringclassName)

◆<TextendsServlet>TcreateServlet(Class<T>clazz)

◆ServletRegistrationgetServletRegistration(StringservletName)

◆Map<String,?extendsServletRegistration>getServletRegistrations()

其中前三个方法的作用是相同的，只是参数类型不同而已；通过createServlet()方法创建的

Servlet，通常需要做一些自定义的配置，然后使用addServlet()方法来将其动态注册为一个可

以用于服务的Servlet。

两个getServletRegistration()方法主要用于动态为Servlet增加映射信息，这等价于在

web.xml(抑或web- fragment.xml)中使用<servlet-mapping>标签为存在的Servlet增加映射信息

。以上 ServletContext新增的方法要么是在ServletContextListener的contexInitialized方法

中调用，要么是在ServletContainerInitializer的onStartup()方法中调用。

ServletContainerInitializer也是Servlet3.0新增的一个接口，容器在启动时使用JAR服务 

API(JARServiceAPI)来发现ServletContainerInitializer的实现类，并且容器将WEB-INF/lib目

录下 JAR包中的类都交给该类的onStartup()方法处理，我们通常需要在该实现类上使用

@HandlesTypes注解来指定希望被处理的类，过滤掉不希望给onStartup()处理的类。

HttpServletRequest对文件上传的支持

此前，对于处理上传文件的操作一直是让开发者头疼的问题，因为Servlet本身没有对此提供直

接的支持，需要使用第三方框架来实现，而且使用起来也不够简单。如今这都成为了历史，

Servlet 3.0已经提供了这个功能，而且使用也非常简单。为此，HttpServletRequest提供了两

个方法用于从请求中解析出上传的文件：

◆PartgetPart(Stringname)
◆Collection<Part>getParts()

前者用于获取请求中给定name的文件，后者用于获取所有的文件。每一个文件用一个

javax.servlet.http.Part对象来表示。该接口提供了处理文件的简易方法，比如write()、

delete()等。至此，结合HttpServletRequest和Part来保存上传的文件变得非常简单，如下所示

：

◆Partphoto=request.getPart("photo");
◆photo.write("/tmp/photo.jpg");

可以将两行代码简化为request.getPart("photo").write("/tmp/photo.jpg")一行。另外，开发

者可以配合前面提到的@MultipartConfig注解来对上传操作进行一些自定义的配置，比如限制上

传文件的大小，以及保存文件的路径等。其用法非常简单，故不在此赘述了。需要注意的是，如

果请求的MIME类型不是multipart/form-data，则不能使用上面的两个方法，否则将抛异常。

总结

Servlet 3.0的众多新特性使得Servlet开发变得更加简单，尤其是异步处理特性和可插性支持的

出现，必将对现有的MVC框架产生深远影响。虽然我们通常不会自己去用Servlet编写控制层代码

，但是也许在下一个版本的Struts中，您就能切实感受到这些新特性带来的实质性改变。