servlet过滤器Filter入门(转，有自己的例子)

ipsen2006

关注

原创最新推荐文章于 2026-05-04 00:30:00 发布 7.6k 阅读 AI 写同款· GEO 优化 ›

5.过滤器Filter(doFilter()+chain.doFilter()) 过滤器是对Web应用程序的请求和响应添加功能的Web服务组件(实现 javax.servlet.Filter 接口的 Java 类。调用web资源之前添加功能;//定义了一个MyFilter过滤器Filter 过滤器它是 JavaWeb 的三大组件之一。三大组件分别是：Servlet 程序、Listener 监听器、Filter 过滤器。阅读详情

servlet API中最重要的一个功能就是能够为servlet和JSP页面定义过滤器。过滤器提供了某些早期服务器所支持的非标准“servlet链接”的一种功能强大且标准的替代品。

过滤器是一个程序，它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息。在这之后，过滤器可以作如下的选择：

1. 以常规的方式调用资源（即，调用servlet或JSP页面）。

2.利用修改过的请求信息调用资源。

3. 调用资源，但在发送响应到客户机前对其进行修改

4. 阻止该资源调用，代之以转到其他的资源，返回一个特定的状态代码或生成替换输出。

过滤器提供了几个重要好处。
      首先，它以一种模块化的或可重用的方式封装公共的行为。你有30个不同的serlvet或JSP页面，需要压缩它们的内容以减少下载时间吗？没问题：构造一个压缩过滤器，然后将它应用到30个资源上即可。

　　其次，利用它能够将高级访问决策与表现代码相分离。这对于JSP特别有价值，其中一般希望将几乎整个页面集中在表现上，而不是集中在业务逻辑上。例如，希望阻塞来自某些站点的访问而不用修改各页面（这些页面受到访问限制）吗？没问题：建立一个访问限制过滤器并把它应用到想要限制访问的页面上即可。

     最后，过滤器使你能够对许多不同的资源进行批量性的更改。你有许多现存资源，这些资源除了公司名要更改外其他的保持不变，能办到么？没问题：构造一个串替换过滤器，只要合适就使用它。

     但要注意，过滤器只在与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。

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并直接发送一个响应到客户机。其次，如果希望修改相关的servlet或JSP页面的输出，可把响应包含在一个收集所有发送到它的输出的对象中。然后，在调用serlvet或JSP页面后，过滤器可检查输出，如果合适就修改它，之后发送到客户机。

DoFilter的最后一个参数为FilterChain对象。对此对象调用doFilter以激活与servlet或JSP页面相关的下一个过滤器。如果没有另一个相关的过滤器，则对doFilter的调用激活servlet或JSP本身。

public void init(FilterConfig config)   thows ServletException

init方法只在此过滤器第一次初始化时执行，不是每次调用过滤器都执行它。对于简单的过滤器，可提供此方法的一个空体，但有两个原因需要使用init。首先，FilterConfig对象提供对servlet环境及web.xml文件中指派的过滤器名的访问。因此，普遍的办法是利用init将FilterConfig对象存放在一个字段中，以便doFilter方法能够访问servlet环境或过滤器名.其次，FilterConfig对象具有一个getInitParameter方法，它能够访问部署描述符文件（web.xml）中分配的过滤器初始化参数。

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，并且中断此调用过程的过滤器负责将输出提供给客户机。

1.4   对适当的servlet和JSP页面注册过滤器
     部署描述符文件的2.3版本引入了两个用于过滤器的元素，分别是：filter和filter-mapping。filter元素向系统注册一个过滤对象，filter-mapping元素指定该过滤对象所应用的URL。

1.filter元素
filter元素位于部署描述符文件（web.xml）的前部，所有filter-mapping、servlet或servlet-mapping元素之前。filter元素具有如下六个可能的子元素：

1、 icon   这是一个可选的元素，它声明IDE能够使用的一个图象文件。
2、filter-name   这是一个必需的元素，它给过滤器分配一个选定的名字。
3、display-name   这是一个可选的元素，它给出IDE使用的短名称。
4、 description   这也是一个可选的元素，它给出IDE的信息，提供文本文档。
5、 filter-class   这是一个必需的元素，它指定过滤器实现类的完全限定名。
6、 init-param   这是一个可选的元素，它定义可利用FilterConfig的getInitParameter方法读取的初始化参数。单个过滤器元素可包含多个init-param元素。

请注意，过滤是在serlvet规范2.3版中初次引入的。因此，web.xml文件必须使用DTD的2.3版本。下面介绍一个简单的例子：

<? 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 >
      < filter >
         < filter-name > MyFilter </ filter-name >
         < filter-class > myPackage.FilterClass </ filter-class >
       </ filter >
       
       < filter-mapping > ... </ filter-mapping >
     </ web-app >

2.filter-mapping元素
    filter-mapping元素位于web.xml文件中filter元素之后serlvet元素之前。它包含如下三个可能的子元素：

1、 filter-name   这个必需的元素必须与用filter元素声明时给予过滤器的名称相匹配。

2、 url-pattern   此元素声明一个以斜杠（/）开始的模式，它指定过滤器应用的URL。所有filter-mapping元素中必须提供url-pattern或servlet-name。但不能对单个filter-mapping元素提供多个url-pattern元素项。如果希望过滤器适用于多个模式，可重复整个filter-mapping元素。

3、 servlet-name   此元素给出一个名称，此名称必须与利用servlet元素给予servlet或JSP页面的名称相匹配。不能给单个filter-mapping元素提供多个servlet-name元素项。如果希望过滤器适合于多个servlet名，可重复这个filter-mapping元素。
下面举一个例子：

<? 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 >
       < filter >
         < filter - name > MyFilter </ filter - name >
         < filter - class > myPackage.FilterClass </ filter - class >
       </ filter >
       
       < filter - mapping >
         < filter - name > MyFilter </ filter - name >
         < url - pattern >/ someDirectory / SomePage.jsp </ url - pattern >
       </ filter - mapping >
     </ web - app >

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，则如下：

< filter >
       < filter-name > SomeFilter </ filter-name >
       < filter-class > somePackage.SomeFilterClass </ filter-class >
     </ filter >
     
     < filter-mapping >
       < filter-name > SomeFilter </ filter-name >
       < servlet-name > SomeServlet </ servlet-name >
     </ filter-mapping >

接着，用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的摘录）

<? 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 >
     
     < servlet >
       < servlet-name > Error </ servlet-name >
       < servlet-class > somePackage.ErrorServlet </ servlet-class >
     </ servlet >
     
     < servlet-mapping >
       < servlet-name > Error </ servlet-name >
       < url-pattern > /servlet/* </ url-pattern >
     </ servlet-mapping >
     
     </ web-app >

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>
       
       <filter>
         <filter-name>Reporter</filter-name>
         <filter-class>
           moreservlets.filters.ReportFilter
         </filter-class>
       </filter>
       
       
       <filter-mapping>
         <filter-name>Reporter</filter-name>
         <url-pattern>/index.jsp</url-pattern>
       </filter-mapping>
       
       <filter-mapping>
         <filter-name>Reporter</filter-name>
         <servlet-name>TodaysSpecial</servlet-name>
       </filter-mapping>
       

       
       <servlet>
         <servlet-name>TodaysSpecial</servlet-name>
         <servlet-class>
           moreservlets.TodaysSpecialServlet
         </servlet-class>
       </servlet>
       

       
       <servlet-mapping>
         <servlet-name>TodaysSpecial</servlet-name>
         <url-pattern>/TodaysSpecial</url-pattern>
       </servlet-mapping>

       
       <servlet-mapping>
         <servlet-name>Redirector</servlet-name>
         <url-pattern>/servlet/*</url-pattern>
       </servlet-mapping>
       
     </web-app>

------------------------------------------------------------------------------------------------------------------

下面是一个完整的例子：

testFilter.java

//建立一个实现Filter接口的类。这个类需要三个方法，分别是：doFilter、init和destroy。
//doFilter方法包含主要的过滤代码，init方法建立设置操作，而destroy方法进行清
package filterpkg;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class testFilter implements Filter{

public void init(FilterConfig filterConfig) throws ServletException
{
}
//在doFilter方法中放入过滤行为。doFilter方法的第一个参数为ServletRequest对象。
//此对象给过滤器提供了对进入的信息（包括表单数据、cookie和HTTP请求头）的完全访问。
//第二个参数为ServletResponse，通常在简单的过滤器中忽略此参数。
//最后一个参数为FilterChain，如下一步所述，此参数用来调用servlet或JSP页。
public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain filterChain)
{
   PrintWriter wout=null;
try
      {
      wout=response.getWriter();
      }
      catch(IOException e)
      {
      }
HttpServletRequest req=(HttpServletRequest)request;//将request转化为它的子类HttpServletRequest
   String uri=req.getRequestURI();//获得传入的URI
   if (uri.indexOf("MyJsp.jsp")>0 ||uri.indexOf("MainForm.do")>0 )//如果是我们指定的登录页面或验证页面
   {
       try
       {
//调用FilterChain对象的doFilter方法。Filter接口的doFilter方法取一个FilterChain对象作为它的一个参数。
//在调用此对象的doFilter方法时，激活下一个相关的过滤器。如果没有另一个过滤器与servlet或JSP页面关联，则servlet或JSP页面被激活。
        filterChain.doFilter(request, response);
       }
       catch(Exception e)
      {
      }
      return;
   }

   if (req.getSession()!=null)
      if (req.getSession().getAttribute("USERID")==null)
      {
        wout.write("<HTML><BODY> Check error! <br/>   </BODY> </HTML>");
        wout.flush();
       return;
      }
      try
      {
      filterChain.doFilter(request, response);
      }
      catch(Exception e)
      {
      }
  }

public void destroy()
{
}
}
MyJsp.jsp

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

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

<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <base href="<%=basePath%>">

    <title>My JSP 'MyJsp.jsp' starting page</title>

<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">

</head>

<body>
   <%//登录页面，过滤器的FilterChain对象将会激活这个页面，而提交form后的MainForm.do是用于检验用户登录的servlet
   //注意这里的MainForm.do是在web.xml中映射的虚拟目录。
   %>

    <form action="MainForm.do" method="post" >

     Input EmpNO: <input type=text name="ENO" value=""><br/>
     Input EmpPWD <input type ="password" name="PWD" value=""><br/>
     Input Check Code <input type="text" name="CODE" >12345 <br/>

     <input type="submit" name="SEND">
<p/>
</form>
   <%
      Date dt=new Date();
      String dstr="当前日期：" +dt.toString();

     out.print(dstr);

    %>


</body>
</html>
ControlServlet.java

package filterpkg;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import java.sql.*;

import javax.servlet.http.*;
import javax.servlet.*;

//写一个类，继承HttpServlet，就是Servlet
public class ControlServlet extends HttpServlet {

public ControlServlet() {
super();
}

public void destroy() {
super.destroy(); // Just puts "destroy" string in log
// Put your code here
}

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

  response.setContentType("text/html");
  PrintWriter out = response.getWriter();
  out
    .println("<!DOCTYPE HTML PUBLIC /"-//W3C//DTD HTML 4.01 Transitional//EN/">");
  out.println("<HTML>");
  out.println(" <HEAD><TITLE>A Servlet</TITLE></HEAD>");
  out.println(" <BODY>");
  out.print("    This is ");
  out.print(this.getClass());
  out.println(", using the GET method");
  out.println(" </BODY>");
  out.println("</HTML>");
  out.flush();
  out.close();
}

/**
* The doPost method of the servlet. <br>
*
* This method is called when a form has its tag value method equals to post.
*
* @param request the request send by the client to the server
* @param response the response send by the server to the client
* @throws ServletException if an error occurred
* @throws IOException if an error occurred
*/
public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  String Eno,pwd,empname;
  Eno=request.getParameter("ENO");//request是servlet的内置对象，我们可以直接调用
  pwd=request.getParameter("PWD");

  try
  {
   Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");//注册数据库驱动
  }
  catch(Exception e)
  {
        }

  try
  {
  //连接数据库
  Connection cnn=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;DataBaseName=jyx","sa","" );
  //产生Statement对象
  Statement st=cnn.createStatement();
  //返回结果集
  ResultSet rs= st.executeQuery("select * from employee where code='"+Eno+"' and password='"+pwd+"'");
         if (rs.next())//如果记录存在
         {
          HttpSession se= request.getSession(true);

          empname=rs.getString("NAME");

          se.setAttribute("USERID",Eno);//记录在session中
          se.setAttribute("PASSWORD",pwd);

         request.setAttribute("NAME", empname);
         RequestDispatcher dispatcher=request.getRequestDispatcher("MainForm.jsp");
         dispatcher.forward(request,response);

         }
         else
         {

        // MyJsp.jsp

         }
        rs.close();
        st.close();
        cnn.close();
       }
  catch(SQLException e )
  {

  }

}

/**
* Initialization of the servlet. <br>
*
* @throws ServletException if an error occure
*/
public void init() throws ServletException {
// Put your code here
}

}
MainForm.jsp

<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <base href="<%=basePath%>">

    <title>My JSP 'MainForm.jsp' starting page</title>

<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">

</head>

<body>
<%=request.getAttribute("NAME")%>
This is my JSP page. <br>
</body>
</html>
web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app 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">

<filter>
    <filter-name>CHECKCODE</filter-name>
    <filter-class>filterpkg.testFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>CHECKCODE</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<servlet>
    <description>This is the description of my J2EE component</description>
    <display-name>This is the display name of my J2EE component</display-name>
    <servlet-name>ControlServlet</servlet-name>
    <servlet-class>filterpkg.ControlServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>ControlServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>

收录于