Servlet 过滤器

　　过滤器Filter，是介于Servlet之前，可拦截过滤浏览器对Servlet的请求，也可以改变Servlet对浏览器的响应。

一、过滤器的概念

现在有以下几个请求：

1、针对所有的Servlet，产品经理想要了解从请求到响应之间的时间差。

2、针对某些特定的页面，希望仅有几个用户才能知道。

3、基于安全方面，用户希望输入的特定字符必须过滤并且替换为无害的字符。

4、请求与响应的编码从Big5改为UTF-8。

思路分析：

1、运行Servlet的service()方法前后，各记录一个时间，计算其差。：过滤器

2、运行Servlet的service()方法前，验证是否为允许的用户。

3、运行Servlet的service()方法前，对请求参数进行字符过滤与替换。

4、运行Servlet的service()方法前，对请求与响应对象设置编码。

性能评测、用户验证、字符替换、编码设置这类需求，应该设置为独立的元件，随时可以加入到应用程序中，这类元件就像过滤器，安插在浏览器与Servlet之间。如图、

二、过滤器的实现与设置

必须实现Filter接口，并用@WebFilter标注。Filter接口主要实现三个方法：init()、doFilter()、destroy()

FilterConfig类似于Servlet接口init()方法参数上的ServletConfig，FilterConfig设置信息的代表对象。如果定义过滤器时设置了初始参数，可以通过FilterConfig的getInitParameter()方法来取得初始参数。

Filter接口的doFilter()方法，类似Servlet接口的service()方法，当请求来到容器，而容器发现调用Servlet的service()方法前，就会调用该过滤器的doFilter()方法。可以再doFilter()方法中进行service()方法的前置处理，而后决定是否调用FilterChain的doFilter()方法。

如果调用了FilterChain的doFilter()方法，就会执行下一个过滤器，如果没有下一个过滤器了，就调用Servlet的service()方法，如果因为某个情况没有执行下一个过滤器(如，用户没有通过验证)而没有调用FilterChain的doFilter()方法，则请求就不会交给目标Servlet。FilterChain运行后会以堆栈顺序返回。

例1：实现简单的性能评测过滤器，记录请求和响应间的时间差，了解Servlet处理请求到响应所花的时间。

 1 package ServletAPI;
 2
 3 import java.io.IOException;
 4 import javax.servlet.Filter;
 5 import javax.servlet.FilterChain;
 6 import javax.servlet.FilterConfig;
 7 import javax.servlet.ServletException;
 8 import javax.servlet.ServletRequest;
 9 import javax.servlet.ServletResponse;
10 import javax.servlet.annotation.WebFilter;
11 import javax.servlet.annotation.WebInitParam;
12
13 /**
14  * Servlet Filter implementation class PerformanceFilter
15  */
16 @WebFilter(
17         filterName = "performance",
18         urlPatterns = { "/*" }
19         )
20 public class PerformanceFilter implements Filter {
21     private FilterConfig fConfig;
22     /**
23      * Default constructor.
24      */
25     public PerformanceFilter() {
26         // TODO Auto-generated constructor stub
27     }
28
29     /**
30      * @see Filter#destroy()
31      */
32     public void destroy() {
33         // TODO Auto-generated method stub
34     }
35
36     /**
37      * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
38      */
39     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
40         // TODO Auto-generated method stub
41         // place your code here
42
43         // pass the request along the filter chain
44         long begin=System.currentTimeMillis();
45         chain.doFilter(request, response);
46         fConfig.getServletContext().log("Request process in "+(System.currentTimeMillis()-begin)+" millseconds.");
47     }
48
49     /**
50      * @see Filter#init(FilterConfig)
51      */
52     public void init(FilterConfig fConfig) throws ServletException {
53         // TODO Auto-generated method stub
54         this.fConfig=fConfig;
55     }
56
57 }

PerformanceFilter.java

三、请求封装器

1、实现字符替换过滤器

假设用户不希望在留言中输入<a href=’http://openhome.cc’>openhome.cc</a>这样的信息，希望直接变成超链接。希望将一些html过滤掉，如将<、>角括号置换为HTML实体字符&lt;  &gt;

EscapeWrapper类继承了HttpServletRequestWrapper，并定义了一个接受HttpSevletRequest的构造器，真正的HttpSevletRequest将通过此构造器传入，必须使用super()调用HttpSevletRequestWrapper接受HttpSevletRequest的构造器，之后要取得被封装的HttpSevletRequest，则可以调用getRequest()方法。

 1 package ServletAPI;
 2 import javax.servlet.http.HttpServletRequest;
 3 import javax.servlet.http.HttpServletRequestWrapper;
 4
 5
 6 import org.apache.commons.lang3.StringEscapeUtils;
 7
 8 public class EscapeWrapper extends HttpServletRequestWrapper {
 9     public EscapeWrapper(HttpServletRequest request){
10         super(request);//必须调用父类的构造器，传入HttpServletRequest的实例。
11     }
12     public String getParameter(String name){//重新定义getParameter方法
13         String value=getRequest().getParameter(name);
14         return StringEscapeUtils.escapeHtml4(value);//将取得的请求参数值进行字符替换
15     }
16 }

EscapeWrapper.java

　　可以使用这个请求封装器类搭配过滤器，以进行字符过滤操作的服务。例如：

 1 package ServletAPI;
 2
 3 import java.io.IOException;
 4
 5 import javax.servlet.Filter;
 6 import javax.servlet.FilterChain;
 7 import javax.servlet.FilterConfig;
 8 import javax.servlet.ServletException;
 9 import javax.servlet.ServletRequest;
10 import javax.servlet.ServletResponse;
11 import javax.servlet.annotation.WebFilter;
12 import javax.servlet.http.HttpServlet;
13 import javax.servlet.http.HttpServletRequest;
14
15 /**
16  * Servlet Filter implementation class EscapeFilter
17  */
18 @WebFilter("/*")
19 public class EscapeFilter implements Filter {
20
21     /**
22      * Default constructor.
23      */
24     public EscapeFilter() {
25         // TODO Auto-generated constructor stub
26     }
27
28     /**
29      * @see Filter#destroy()
30      */
31     public void destroy() {
32         // TODO Auto-generated method stub
33     }
34
35     /**
36      * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
37      */
38     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
39         // TODO Auto-generated method stub
40         // place your code here
41
42         // pass the request along the filter chain
43         HttpServletRequest requestWrapper=new EscapeWrapper((HttpServletRequest) request);//将原请求对象包裹至EscapeWrapper中。
44
45         chain.doFilter(request, response);//将EscapeWrapper对象当做请求对象传入doFilter()
46     }
47
48     /**
49      * @see Filter#init(FilterConfig)
50      */
51     public void init(FilterConfig fConfig) throws ServletException {
52         // TODO Auto-generated method stub
53     }
54
55 }

EscapeFilter.java

　　运行结果：

　　　　

2、实现编码设置过滤器

实现方式：过滤器+封装器

 1 package ServletAPI;
 2
 3 import java.io.UnsupportedEncodingException;
 4
 5 import javax.servlet.http.HttpServletRequest;
 6 import javax.servlet.http.HttpServletRequestWrapper;
 7
 8 public class EncodingWrapper extends HttpServletRequestWrapper{
 9     private String ENCODING;
10     public EncodingWrapper(HttpServletRequest request,String ENCODING){
11         super(request);
12         this.ENCODING=ENCODING;
13     }
14     public String getParameter(String name){
15         String value=getRequest().getParameter(name);
16         if(value!=null){
17             try {
18                 byte[] b=value.getBytes("ISO-8859-1");
19                 value=new String(b,ENCODING);//编码转换
20             } catch (UnsupportedEncodingException e) {
21                 // TODO: handle exception
22                 throw new RuntimeException(e);
23             }
24         }
25         return value;
26     }
27 }

EncodingWrapper.java

 1 package ServletAPI;
 2
 3 import java.io.IOException;
 4
 5 import javax.servlet.Filter;
 6 import javax.servlet.FilterChain;
 7 import javax.servlet.FilterConfig;
 8 import javax.servlet.ServletException;
 9 import javax.servlet.ServletRequest;
10 import javax.servlet.ServletResponse;
11 import javax.servlet.annotation.WebFilter;
12 import javax.servlet.annotation.WebInitParam;
13 import javax.servlet.http.HttpServletRequest;
14
15 import org.omg.CORBA.PUBLIC_MEMBER;
16
17 /**
18  * Servlet Filter implementation class EncodingFilter
19  */
20 @WebFilter(
21         urlPatterns = { "/*" },
22         initParams = {
23                 @WebInitParam(name = "ENCODING", value = "UTF-8")
24         })
25 public class EncodingFilter implements Filter {
26     private String ENCODING;
27     /**
28      * Default constructor.
29      */
30     public EncodingFilter() {
31         // TODO Auto-generated constructor stub
32     }
33
34     /**
35      * @see Filter#destroy()
36      */
37     public void destroy() {
38         // TODO Auto-generated method stub
39     }
40
41     /**
42      * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
43      */
44     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
45         // TODO Auto-generated method stub
46         // place your code here
47
48         // pass the request along the filter chain
49         HttpServletRequest req=(HttpServletRequest)request;
50         if("GET".equals(req.getMethod())){
51             req=new EncodingWrapper(req,ENCODING);//GET请求时创建封装器
52         }
53         else{
54             req.setCharacterEncoding(ENCODING);
55         }
56         chain.doFilter(request, response);
57     }
58
59     /**
60      * @see Filter#init(FilterConfig)
61      */
62     public void init(FilterConfig fConfig) throws ServletException {
63         // TODO Auto-generated method stub
64         ENCODING=fConfig.getInitParameter("ENCODING");//读取初始参数
65     }
66
67 }

EncodingFilter.java

四、响应封装器

Servlet是通过HttpServletResponse对象来对浏览器进行响应的，通过getWriter()取得PrintWriter，或是通过getOutputStream()取得ServletOutputStream。如果想要对响应的内容进行压缩处理，主要继承了HttpServletResponseWrapper之后，重新定义这两个方法实现的。

用GZIPOutputStream类实现压缩，其增加了压缩输出功能，重新定义writer()方法，通过GZIPOutputStream的writer()方法来做串流输出，GZIPOutputStream的writer()实现了压缩的功能。

 1 package ServletAPI;
 2
 3 import java.io.IOException;
 4 import java.util.zip.GZIPOutputStream;
 5
 6 import javax.servlet.ServletOutputStream;
 7
 8 public class GZipServletOutputStream  extends ServletOutputStream{
 9     private GZIPOutputStream gzipOutputStream;
10     public GZipServletOutputStream(ServletOutputStream servletOutputStream) throws IOException{
11         this.gzipOutputStream=new GZIPOutputStream(servletOutputStream);
12         //使用GZIPOutputStream来增加压缩功能。
13     }
14     @Override
15     public void write(int b) throws IOException {
16         // TODO Auto-generated method stub
17         gzipOutputStream.write(b);//输出时通过GZIPOutputStream的write()方法来压缩输出
18     }
19     public GZIPOutputStream getGzipOutputStream(){
20         return gzipOutputStream;
21     }
22
23 }

GZipServletOutputStream.java

 1 package ServletAPI;
 2
 3 import java.io.IOException;
 4 import java.io.OutputStreamWriter;
 5 import java.io.PrintWriter;
 6 import java.util.zip.GZIPOutputStream;
 7
 8 import javax.servlet.ServletOutputStream;
 9 import javax.servlet.http.HttpServletResponse;
10 import javax.servlet.http.HttpServletResponseWrapper;
11
12 public class CompressionWrapper extends HttpServletResponseWrapper {
13     private GZipServletOutputStream gzServletOutputStream;
14     private PrintWriter printWriter;
15     public CompressionWrapper(HttpServletResponse response) {
16         super(response);
17         // TODO Auto-generated constructor stub
18
19     }
20     public ServletOutputStream getOutputStream()throws IOException{
21         if(printWriter!=null){
22             throw new IllegalStateException();//已调用过getWriter()，再调用getOutputStream()就抛出异常
23         }
24         if(gzServletOutputStream==null){
25             gzServletOutputStream=new GZipServletOutputStream(getResponse().getOutputStream());
26             //创建有压缩功能的GZipServletOutputStram对象
27         }
28         return gzServletOutputStream;
29     }
30     public PrintWriter getWriter() throws IOException{
31         if(gzServletOutputStream!=null){
32             throw new IllegalStateException();//已调用过getOutputStream()，再调用getWriter()就抛出异常
33         }
34         if(printWriter==null){
35             gzServletOutputStream=new GZipServletOutputStream(getResponse().getOutputStream());
36             OutputStreamWriter osw= new OutputStreamWriter(gzServletOutputStream,getResponse().getCharacterEncoding());
37             //创建GzipServletOutputStream对象，供构造PrintWriter时使用
38             printWriter=new PrintWriter(osw);
39         }
40         return printWriter;
41     }
42
43     public void setContentLength(int len){}//不实现此方法内容，因为真正的输出会压缩
44     public GZIPOutputStream getGZIPOutputStream(){
45         if(this.gzServletOutputStream==null){
46             return null;
47         }
48         return this.gzServletOutputStream.getGzipOutputStream();
49     }
50 }

CompressionWrapper.java

　　在同一个请求期间，getWriter()和getOutputStream()只能选择一个调用。接下来实现一个压缩过滤器，使用上面开发的CompressionWrapper来封装原HttpServletResponse。

 1 package ServletAPI;
 2
 3 import java.io.IOException;
 4 import java.util.zip.GZIPOutputStream;
 5
 6 import javax.servlet.Filter;
 7 import javax.servlet.FilterChain;
 8 import javax.servlet.FilterConfig;
 9 import javax.servlet.ServletException;
10 import javax.servlet.ServletRequest;
11 import javax.servlet.ServletResponse;
12 import javax.servlet.annotation.WebFilter;
13 import javax.servlet.http.HttpServletRequest;
14 import javax.servlet.http.HttpServletResponse;
15
16 /**
17  * Servlet Filter implementation class CompressionFilter
18  */
19 @WebFilter(filterName="CompressionFilter",urlPatterns="/*")
20 public class CompressionFilter implements Filter {
21
22     /**
23      * Default constructor.
24      */
25     public CompressionFilter() {
26         // TODO Auto-generated constructor stub
27     }
28
29     /**
30      * @see Filter#destroy()
31      */
32     public void destroy() {
33         // TODO Auto-generated method stub
34     }
35
36     /**
37      * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
38      */
39     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
40         // TODO Auto-generated method stub
41         // place your code here
42
43         // pass the request along the filter chain
44         HttpServletRequest req=(HttpServletRequest)request;
45         HttpServletResponse res=(HttpServletResponse)response;
46         String encoding=req.getHeader("accept-encoding");
47
48         if((encoding!=null)&&(encoding.indexOf("gzip")>-1)){//检查是否接受gzip压缩
49             CompressionWrapper responseWrapper=new CompressionWrapper(res);//创建响应封装器
50             responseWrapper.setHeader("content-encoding","gzip");//设置响应内容编码为gzip格式
51             chain.doFilter(request, responseWrapper);//下一个过滤器
52             GZIPOutputStream gzipOutputStream=responseWrapper.getGZIPOutputStream();
53             if(gzipOutputStream!=null){
54                 gzipOutputStream.finish();//调用GZIPOutputStream的finish方法来完成压缩输出。
55             }
56         }else{
57             chain.doFilter(request, response);//不接受压缩，直接进行下一个过滤器
58         }
59     }
60
61     /**
62      * @see Filter#init(FilterConfig)
63      */
64     public void init(FilterConfig fConfig) throws ServletException {
65         // TODO Auto-generated method stub
66     }
67
68 }

CompressionFilter.java

　　浏览器是否采用GZIP压缩的格式，可以通过检查accept-encoding请求标头中是否包括gzip字符串来判断，如果接受，就创建CompressionWrapper封装原对象，并设置content-encoding响应标头为gzip即可。接着调用doFilter()时，传入的响应对象为CompressionWrapper对象。当doFilter()结束时，必须调用GZIPOutputStream的finish()方法，这才会将GZIP后的资料从缓冲区中全部移除并进行响应。

如果客户端不接受GZIP压缩，就直接调用FilterChain的doFilter()。

时间： 2024-10-16 16:35:25

Servlet 过滤器的相关文章

Servlet过滤器和监听器知识总结(转)

 Servlet过滤器是 Servlet 程序的一种特殊用法,主要用来完成一些通用的操作,如编码的过滤.判断用户的登录状态.过滤器使得Servlet开发者能够在客户端请求到达 Servlet资源之前被截获,在处理之后再发送给被请求的Servlet资源,并且还可以截获响应,修改之后再发送给用户.而Servlet监听器可以  监听客户端发出的请求.服务器端的操作,通过监听器,可以自动激发一些操作,如监听在线人数.  Servlet过滤器简介绍      Servlet过滤器是在Java Servle

JavaWeb servlet过滤器

一.Filter简介: *************************************************************************************** Filter也称之为过滤器,它是Servlet技术中最实用的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件 或静态 html 文件等进行拦截,从而实现一些特殊的功能.例如实现URL级别的权限访问控制.过滤敏感词汇.压缩响应信

java基础篇---Servlet过滤器

Servlet过滤器从字面上的字意理解为景观一层次的过滤处理才达到使用的要求,而其实Servlet过滤器就是服务器与客户端请求与响应的中间层组件,在实际项目开发中Servlet过滤器主要用于对浏览器的请求进行过滤处理,将过滤后的请求再转给下一个资源. 过滤器的基本概念 Filter是在Servlet 2.3之后增加的新功能,当需要限制用户访问某些资源或者在处理请求时提前处理某些资源的时候,就可以使用过滤器完成. 过滤器是以一种组件的形式绑定到WEB应用程序当中的,与其他的WEB应用程序组件不同的

Servlet过滤器介绍之原理分析

zhangjunhd 的BLOG   写留言去学院学习发消息 加友情链接进家园 加好友 博客统计信息 51CTO博客之星 用户名:zhangjunhd文章数:110 评论数:858访问量:1923464无忧币:6720博客积分:6145博客等级:8注册日期:2007-02-03 热门专题更多>> Linux系统基础之菜鸟进阶 阅读量:2359 ARM驱动之Linux驱动程序设计入门 阅读量:2252 HTML5入门教程 阅读量:1392 深入浅出学MySQL 阅读量:1558 热门文章 基于T

JSP详细篇——Servlet过滤器和监听器

过滤器和监听器 Servlet过滤器是从Servlet2.3规范开始新增的功能,并在Servlet2.4规范中得到增强,监听器可以监听到Web应用程序启动和关闭.创建监听器需要实现响应的接口,并对其进行配置. Servlet过滤器 1.什么是过滤器 Servlet过滤器与Servlet十分相似,但是它具有拦截客户端请求的功能.Servlet过滤器可以改变请求中的内容,来满足实际开发中的需要.对于程序开发人员来说,过滤器实质上就是在Web应用服务器上的一个Web应用组件,用于拦截客户端与目标资源之

Servlet过滤器Filter用法

1 Servlet 过滤器方法 过滤器是一个实现了 javax.servlet.Filter 接口的 Java 类.javax.servlet.Filter 接口定义了三个方法:public void doFilter (ServletRequest, ServletResponse, FilterChain)该方法完成实际的过滤操作,当客户端请求方法与过滤器设置匹配的URL时,Servlet容器将先调用过滤器的doFilter方法.FilterChain用户访问后续过滤器. public vo

Servlet过滤器Filter

Filter与Listener是Servlet规范里的两个高级特性.不用于处理客户端请求,只用于对request,response进行修改或者对context,session,request事件进行监听.善于处理一些特殊问题. sun公司在Servlet2.3规范中添加了Filter功能,并在Servlet2.4中对Filter进行了细节的补充.ServletFilter提现的是设计模式中的Filter模式. 实例参考: http://book.51cto.com/art/201004/1934

代理Servlet过滤器

Spring Security借助一些列Servlet 过滤器 来提供 各种 安全性功能. 我们只需要在应用中的 web.xml 中配置 一个过滤器. <filter> <filter-name>springSecurityFilterChain</filter-name> <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> </

Servlet过滤器---基础

过滤器的基本概念 Servlet过滤器从字面上的字意理解为经过一层次的过滤处理才达到使用的要求,而其实Servlet过滤器就是服务器与客户端请求与响应的中间层组件,在实际项目开发中Servlet过滤器主要用于对浏览器的请求进行过滤处理,将过滤后的请求再转给下一个资源. Filter是在Servlet 2.3之后增加的新功能,当需要限制用户访问某些资源或者在处理请求时提前处理某些资源的时候,就可以使用过滤器完成. 过滤器是以一种组件的形式绑定到WEB应用程序当中的,与其他的WEB应用程序组件不同的

JavaWeb学习篇之----Servlet过滤器Filter和监听器

JavaWeb学习篇之----Servlet过滤器Filter和监听器 首先来看一下Servlet的过滤器内容: 一.Servlet过滤器的概念: *************************************************************************************** Servlet过滤器是在Java Servlet规范2.3中定义的,它能够对Servlet容器的请求和响应对象进行检查和修改. Servlet过滤器本身并不产生请求和响应对象,