JAVA 过滤器的实现

关注

转载最新推荐文章于 2026-03-28 09:39:50 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

java过滤器（Filter） filter也称之为过滤器，它是javaWeb三大组件之一（Servlet程序、Listener监听器、Filter过滤器）既可以对请求进行拦截，也可以对响应进行处理。权限检查，日记操作、拦截请求、过滤操作、对请求字符设置编码。要想介绍filter，就必须介绍Filter中的三个方法。/*** web应用启动时，web服务器将创建Filter的实例对象，并调用init方法，读取web.xml的配置，完成对象的初始化功能，阅读详情

一个过滤器是一个可以传送请求或者修改相应的对象。

过滤器并不是Servlet,它们并不实际创建一个请求。它们是请求到达一个Servlet前的预处理程序，在相应离开Servlet后的后处理程序。

一个过滤器能够做如下的工作：

（1）在一个servlet被调用前截获该调用

（2）在一个servlet被调用前检查请求

（3）修改在实际请求中提供了可定制请求对象的请求头和请求数据

（4）修改在实际响应中提供了可定制响应对象的响应头和响应数据

（5）在一个servlet被调用之后截获该调用

一个过滤器实现java.servlet.Filter接口

init: 在过滤器执行service前被调用，以设置过滤器的配置对象

destroy: 在过滤器执行service后被调用

doFilter: 执行实际的过滤工作

下面给个例子，使用这个过滤器来计算执行某个servlet所用时间并记录在日志内：

[java] view plaincopy 
    
 import java.io.*;  
 import javax.servlet.*;  
 import.servlet.http.*;  
 //实现一个过滤器  
 public class TimerFilter implements Filter{  
   private FilterConfig config = null;  
     
   public void init(FilterConfig config) throws ServletException{  
     this.config = config;  
   }  
   public void destroy(){  
     config = null;  
   }  
   public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain)throws IOException,ServletException{  
     long before = System.currentTimeMillis();  
     chain.doFilter(request,response);  
     long after = System.currentTimeMillis();  
     String name = "";  
     if(request instanceof HttpServletRequset){  
       name = ((HttpServletRequest)request).getRequestURI();  
     }  
     //记录时间  
     config.getServletContext().log(name+": "+(after-before) + "ms");  
   }  
 }  

使用此过滤器，还需要在web.xml文件中用<filter>标签部署它

<filter-name>timerFilter</filter-name>

<filter-class>TimerFilter</filter-class>

</filter>

[java]view plaincopy 
    
 一、使浏览器不缓存页面的过滤器       
 import javax.servlet.*;      
 import javax.servlet.http.HttpServletResponse;      
 import java.io.IOException;      
      
 /**    
 * 用于的使 Browser 不缓存页面的过滤器    
 */     
 public class ForceNoCacheFilter implements Filter {      
      
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException      
 {      
     ((HttpServletResponse) response).setHeader("Cache-Control","no-cache");      
     ((HttpServletResponse) response).setHeader("Pragma","no-cache");      
     ((HttpServletResponse) response).setDateHeader ("Expires", -1);      
     filterChain.doFilter(request, response);      
 }      
      
 public void destroy()      
 {      
 }      
      
       public void init(FilterConfig filterConfig) throws ServletException      
 {      
 }      
 }      
      
 二、检测用户是否登陆的过滤器      
      
 import javax.servlet.*;      
 import javax.servlet.http.HttpServletRequest;      
 import javax.servlet.http.HttpServletResponse;      
 import javax.servlet.http.HttpSession;      
 import java.util.List;      
 import java.util.ArrayList;      
 import java.util.StringTokenizer;      
 import java.io.IOException;      
      
 /**    
 * 用于检测用户是否登陆的过滤器，如果未登录，则重定向到指的登录页面     
    
    
 * 配置参数     
    
    
 * checkSessionKey 需检查的在 Session 中保存的关键字    
    
 * redirectURL 如果用户未登录，则重定向到指定的页面，URL不包括 ContextPath    
    
 * notCheckURLList 不做检查的URL列表，以分号分开，并且 URL 中不包括 ContextPath    
    
 */     
 public class CheckLoginFilter      
 implements Filter      
 {      
       protected FilterConfig filterConfig = null;      
       private String redirectURL = null;      
       private List notCheckURLList = new ArrayList();      
       private String sessionKey = null;      
      
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException      
 {      
     HttpServletRequest request = (HttpServletRequest) servletRequest;      
     HttpServletResponse response = (HttpServletResponse) servletResponse;      
      
      HttpSession session = request.getSession();      
     if(sessionKey == null)      
     {      
      filterChain.doFilter(request, response);      
      return;      
     }      
     if((!checkRequestURIIntNotFilterList(request)) && session.getAttribute(sessionKey) == null)      
     {      
      response.sendRedirect(request.getContextPath() + redirectURL);      
      return;      
     }      
     filterChain.doFilter(servletRequest, servletResponse);      
 }      
      
 public void destroy()      
 {      
     notCheckURLList.clear();      
 }      
      
 private boolean checkRequestURIIntNotFilterList(HttpServletRequest request)      
 {      
     String uri = request.getServletPath() + (request.getPathInfo() == null ? "" : request.getPathInfo());      
     return notCheckURLList.contains(uri);      
 }      
      
 public void init(FilterConfig filterConfig) throws ServletException      
 {      
     this.filterConfig = filterConfig;      
     redirectURL = filterConfig.getInitParameter("redirectURL");      
     sessionKey = filterConfig.getInitParameter("checkSessionKey");      
      
     String notCheckURLListStr = filterConfig.getInitParameter("notCheckURLList");      
      
     if(notCheckURLListStr != null)      
     {      
      StringTokenizer st = new StringTokenizer(notCheckURLListStr, ";");      
      notCheckURLList.clear();      
      while(st.hasMoreTokens())      
      {      
       notCheckURLList.add(st.nextToken());      
      }      
     }      
 }      
 }      
      
 三、字符编码的过滤器      
      
 import javax.servlet.*;      
 import java.io.IOException;      
      
 /**    
 * 用于设置 HTTP 请求字符编码的过滤器，通过过滤器参数encoding指明使用何种字符编码,用于处理Html Form请求参数的中文问题    
 */     
 public class CharacterEncodingFilter      
 implements Filter      
 {      
 protected FilterConfig filterConfig = null;      
 protected String encoding = "";      
      
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException      
 {      
           if(encoding != null)      
            servletRequest.setCharacterEncoding(encoding);      
           filterChain.doFilter(servletRequest, servletResponse);      
 }      
      
 public void destroy()      
 {      
     filterConfig = null;      
     encoding = null;      
 }      
      
       public void init(FilterConfig filterConfig) throws ServletException      
 {      
            this.filterConfig = filterConfig;      
           this.encoding = filterConfig.getInitParameter("encoding");      
      
 }      
 }      
      
 四、资源保护过滤器      
      
      
 package catalog.view.util;      
      
 import javax.servlet.Filter;      
 import javax.servlet.FilterConfig;      
 import javax.servlet.ServletRequest;      
 import javax.servlet.ServletResponse;      
 import javax.servlet.FilterChain;      
 import javax.servlet.ServletException;      
 import javax.servlet.http.HttpServletRequest;      
 import java.io.IOException;      
 import java.util.Iterator;      
 import java.util.Set;      
 import java.util.HashSet;      
 //      
 import org.apache.commons.logging.Log;      
 import org.apache.commons.logging.LogFactory;      
      
 /**    
 * This Filter class handle the security of the application.    
 *     
 * It should be configured inside the web.xml.    
 *     
 * @author Derek Y. Shen    
 */     
 public class SecurityFilter implements Filter {      
 //the login page uri      
 private static final String LOGIN_PAGE_URI = "login.jsf";      
        
 //the logger object      
 private Log logger = LogFactory.getLog(this.getClass());      
        
 //a set of restricted resources      
 private Set restrictedResources;      
        
 /**    
    * Initializes the Filter.    
    */     
 public void init(FilterConfig filterConfig) throws ServletException {      
    this.restrictedResources = new HashSet();      
    this.restrictedResources.add("/createProduct.jsf");      
    this.restrictedResources.add("/editProduct.jsf");      
    this.restrictedResources.add("/productList.jsf");      
 }      
        
 /**    
    * Standard doFilter object.    
    */     
 public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)      
     throws IOException, ServletException {      
    this.logger.debug("doFilter");      
         
    String contextPath = ((HttpServletRequest)req).getContextPath();      
    String requestUri = ((HttpServletRequest)req).getRequestURI();      
         
    this.logger.debug("contextPath = " + contextPath);      
    this.logger.debug("requestUri = " + requestUri);      
         
    if (this.contains(requestUri, contextPath) && !this.authorize((HttpServletRequest)req)) {      
     this.logger.debug("authorization failed");      
     ((HttpServletRequest)req).getRequestDispatcher(LOGIN_PAGE_URI).forward(req, res);      
    }      
    else {      
     this.logger.debug("authorization succeeded");      
     chain.doFilter(req, res);      
    }      
 }      
        
 public void destroy() {}       
        
 private boolean contains(String value, String contextPath) {      
    Iterator ite = this.restrictedResources.iterator();      
         
    while (ite.hasNext()) {      
     String restrictedResource = (String)ite.next();      
          
     if ((contextPath + restrictedResource).equalsIgnoreCase(value)) {      
      return true;      
     }      
    }      
         
    return false;      
 }      
        
 private boolean authorize(HttpServletRequest req) {      
      
                //处理用户登录      
         /* UserBean user = (UserBean)req.getSession().getAttribute(BeanNames.USER_BEAN);    
       
    if (user != null && user.getLoggedIn()) {    
     //user logged in    
     return true;    
    }    
    else {    
     return false;    
    }*/     
 }      
 }   