Servlet 2.5规范现在把J2SE 5.0(JDK 1.5)作为最低要求。这个变动保证了J2SE5.0中所有新的语言特性都在Servlet 2.5中可用，包括：泛型支持、自动包装、增强的迭代循环、新的enum枚举类型、静态导入、可变参数表、元数据注解等等

注解提供了一套机制，通过元数据来装饰Java代码结构（类、方法、域等等）。注解并不象代码一样执行，而是对代码进行标记，使代码处理机可以根据这些元数据信息作出相应的行为。以前的版本提供了一些不同的小技巧来对类或方法进行注解，例如使用Serializable接口来标记序列化类，或使用@deprecated的Javadoc注释来标记弃用的方法。新的元数据机制提供一套标准的方法来对代码进行注解，并提供了类库来创建自定义的注解类型。请参考第 43.2.4.2 节 “使用注解”

Servlet 2.5中引入了一些对web.xml的小变动，使得部署配置更为方便。

 <filter-mapping>
  <filter-name>Image Filter</filter-name>
  <servlet-name>*</servlet-name>  <!-- 新特性 -->
</filter-mapping> 

 <filter-mapping>
  <filter-name>Dispatch Filter</filter-name>
  <servlet-name>*</servlet-name>
  <dispatcher>FORWARD</dispatcher>
</filter-mapping> 

<servlet-mapping>
  <servlet-name>color</servlet-name>
  <url-pattern>/color/*</url-pattern>
  <url-pattern>/colour/*</url-pattern>
</servlet-mapping> 

<filter-mapping>
  <filter-name>Multipe Mappings Filter</filter-name>
  <url-pattern>/foo/*</url-pattern>
  <servlet-name>Servlet1</servlet-name>
  <servlet-name>Servlet2</servlet-name>
  <url-pattern>/bar/*</url-pattern>
</filter-mapping> 

Servlet 2.4版使用XML Schema定义作为部署描述文件，这样使Web容器更容易校验web.xml语法。同时XML Schema提供了更好的扩充性。

DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">

        

变为在可以根元素指定属性，当然以前的方式也兼容

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"

Servlet 2.4在事件监听器中加入了ServletRequest监听器，包括新的API：ServletRequestListener， ServletRequestAttributeListener和其他相关类。这些类可以用来管理和控制与ServletRequest动作有关的事件。请参考第 43.2.5.2 节 “Application Events”

Servlet 2.4的Web程序增强了filter和request dispatcher的配合功能，这样过滤器可以根据请求分发器(request dispatcher)所使用的方法有条件地对Web请求进行过滤。请参考：第 43.2.5.1 节 “Servlet Filtering”

Servlet 2.4增加了Web程序国际化功能，在web.xml中可以定义网站的字符编码方式。

    <locale-encoding-mapping>
      <locale>zh</locale>
      <encoding>GB2312</encoding>
    </locale-encoding-mapping>

当客户请求了特定语言的Web资源时，servlet程序通过ServletResponse接口的setLocale方法设置一个Web响应的语言属性。

@Resource用来标记一个类或变量，请求servlet容器对其进行“资源注入”。当容器遇到这个注解时，将在servlet进入服务状态之前对变量赋予合适的值。通过这个注解，避免了在代码中显式使用一个JNDI查找调用以及在web.xml中声明资源。服务器自动通过反射机制完成这两个任务。注入资源可以是数据源、JMS目的地、或环境变量。以下是个简单的例子：

@Resource javax.sql.DataSource catalog;
public getData() {
  Connection con = catalog.getConnection();
} 

在servlet进入服务状态之前，容器将自动通过JNDI找到名为catalog，类型为DataSource的变量并将其引用赋值给此处的catalog变量。

@Resources注解作用与@Resource相似，用来包含一系列的@Resource注解

这两个注解把一个或多个类方法标记为生命周期回调方法。标记为@PostConstruct的方法将在资源注入后被回调，提供机会对注入的资源进行初始化。标记为@PreDestroy的方法将在servlet停止服务前被回调，提供机会释放注入的资源。这些回调方法必须为无返回值(void)且不抛出任何checked异常的非静态方法。在servlet中，这些注解的作用基本上是可以让任意方法成为第二个init()或destroy()方法。

与@Resource类似，但用于注入Enterprise JavaBeans引用。

与@Resource和@EJB类似，但用于注入Web service引用。

@PersistenceContext，@PersistenceContexts，@PersistenceUnit，@PersistenceUnits：在EJB3.0规范中定义的用于持久对象的注解。

定义了在应用中使用的安全角色。当用于servlet时，这个注解可作为web.xml文件中<security-role>标签的替代品。

声明一个类将以哪个角色的名义运行。当用于servlet时，这个注解可作为web.xml文件中<run-as>标签的替代品。

客户端请求（request）包含了从客户端传递到Servlet的数据。所有的请求(request)都实现了ServletRequest接口。这个接口定义了一些方法来访问下面的信息：

下面的代码片断示范了如何使用request中的方法获得客户端信息。

Enumeration params = request.getParameterNames();

String paramName = null;
String[] paramValues = null;

while (params.hasMoreElements()) {
    paramName = (String) params.nextElement();
    paramValues = request.getParameterValues(paramName);

    System.out.println("\nParameter name is " + paramName);

    for (int i = 0; i < paramValues.length; i++) {
      System.out.println(", value " + i + " is " + paramValues[i].toString());
    }
}

HTTP servlets使用HTTP request对象(HttpServletRequest)，它包含了request URL，HTTP头信息, 查询字符串等等。

HTTP request URL 包括几个部分：

http://<host>:<port><request path>?<query string>

一般情况下：

requestURI = contextPath + servletPath + pathInfo

例如：

响应(response)包含了在服务器和客户端之间传递的数据。所有的响应（response）都实现了ServletResponse接口。这个接口定义了一些方法提供给开发人员使用：

HTTP response类（HttpServletResponse）有一些代表HTTP头信息的域：

Servlet首先设置响应（response）头信息：响应（response）的内容类别和缓冲区大小，然后在doGet方法中从响应(response)获得PrintWriter，最后向输出中写入HTML代码，调用close()方法提交这次对客户端的响应（response）。

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

      // 设置头信息
      response.setContentType("text/html");
      response.setBufferSize(8192);
      PrintWriter out = response.getWriter();

      // 向response中输出
      out.println("<html>" +
         "<head><title>+
         messages.getString("TitleBookDescription")
         +</title></head>");
      ...
      out.println("</body></html>");

      // 关闭输出流
      out.close();
   }

Session表现为HttpSession对象。调用request对象的getSession方法访问session。这个方法返回当前客户端请求（request）所关联的session，如果不存在，则为当前请求（request）创建一个session。由于getSession方法可能会改变响应（response）的头信息，所以需要在获得PrintWriter或ServletOutputStream之前被调用。

可以通过名称使对象值属性和一个session相关联。例如把购物车作为属性存储在session中，在其他Servlet中可以通过session再获得购物车。

      // 得到用户session和购物篮
      HttpSession session = request.getSession();
      ShoppingCart cart =
         (ShoppingCart)session.
            getAttribute("cart");
      ...

由于没有办法知道HTTP客户端不再需要session，因此每个session都关联一个时间期限使它的资源可以被回收。通过session的setMaxInactiveInterval和getMaxInactiveInterval方法访问超时时间。

为了确保session的有效，不超时，开发人员应该在service方法中周期性的访问session。当客户端完成一个（组）完整的交互过程后，可以使用invalidate()方法使服务器端的session无效，并清除session数据。

      // 得到用户session和购物篮
      HttpSession session = request.getSession();

      // 付款完成，使session无效
      session.invalidate();
      ...

Web容器使用了一些方法使用户和特定的session相关联，这些方法在客户端与服务器端之间传递session的标识。这个标识可以作为cookies在客户端被维护，或者Web组件把这个标识包含在每个URL中返回到客户端。

如果应用需要使用session对象，那么开发人员必须确保在用户关闭cookies的情况下，应用能够改写URL使session跟踪功能激活。在所有返回给用户URL之前都调用response的encodeURL(URL)方法，这样在用户关闭cookies的情况下URL中就会包含session ID，否则不改变URL。 例如：

   out.println("<p> &nbsp; <p><strong><a href=\"" +

   response.encodeURL(request.getContextPath() + "/catalog") +
      "\">" + messages.getString("ContinueShopping") +
      "</a> &nbsp; &nbsp; &nbsp;" +
      "<a href=\"" +

   response.encodeURL(request.getContextPath() + "/cashier") +
      "\">" + messages.getString("Checkout") +
      "</a> &nbsp; &nbsp; &nbsp;" +
      "<a href=\"" +

   response.encodeURL(request.getContextPath() +
      "/showcart?Clear=clear") +
      "\">" + messages.getString("ClearCart") +
      "</a></strong>");

上面的代码改写了三个URL，如果客户端关闭 cookies，则URL被改写为:

http://localhost:6888/bookstore1/cashier; jsessionid=wKgUUxroPN$HVmpTkhU6YPLTqyMA

如果客户端cookies未关闭，则URL不作任何改变：

http://localhost:6888/bookstore1/cashier

包含其他Web资源非常有用，例如从Web组件返回给客户端的响应(response)中可以包含banner或版权（copyright）信息。调用RequestDispatcher对象的相关方法来实现此功能：

如果资源是静态的，include方法能够实现服务器端包含。如果资源是Web组件，那么执行include()方法的效果等同于：

1. 向被包含的Web组件发送请求

2. 执行Web组件

3. 把执行的结果返回给包含Web组件的Servlet

被包含的Web组件可以访问request对象，当访问response对象有一些限制：

以下BannerServlet用来产生Banner信息：

public class BannerServlet extends HttpServlet {

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

      PrintWriter out = response.getWriter();

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

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

      PrintWriter out = response.getWriter();
      out.println(" ... ");
   }
}

其他的servlet可以包含BannerServlet：

RequestDispatcher dispatcher =
   getServletContext().getRequestDispatcher("/banner");
if (dispatcher != null)
   dispatcher.include(request, response);
}

在一些应用中，也许需要一个Web组件对请求（request）作预处理，然后利用另一个Web组件产生响应（response）。可以调用RequestDispatcher对象的forward()方法实现这个功能。当一个请求（request）被转移，request URL会被设置成新的页面。如果原先的URL还有用，可以把它作为request的属性保存。以下Dispatcher类，从request中获得RequestDispatcher对象，然后把控制权交给template.jsp：

public class Dispatcher extends HttpServlet {
   public void doGet(HttpServletRequest request,
                     HttpServletResponse response) {

      request.setAttribute("selectedScreen",request.getServletPath());

      //从 request 中获得 RequestDispatcher 对象
      RequestDispatcher dispatcher = request.getRequestDispatcher("/template.jsp");

      //传递控制到template.jsp
      if (dispatcher != null)
         dispatcher.forward(request, response);
   }

   public void doPost(HttpServletRequest request,
   ...
}

forward()方法使另外的资源来答复客户端的请求（request）。如果已经访问了ServletOutputStream或PrintWriter，那么将不能使用include()方法，否则会抛出IllegalStateException异常。

编写过滤器的API是javax.servlet包中Filter、FilterChain和FilterConfig接口中定义的一些方法。定义一个过滤器就是实现Filter接口。Filter接口中最主要的方法是doFilter()方法，它接收三个参数：request对象、response对象、filterchain对象。

void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

这个方法能够执行的动作包括：

除了doFilter()方法，开发人员也必须实现init()和destroy()方法。当容器创建过滤器实例时调用init()方法，

 void init(FilterConfig filterConfig)

可以从FilterConfig对象中获得初始化参数。

在doFilter()方法中，过滤器可以从FilterConfig对象获得ServletContext对象，那么就可以访问存储在ServletContext中的属性对象。当过滤器完成特定的处理过程后，调用chain对象的doFilter()方法。例如

public final class HitCounterFilter implements Filter {
   private FilterConfig filterConfig = null;

   // 初始化
   public void init(FilterConfig filterConfig)
      throws ServletException {
      this.filterConfig = filterConfig;
   }
   // 结束
   public void destroy() {
      this.filterConfig = null;
   }

   public void doFilter(ServletRequest request,
      ServletResponse response, FilterChain chain)
           throws IOException, ServletException {

      if (filterConfig == null)
         return;

      StringWriter sw = new StringWriter();
      PrintWriter writer = new PrintWriter(sw);

      writer.println(" ... ");
        .
        .
        .
      writer.flush();

      // 输出日志
      filterConfig.getServletContext().
         log(sw.getBuffer().toString());
      ...

      //调用在过滤器链中的下一个实体
      chain.doFilter(request, wrapper);
      ...
   }
}

有许多方法可以改变请求（request）或者响应（response）。例如过滤器能够给请求（request）增加属性或在响应（response）中插入数据。

过滤器如果需要改变响应（response）必须在响应（response）返回给客户端之前捕获它。要做到这一点需要传递“替身”流（stream）给Servlet，然后利用“替身”stream产生响应（response）。“替身”stream防止了当响应（response）结束后关闭了原始的响应（response）输出流，并且允许过滤器改变Servlet的响应（response）。

过滤器产生“替身”stream

为了给Servlet传递“替身”stream，过滤器需要创建response对象的包装类并且覆盖getWriter或getOutputStream方法。包装类被FilterChain对象的doFilter方法传递。创建请求（request）的包装类继承ServletRequestWrapper或HttpServletRequestWrapper，创建响应（response）的包装类继承ServletResponseWrapper或HttpServletResponseWrapper。

以下CharResponseWrapper类包装了响应（response）：

public class CharResponseWrapper extends
   HttpServletResponseWrapper {

   private CharArrayWriter output;

   public String toString() {
      return output.toString();
   }

   public CharResponseWrapper(HttpServletResponse response){
      super(response);
      output = new CharArrayWriter();
   }

   public PrintWriter getWriter(){
      return new PrintWriter(output);
   }
}

包装类被传递给BookStoreServlet，BookStoreServlet把响应写入“替身”stream，当chain.doFilter返回，HitCounterFilter重新找回response把它写入缓冲，过滤器插入计数器值到缓冲中然后重新设置response的头信息，最后把缓冲中的内容写入response。

PrintWriter out = response.getWriter();
//构造包装类
CharResponseWrapper wrapper = new CharResponseWrapper(
   (HttpServletResponse)response);

//向 doFilter 传递包装类
chain.doFilter(request, wrapper);

CharArrayWriter caw = new CharArrayWriter();

caw.write(wrapper.toString().substring(0,
          wrapper.toString().indexOf("</body>")-1));
...

caw.write("\n</body></html>");

//重新设置响应长度
response.setContentLength(caw.toString().length());

out.write(caw.toString());
out.close();

Web容器使用过滤器映射来决定是否过滤Web资源。在Web应用的部署描述文件中映射过滤器到Servlet或URL模板。

如下图，可以映射一个过滤器到一个或多个Servlet，或者可以映射一个 Servlet到多个过滤器。

过滤器的映射

过滤器F1映射到servlet S1，S2和S3，过滤器F2映射到servlet S2，过滤器F3 映射到servlet S1和S2。

配置事件监听类的步骤：

1. 打开Web应用的部署描述文件web.xml

2. 增加事件声明标记<listener>。事件声明定义的事件监听类在事件发生时被调用。<listener>标记必须在<filter>和<filter-mapping>标记之后和<servlet>标记之前。可以为每种事件定义多个事件监听类，Apusic应用服务器按照它们在部署描述文件声明的顺序调用。例如：

<listener>
  <listener-class>myApp.myContextListenerClass</listener-class>
</listener>
<listener>
  <listener-class>myApp.mySessionAttributeListenerClass</listener-class>
</listener>

3. 编写和部署监听类。

编写事件监听类的步骤：

1. 创建新的类并实现事件对应的接口

2. 定义不接受参数、访问属性为public的构造函数

3. 实现接口的方法

4. 编译并拷贝到对应Web应用的WEB-INF/classes目录下，或者打包成jar文件拷贝到WEB-INF/lib目录下

ServletContext 监听类例子：

import javax.servlet.*;
public final class myContextListenerClass
            implements   ServletContextListener {
    public void contextInitialized(ServletContextEvent event) {

      /*
         当 ServletContext 初始化时被调用，可以在这儿
         初始化 ServletContext 的相关数据
      */

    }
    public void contextDestroyed(ServletContextEvent event) {
      /*
         当 Web 应用被卸载或 Apusic 服务器关闭时被调用
      */
    }
}

HttpSession 属性监听类例子：

import javax.servlet.*;
public final class mySessionAttributeListenerClass
             implements   HttpSessionAttributesListener {
    public void attributeAdded(HttpSessionBindingEvent sbe) {
      /*
         增加session属性时被调用
      */
    }
    public void attributeRemoved(HttpSessionBindingEvent sbe) {
      /*
         删除session属性时被调用
      */
    }
    public void attributeReplaced(HttpSessionBindingEvent sbe) {
      /*
         替换session属性时被调用
     */
    }
}

ServletRequest 属性监听类例子：

import javax.servlet.*;
public final class myRequestAttributeListenerClass
             implements   ServletRequestAttributeListener {
    public void attributeAdded(HttpSessionBindingEvent sbe) {
      /*
         增加request属性时被调用
      */
    }
    public void attributeRemoved(HttpSessionBindingEvent sbe) {
      /*
         删除request属性时被调用
      */
    }
    public void attributeReplaced(HttpSessionBindingEvent sbe) {
      /*
         替换request属性时被调用
     */
    }
}