Khan's Notebook GCC/GNU/Linux Delphi/Window Java/Anywhere

servlet API的2.3版本中最重要的一个新功能就是能够为servlet和JSP页面定义过滤器。过滤器提供了某些早期服务器所支持的非标准“servlet链接”的一种功能强大且标准的替代品。
过滤器是一个程序，它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息。在这之后，过滤器可以作如下的选择：
l 以常规的方式调用资源（即，调用servlet或JSP页面）。
l 利用修改过的请求信息调用资源。
l 调用资源，但在发送响应到客户机前对其进行修改
l 阻止该资源调用，代之以转到其他的资源，返回一个特定的状态代码或生成替换输出。
过滤器提供了几个重要好处。
首先，它以一种模块化的或可重用的方式封装公共的行为。你有30个不同的serlvet或JSP页面，需要压缩它们的内容以减少下载时间吗？没问题：构造一个压缩过滤器（参阅第11节），然后将它应用到30个资源上即可。
其 次，利用它能够将高级访问决策与表现代码相分离。这对于JSP特别有价值，其中一般希望将几乎整个页面集中在表现上，而不是集中在业务逻辑上。例如，希望 阻塞来自某些站点的访问而不用修改各页面（这些页面受到访问限制）吗？没问题：建立一个访问限制过滤器（参阅第8节）并把它应用到想要限制访问的页面上即 可。
最后，过滤器使你能够对许多不同的资源进行批量性的更改。你有许多现存资源，这些资源除了公司名要更改外其他的保持不变，能办到么？没问题：构造一个串替换过滤器（参阅第10节），只要合适就使用它。
但要注意，过滤器只在与servlet规范2.3版兼容的服务器上有作用。如果你的Web应用需要支持旧版服务器，就不能使用过滤器。
1．  建立基本过滤器
建立一个过滤器涉及下列五个步骤：
1）建立一个实现Filter接口的类。这个类需要三个方法，分别是：doFilter、init和destroy。doFilter方法包含主要的过滤代码（见第2步），init方法建立设置操作，而destroy方法进行清楚。
2） 在doFilter方法中放入过滤行为。doFilter方法的第一个参数为ServletRequest对象。此对象给过滤器提供了对进入的信息（包括 表单数据、cookie和HTTP请求头）的完全访问。第二个参数为ServletResponse，通常在简单的过滤器中忽略此参数。最后一个参数为 FilterChain，如下一步所述，此参数用来调用servlet或JSP页。
3）调用FilterChain对象的doFilter方法。 Filter接口的doFilter方法取一个FilterChain对象作为它的一个参数。在调用此对象的doFilter方法时，激活下一个相关的过 滤器。如果没有另一个过滤器与servlet或JSP页面关联，则servlet或JSP页面被激活。
4）对相应的servlet和JSP页面注册过滤器。在部署描述符文件（web.xml）中使用filter和filter-mapping元素。
5）禁用激活器servlet。防止用户利用缺省servlet URL绕过过滤器设置。
1.1  建立一个实现Filter接口的类
所有过滤器都必须实现javax.servlet.Filter。这个接口包含三个方法，分别为doFilter、init和destroy。
l public void doFilter(ServletRequset request, 
                    ServletResponse response,
                    FilterChain chain)
    thows ServletException, IOException
每当调用一个过滤器（即，每次请求与此过滤器相关的servlet或JSP页面）时，就执行其doFilter方法。正是这个方法包含了大部分过滤逻辑。
第 一个参数为与传入请求有关的ServletRequest。对于简单的过滤器，大多数过滤逻辑是基于这个对象的。如果处理HTTP请求，并且需要访问诸如 getHeader或getCookies等在ServletRequest中无法得到的方法，就要把此对象构造成 HttpServletRequest。
第二个参数为ServletResponse。除了在两个情形下要使用它以外，通常忽略这个参数。首先， 如果希望完全阻塞对相关servlet或JSP页面的访问。可调用response.getWriter并直接发送一个响应到客户机。第7节给出详细内 容，第8节给出一个例子。其次，如果希望修改相关的servlet或JSP页面的输出，可把响应包含在一个收集所有发送到它的输出的对象中。然后，在调用 serlvet或JSP页面后，过滤器可检查输出，如果合适就修改它，之后发送到客户机。详情请参阅第9节。
DoFilter的最后一个参数为FilterChain对象。对此对象调用doFilter以激活与servlet或JSP页面相关的下一个过滤器。如果没有另一个相关的过滤器，则对doFilter的调用激活servlet或JSP本身。
l public void init(FilterConfig config)
    thows ServletException
init 方法只在此过滤器第一次初始化时执行，不是每次调用过滤器都执行它。对于简单的过滤器，可提供此方法的一个空体，但有两个原因需要使用init。首先， FilterConfig对象提供对servlet环境及web.xml文件中指派的过滤器名的访问。因此，普遍的办法是利用init将 FilterConfig对象存放在一个字段中，以便doFilter方法能够访问servlet环境或过滤器名。这种处理在第3节描述。其次， FilterConfig对象具有一个getInitParameter方法，它能够访问部署描述符文件（web.xml）中分配的过滤器初始化参数。初 始化参数的使用在第5节中描述。
l public void destroy( )
此方法在利用一个给定的过滤器对象永久地终止服务器（如关闭服务器）时调用。大多数过滤器简单地为此方法提供一个空体，不过，可利用它来完成诸如关闭过滤器使用的文件或数据库连接池等清除任务。
1.2  将过滤行为放入doFilter方法
doFilter 方法为大多数过滤器地关键部分。每当调用一个过滤器时，都要执行doFilter。对于大多数过滤器来说，doFilter执行的步骤是基于传入的信息 的。因此，可能要利用作为doFilter的第一个参数提供的ServletRequest。这个对象常常构造为HttpServletRequest类 型，以提供对该类的更特殊方法的访问。
1.3  调用FilterChain对象的doFilter方法
Filter接口的 doFilter方法以一个FilterChain对象作为它的第三个参数。在调用该对象的doFilter方法时，激活下一个相关的过滤器。这个过程一 般持续到链中最后一个过滤器为止。在最后一个过滤器调用其FilterChain对象的doFilter方法时，激活servlet或页面自身。
但是，链中的任意过滤器都可以通过不调用其FilterChain的doFilter方法中断这个过程。在这样的情况下，不再调用JSP页面的serlvet，并且中断此调用过程的过滤器负责将输出提供给客户机。详情请参阅第7节。
1.4  对适当的servlet和JSP页面注册过滤器
部署描述符文件的2.3版本引入了两个用于过滤器的元素，分别是：filter和filter-mapping。filter元素向系统注册一个过滤对象，filter-mapping元素指定该过滤对象所应用的URL。
1.filter元素
filter元素位于部署描述符文件（web.xml）的前部，所有filter-mapping、servlet或servlet-mapping元素之前。filter元素具有如下六个可能的子元素：
l icon  这是一个可选的元素，它声明IDE能够使用的一个图象文件。
l filter-name  这是一个必需的元素，它给过滤器分配一个选定的名字。
l display-name  这是一个可选的元素，它给出IDE使用的短名称。
l description  这也是一个可选的元素，它给出IDE的信息，提供文本文档。
l filter-class  这是一个必需的元素，它指定过滤器实现类的完全限定名。
l init-param  这是一个可选的元素，它定义可利用FilterConfig的getInitParameter方法读取的初始化参数。单个过滤器元素可包含多个init-param元素。
请注意，过滤是在serlvet规范2.3版中初次引入的。因此，web.xml文件必须使用DTD的2.3版本。下面介绍一个简单的例子：


2.filter-mapping元素
filter-mapping元素位于web.xml文件中filter元素之后serlvet元素之前。它包含如下三个可能的子元素：：
l filter-name  这个必需的元素必须与用filter元素声明时给予过滤器的名称相匹配。
l url-pattern  此元素声明一个以斜杠（/）开始的模式，它指定过滤器应用的URL。所有filter-mapping元素中必须提供url- pattern或servlet-name。但不能对单个filter-mapping元素提供多个url-pattern元素项。如果希望过滤器适用于 多个模式，可重复整个filter-mapping元素。
l servlet-name  此元素给出一个名称，此名称必须与利用servlet元素给予servlet或JSP页面的名称相匹配。不能给单个 filter-mapping元素提供多个servlet-name元素项。如果希望过滤器适合于多个servlet名，可重复这个filter- mapping元素。
下面举一个例子：

1.5  禁用激活器servlet
在 对资源应用过滤器时，可通过指定要应用过滤器的URL模式或servlet名来完成。如果提供servlet名，则此名称必须与web.xml的 servlet元素中给出的名称相匹配。如果使用应用到一个serlvet的URL模式，则此模式必须与利用web.xml的元素servlet- mapping指定的模式相匹配。但是，多数服务器使用“激活器servlet”为servlet体统一个缺省的URL：http: //host/WebAppPrefix/servlet/ServletName。需要保证用户不利用这个URL访问servlet（这样会绕过过滤器 设置）。
例如，假如利用filter和filter-mapping指示名为SomeFilter的过滤器应用到名为SomeServlet的servlet，则如下：


接着，用servlet和servlet-mapping规定URL  http://host/webAppPrefix/Blah 应该调用SomeSerlvet，如下所示：



现在，在客户机使用URL  http://host/webAppPrefix/Blah 时就会调用过滤器。过滤器不应用到
http://host/webAppPrefix/servlet/SomePackage.SomeServletClass。
尽 管有关闭激活器的服务器专用方法。但是，可移植最强的方法时重新映射Web应用钟的/servlet模式，这样使所有包含此模式的请求被送到相同的 servlet中。为了重新映射此模式，首先应该建立一个简单的servlet，它打印一条错误消息，或重定向用户到顶层页。然后，使用servlet和 servlet-mapping元素发送包含/servlet模式的请求到该servlet。程序清单9-1给出了一个简短的例子。

程序清单9-1 web.xml（重定向缺省servlet URL的摘录）


2．  样例：报告过滤器
趁热打铁，我们来试验一个简单的过滤器，只要调用相关的servlet或JSP页面，它就打印一条消息到标准输出。为了完成此任务，相应的过滤器必须具有下面的内容：
1）实现Filter接口的一个类。这个类名为ReportFilter，如程序清单9-2所示。这个类对init和destroy方法提供空体。
2） 在doFilter方法中过滤行为。每当调用与这个过滤器相关的servlet或JSP页面时，doFilter方法就生成一个打印输出，此输出列出请求 主机和调用的URL。因为getRequestURL方法位于HttpServletRequest而不是ServletRequest中，所以把 ServletRequest对象构造为HttpServletRequest类型。
3）调用FilterChain的doFilter方法。在打印输出报告后，过滤器调用FilterChain的doFilter方法激活servlet或JSP页面（如果有的话，调用下一个过滤器）
4） 对Web应用主页和显示TodaysSpecialservlet进行注册。首先，filter元素将名称Reporter与类 moreservlets.filters.ReportFilter相关联。然后，filter-mapping元素使用/index.jsp的url -pattern将过滤器与主页相关联。最后，filter-mapping元素使用TodaysSpecial的servlet-name将过滤器与 TodaysSpecialservlet（名称TodaysSpecial是在servlet元素中声明的）相关联。参见程序清单9-3。
5） 禁用激活器servlet。首先，建立一个RedirectorServlet（见程序清单9-6），它把接收到的所有请求重定向到此Web应用的主页。 接着，利用servlet和servlet-mapping元素（参见程序清单9-3）指定所有以http: //host/webAppPrefix/servlet/ 开始的URL都应该激活RedirectorServlet。
给出这些设置后，每当客户机请求此Web应用主页（程序清单9-4）或TodaysSpecialservlet（程序清单9-5）时，都调用此过滤器。

程序清单9-2 ReportFilter.java

 

package moreservlets.filters;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*; // For Date class

/** Simple filter that prints a report on the standard output
* each time an associated servlet or JSP page is accessed.
*/

public class ReportFilter implements Filter {
  public void doFilter(ServletRequest request,
                  ServletResponse response,
                  FilterChain chain)
      throws ServletException, IOException {
    HttpServletRequest req = (HttpServletRequest)request;
    System.out.println(req.getRemoteHost() +
                   " tried to access " +
                   req.getRequestURL() +
                   " on " + new Date() + ".");
    chain.doFilter(request,response);
  }

  public void init(FilterConfig config)
      throws ServletException {
  }

  public void destroy() {}
}

程序清单9-3 web.xml（针对报告过滤器的摘录）

<?xml version="1.0" encoding="ISO-8859-1"?>
    <!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd">
    <web-app>
      <!-- Register the name "Reporter" for ReportFilter. -->
      <filter>
        <filter-name>Reporter</filter-name>
        <filter-class>
          moreservlets.filters.ReportFilter
        </filter-class>
      </filter>
      <!-- ... -->
      <!-- Apply the Reporter filter to home page. -->
      <filter-mapping>
        <filter-name>Reporter</filter-name>
        <url-pattern>/index.jsp</url-pattern>
      </filter-mapping>
      <!-- Also apply the Reporter filter to the servlet named
          "TodaysSpecial".
      -->
      <filter-mapping>
        <filter-name>Reporter</filter-name>
        <servlet-name>TodaysSpecial</servlet-name>
      </filter-mapping>
      <!-- ... -->
    
      <!-- Give a name to the Today's Special servlet so that filters
          can be applied to it.
      -->
      <servlet>
        <servlet-name>TodaysSpecial</servlet-name>
        <servlet-class>
          moreservlets.TodaysSpecialServlet
        </servlet-class>
      </servlet>
      <!-- ... -->
    
      <!-- Make /TodaysSpecial invoke the servlet
          named TodaysSpecial (i.e., moreservlets.TodaysSpecial).
      -->
      <servlet-mapping>
        <servlet-name>TodaysSpecial</servlet-name>
        <url-pattern>/TodaysSpecial</url-pattern>
      </servlet-mapping>
    
      <!-- Turn off invoker. Send requests to index.jsp. -->
      <servlet-mapping>
        <servlet-name>Redirector</servlet-name>
        <url-pattern>/servlet/*</url-pattern>
      </servlet-mapping>
      <!-- ... -->
    </web-app>

 

程序清单9-4 index.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>Filters 'R' Us</TITLE>
<LINK REL=STYLESHEET
        HREF="filter-styles.css"
        TYPE="text/css">
</HEAD>
<BODY>
<CENTER>
<TABLE BORDER=5>
  <TR><TH CLASS="TITLE">Filters 'R' Us</TABLE>
<P>
<TABLE>
  <TR>
    <TH><IMG SRC="images/air-filter.jpg" ALT="Air Filter">
    <TH><IMG SRC="images/coffee-filter.gif" ALT="Coffee Filter">
    <TH><IMG SRC="images/pump-filter.jpg" ALT="Pump Filter">
  </TR>
</TABLE>

<H3>We specialize in the following:</H3>
<UL>
  <LI>Air filters
  <LI>Coffee filters
  <LI>Pump filters
  <LI>Camera lens filters
  <LI>Image filters for Adobe Photoshop
  <LI>Web content filters
  <LI>Kalman filters
  <LI>Servlet and JSP filters
</UL>
Check out <A HREF="TodaysSpecial">Today's Special</A>.
</CENTER>
</BODY>
</HTML>


程序清单9-5 TodaysSpecialServlet.java
package moreservlets;

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

/** Sample servlet used to test the simple filters. */

public class TodaysSpecialServlet extends HttpServlet {
  private String title, picture;

  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
        throws ServletException, IOException {
    updateSpecials();
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    String docType =
        "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 " +
        "Transitional//EN\">\n";
        out.println
        (docType +
        "<HTML>\n" +
        "<HEAD><TITLE>Today's Special</TITLE></HEAD>\n" +
        "<BODY BGCOLOR=\"WHITE\">\n" +
        "<CENTER>\n" +
        "<H1>Today's Special: " + title + "s!</H1>\n" +
        "<IMG SRC=\"images/" + picture + "\"\n" +
        " ALT=\"" + title + "\">\n" +
        "<BR CLEAR=\"ALL\">\n" +
        "Special deal: for only twice the price, you can\n" +
        "<I>buy one, get one free!</I>.\n" +
        "</BODY></HTML>");
  }

  // Rotate among the three available filter images.

  private void updateSpecials() {
    double num = Math.random();
    if (num < 0.333) {
      title = "Air Filter";
      picture = "air-filter.jpg";
    } else if (num < 0.666) {
      title = "Coffee Filter";
      picture = "coffee-filter.gif";
    } else {
      title = "Pump Filter";
      picture = "pump-filter.jpg";
    }
  }
}


程序清单9-6 RedirectorServlet.java
package moreservlets;

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

/** Servlet that simply redirects users to the
* Web application home page. Registered with the
* default servlet URL to prevent clients from
* using http://host/webAppPrefix/servlet/ServletName
* to bypass filters or security settings that
* are associated with custom URLs.
*/

public class RedirectorServlet extends HttpServlet {
  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
        throws ServletException, IOException {
    response.sendRedirect(request.getContextPath());
  }

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


3．  从过滤器中访问servlet环境
前 一节的ReportFilter只要调用指定的servlet或JSP页面，就在标准输出上打印一个报告。当你在自己的桌面系统上运行一个服务器时，一般 会用一个显示标准输出的窗口，在开发过程中，标准输出上的报告很好用。但在部署过程中，不可能访问这个窗口。因此，一种自然的改进是将报告写入 servlet日志文件写到标准输出。
Servlet API提供了两个log方法：一个取一个简单的String而另一个取一个String和 一个Throwable。这两个方法都可以从GenericServlet或ServletContext类中使用。关于这两个方法所用的日志文件的准确 位置，请查看相关服务器的帮助文档。问题是doFilter方法在与其相关的serlvet或JSP页面之前执行。因此，你不能访问该servlet的实 例，从而不能调用从GenericServlet继承的log方法。此外，API没有体统从doFilter方法中访问ServletContext的简 单方法。可以访问ServletContext的方法并且与过滤器相关的唯一类是FilterConfig，访问ServletContext的方法为 getServletContext。FilterConfig对象被传输给init方法，但不会自动存放到doFilter可使用的某个位置。
因 此，你必须自己存放FilterConfig。可建立一个FilterConfig类型的字段，然后重载init，将它的参数分配给该字段。因为一般只使 用FilterConfig对象来访问ServletContext和过滤器名，所以可以存放该ServletContext和名称在字段中。相面举一个 例子：
    public class SomeFilter implements Filter {
      protected FilterConfig config;
      private ServletContext context;
      private String filterName;
      public void init(FilterConfig config)
            throws ServletException {
        this.config = config; // In case it is needed by subclass.
        context = config.getServletContext();
        filterName = config.getFilterName();
      }

    // doFilter and destroy methods...
    }
4．  例子：日志记录过滤器
我们来更新ReportFilter（程序清单9-2），以便消息进入日志文件而不是标准输出。为了完成这个任务，过滤器应该具有下列内容：
1）实现Filter接口的一个类。这个类名为LogFilter，如程序清单9-7所示。这个类的init方法在过滤器的字段中存放FilterConfig、ServletContext和过滤器名。它对destory方法提供一个空体。
2）在doFilter方法中过滤行为。这个行为和ReportFilter的行为之间有两点不同：报告放于日志文件中而不是标准输出中，报告包括过滤器的名称。
3）调用FilterChain的doFilter方法。在打印出报告后，此过滤器调用FilterChain的doFilter方法激活链中的下一个过滤器（如果没有更多的过滤器，则激活servlet或JSP页面）。
4） 对所有URL进行注册。首先，filter元素将名称LogFilter与类moreservlets.filters.LogFilter相关联。接 着，filter-mapping元素使用值为/*的url-pattern将此过滤器与Web应用中所有URL相关联。参看程序清单9-8。
5）禁用激活servlet。这个操作已经在第2节介绍过，这里就不再重复了。
当 这个Web应用部署在一个外部服务器上且附加了日志记录过滤器后，客户机对此Web应用主页的请求将在日志文件中产生一个项，如： “audits.irs.gov tired to acces http://www.filtersrus.com/filters/index.jsp on Fri Oct 26 15: 16:15 EDT 2001.(Reported by Logger.)”。

程序清单9-7 LogFilter.java
package moreservlets.filters;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*; // For Date class

/** Simple filter that prints a report in the log file
* whenever the associated servlets or JSP pages
* are accessed.
*/

public class LogFilter implements Filter {
  protected FilterConfig config;
  private ServletContext context;
  private String filterName;
  public void doFilter(ServletRequest request,
                       ServletResponse response,
                       FilterChain chain)
        throws ServletException, IOException {
    HttpServletRequest req = (HttpServletRequest)request;
    context.log(req.getRemoteHost() +
                " tried to access " +
                req.getRequestURL() +
                " on " + new Date() + ". " +
                "(Reported by " + filterName + ".)");
    chain.doFilter(request,response);
  }

  public void init(FilterConfig config)
        throws ServletException {
    this.config = config; // In case it is needed by subclass.
    context = config.getServletContext();
    filterName = config.getFilterName();
  }

  public void destroy() {}

}


程序清单9-8 web.xml（针对日志记录过滤器的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC
    "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
  <!-- ... -->

  <!-- Register the name "Logger" for LogFilter. -->
  <filter>
    <filter-name>Logger</filter-name>
    <filter-class>
      moreservlets.filters.LogFilter
    </filter-class>
  </filter>
  <!-- ... -->

  <!-- Apply the Logger filter to all servlets and
  JSP pages.
  -->
  <filter-mapping>
    <filter-name>Logger</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- ... -->
</web-app>


5．  利用过滤器的初始化参数
对于servlet和JSP页面，可通过提供初始化参数定制初始化行为。这个功能之所以游泳的原因在于有三组不同的人员可能希望定制servlet或JSP页面的行为，这三组人员分别为：
1）开发人员——他们通过更改serlvet或JSP页面的代码定制相应的行为。
2）最终用户——他们通过在HTML表单中输入值来定制相应的行为。
3） 部署人员——这是提供初始化参数服务的一组人员。这组人员是那些获得现存Web应用（或个别的servlet或JSP页面）并在一个定制环境环境中部署它 们的人员。他们不一定是开发人员，因此期望他们修改servlet和JSP代码是不现实的。但由于过滤器在它们所附加的servlet或JSP页面之前执 行，最终用户一般不能定制过滤器的行为，这种能力仍然很有用。定制过滤器的行为用如下步骤完成：
1）定义初始化参数。使用web.xml中的filter的init-param子元素以及param-nam和param-value子元素，如下所示。

    <filter>
      <filter-name>SomeFilter</filter-name>
      <filter-class>somePackage.SomeFilterClass</filter-class>
      <init-param>
        <param-name>param1</param-name>
        <param-value>value1</param-value>
      </init-param>
      <init-param>
        <param-name>param2</param-name>
        <param-value>value2</param-value>
      </init-param>
    </filter>

2）读初始化参数。从过滤器的inti方法中调用FilterConfig的getInitParameter方法。如下所示。

    public void init(FilterConfig config)
        throws ServletException {
      String val1 = config.getInitParameter("param1");
      String val2 = config.getInitParameter("param2");
      ...
    }

3） 分析初始化参数。就像servlet和JSP的初始化参数一样，每个过滤器的初始化都是String类型的。因此，如果想要其他类型的值，必须对它进行转 换。例如，可用Integer.parseInt将String“7”转换为int 7。在分析时，别忘了检查缺少的和不良的数据。缺少初始化参数将导致 从getInitParameter返回null。即使这些参数存在，也一个来考虑到部署人员不正确地对其值进行格式化的可能性。例如，在转换 String类型的值为int类型的值时，应该将Integer.parseInt调用封在try/catch中，这个块捕捉 NumberFormatException。这种办法彻底地处理了null和格式化不正确的值。
6．  例子：访问时的过滤器
第4节的 LogFilter，每当相关的servlet或JSP页面被访问时，就在日志文件中打印一个项。假如想修改它，使它只注意不寻常时刻出现的访问。因为 “不寻常”要视具体情况而定，servlet应该提供不寻常时间范围的缺省值，并允许部署人员通过初始化参数来重载这些值。为了完成这种功能，相应的过滤 器应该具有下面的内容：
1）实现Filter接口的一个类。这个类名为LateAccessFilter，如程序清单9-9所示。这个类的 init方法读取startTime和endTime初始化参数。它尝试作为init分析这些值，如果这些参数为null或未格式化为整数，这使用缺省 值。然后，它将开始和结束事件、FilterConfig、ServletContext以及过滤器名存入过滤器的字段。最后， LateAccessFilter对destroy方法提供一个空体。
2）在doFilter方法中过滤行为。这个方法查找当前事件，看它问是否在开始时间和结束事件给出的范围内，如果是，打印一个日志项。
3）调用FilterChain的doFilter方法。在打印出报告后，此过滤器调用FilterChain的doFilter方法激活链中的下一个过滤器（如果没有更多的过滤器，则激活servlet或JSP页面）。
4） 对Web应用主页进行注册；定义初始化参数。首先，filter元素将名称LateAccessFilter与类 moreservlets.filters.LateAccessFilter相关联。filter元素还包含两个init-param子元素：一个定义 startTime参数，另一个定义endTime参数。因为将要访问filterRus主页的人是程序员，考虑反常的时间范围为上午2:00到10: 00之间。最后，filter-mapping元素使用值为/index.jsp的ulr-pattern子元素，将此过滤器与Web应用主页相关联。参 看程序清单9-10。
5）己用激活器serlvet。这个已经在第2节介绍过，不再重复。
当这个Web应用部署在一个外部服务器上且附加 了日志记录过滤器后，客户机对此Web应用主页的请求将在日志文件中产生一个项，如：“WARNING:  hacker6.filtersrus.com accessed http://www.filtersrus.com/filters/index.jsp on Oct 30,2001 9: 22:09 AM.”。

程序清单9-9 LateAccessFilter.java
package moreservlets.filters;

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

/** Filter that keeps track of accesses that occur
* at unusual hours.
*/
public class LateAccessFilter implements Filter {
  private FilterConfig config;
  private ServletContext context;
  private int startTime, endTime;
  private DateFormat formatter;
  public void doFilter(ServletRequest request,
                       ServletResponse response,
                       FilterChain chain)
        throws ServletException, IOException {
    HttpServletRequest req = (HttpServletRequest)request;
    GregorianCalendar calendar = new GregorianCalendar();
    int currentTime = calendar.get(calendar.HOUR_OF_DAY);
    if (isUnusualTime(currentTime, startTime, endTime)) {
      context.log("WARNING: " +
      req.getRemoteHost() +
      " accessed " +
      req.getRequestURL() +
      " on " +
      formatter.format(calendar.getTime()));
    }
    chain.doFilter(request,response);
  }

  public void init(FilterConfig config)
        throws ServletException {
    this.config = config;
    context = config.getServletContext();
    formatter =
      DateFormat.getDateTimeInstance(DateFormat.MEDIUM,
    DateFormat.MEDIUM);
    try {
      startTime =
        Integer.parseInt(config.getInitParameter("startTime"));
      endTime =
        Integer.parseInt(config.getInitParameter("endTime"));
    } catch(NumberFormatException nfe) { // Malformed or null
      // Default: access at or after 10 p.m. but before 6 a.m.
      // is considered unusual.
      startTime = 22; // 10:00 p.m.
      endTime = 6; // 6:00 a.m.
    }
  }

  public void destroy() {}

  // Is the current time between the start and end
  // times that are marked as abnormal access times?

  private boolean isUnusualTime(int currentTime,
                                int startTime,
                                int endTime) {
    // If the start time is less than the end time (i.e.,
    // they are two times on the same day), then the
    // current time is considered unusual if it is
    // between the start and end times.
    if (startTime < endTime) {
      return((currentTime >= startTime) &&
      (currentTime < endTime));
    }
    // If the start time is greater than or equal to the
    // end time (i.e., the start time is on one day and
    // the end time is on the next day), then the current
    // time is considered unusual if it is NOT between
    // the end and start times.
    else {
      return(!isUnusualTime(currentTime, endTime, startTime));
    }
  }
}


程序清单9-10 web.xml（针对访问时过滤器的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC
    "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
    <!-- ... -->

    <!-- Register the name "LateAccessFilter" for
        moreservlets.filter.LateAccessFilter.
        Supply two initialization parameters:
        startTime and endTime.
    -->
    <filter>
      <filter-name>LateAccessFilter</filter-name>
      <filter-class>
        moreservlets.filters.LateAccessFilter
      </filter-class>
      <init-param>
        <param-name>startTime</param-name>
        <param-value>2</param-value>
      </init-param>
      <init-param>
        <param-name>endTime</param-name>
        <param-value>10</param-value>
      </init-param>
    </filter>
    <!-- ... -->

    <!-- Apply LateAccessFilter to the home page. -->
    <filter-mapping>
      <filter-name>LateAccessFilter</filter-name>
      <url-pattern>/index.jsp</url-pattern>
    </filter-mapping>

    <!-- ... -->
</web-app>