过滤器

一、概述

过滤器，又叫拦截器，属于Servlet中的技术，Since Servlet2.3。使用Filter技术可以对web服务器管理的所有web资源，例如JSP、Servlet、静态资源等进行拦截，从而实现一些特殊的功能（后面会有八个案例）。

二、快速入门

1）过滤器编写步骤

① 在Web工程中新建Java类实现Filter接口，并实现doFilter()方法【可打印一句话，来证明能够进行拦截】

public class FilterDemo1 implements Filter {    // 应用被加载时完成过滤器的实例化    public FilterDemo1() {        System.out.println("调用了默认构造方法");    }    // 初始化：服务器传入FilterConfig参数    public void init(FilterConfig filterConfig) throws ServletException {        System.out.println("调用初始化方法");    }    // 用户每次访问被过滤资源都会调用过滤器的doFilter方法    public void doFilter(ServletRequest request, ServletResponse response,            FilterChain chain) throws IOException, ServletException {        System.out.println("FilterDemo1第一次拦截");        // 对request、response进行预处理，代码放在chain.doFilter()前        chain.doFilter(request, response);// 放行        // 对响应信息进行拦截，代码放在chain.doFilter()后        System.out.println("FilterDemo1第二次拦截");    }    // 应用从服务器上卸载时调用销毁方法    public void destroy() {        System.out.println("调用销毁方法");    }}

② 在web.xml中配置Filter（filter、filter-mapping元素），指定拦截范围【类似Servlet配置，配置完成后，访问一个页面，看看拦截效果】：

<filter>    <filter-name>FilterDemo1</filter-name>    <filter-class>org.flyne.filter.FilterDemo1</filter-class></filter><filter-mapping>    <filter-name>FilterDemo1</filter-name>    <url-pattern>/*</url-pattern></filter-mapping>

2）doFilter()方法

WEB服务器每次在调用web资源之前，都会先调用doFilter方法，因此，在该方法内编写代码可达到如下目的：

① 调用目标资源之前，对request、response进行预处理

② 是否调用目标资源，即是否让用户访问web资源

Web服务器在调用doFilter方法时，会传递一个filterChain对象进来，它也提供了一个doFilter方法，我们可以根据需求决定是否调用此方法，调用该方法，则web资源就会被访问（放行），否则web资源不会被访问（一直处于拦截状态）。

③ 调用目标资源之后，对响应信息进行过滤

3）Filter链（FilterChain）

① 在一个web应用中，可以开发编写多个Filter，这些Filter组合起来称之为一个Filter链。

② Web服务器根据Filter在web.xml文件中的注册顺序（按filter-mapping元素的顺序），决定先调用哪个Filter，当第一个Filter的doFilter方法被调用时，Web服务器会创建一个代表Filter链的FilterChain对象传递给该方法。

在doFilter方法中，如果调用了FilterChain对象的doFilter方法，则web服务器会检查FilterChain对象中是否还有filter，如果有，则调用第2个filter，如果没有，则调用目标资源。

三、一些细节问题

1）Filter生命周期

诞生（init）：过滤器的实例是在应用被加载时就完成的实例化，并初始化的。
存活（doFilter）：和应用的生命周期一致的。针对拦截范围内的资源访问，每次访问都会调用void doFIlter(request,response.chain)进行拦截。
死亡（destroy）：应用被卸载（undeploy）。
如上面的FilterDemo1，当部署（Deploy）该应用到服务器时，就会产生FilterDemo1的实例，并调用初始化方法；最后将该应用从服务器卸载（undeploy）时，调用destroy方法。

2）FilterConfig接口【类似ServletConfig】

在配置Filter时，可以使用为filter配置一些初始化参数，当web容器实例化Filter对象，调用其init方法时，会把封装了filter初始化参数的filterConfig对象传递进来。filterConfig中的方法如下：

String getFilterName()：得到Filter名称
String getInitParameter(name)：返回中配置的参数，不存在返回null
3）子元素的配置

在配置拦截范围（）时，可以配置多个子元素，使得Filter将会拦截客户端直接请求的资源（REQUEST）、请求转发的目标资源（FORWARD）、包含的目标资源（INCLUDE）和中指定的目标资源（ERROR）。默认值为REQUEST。
四、基础案例（4个）

1）SetCharacterEncodingFilter：解决POST请求参数和响应输出的中文乱码

public class SetCharacterEncodingFilter implements Filter {    private String encoding;//编码可以通过<init-param>元素配置    public void init(FilterConfig filterConfig) throws ServletException {        encoding = filterConfig.getInitParameter("encoding");        if(encoding == null){//如果用户忘记配置，默认encoding为UTF-8            encoding = "UTF-8";        }    }    public void doFilter(ServletRequest request, ServletResponse response,            FilterChain chain) throws IOException, ServletException {        //只能解决POST请求参数乱码问题        request.setCharacterEncoding(encoding);        //指定输出编码（最后带上，后面会有说明）        response.setCharacterEncoding(encoding);        //指定输出流编码及客户端应使用的码表        response.setContentType("text/html;charset="+encoding);        chain.doFilter(request, response);    }    public void destroy() {    }}------------------------web.xml配置------------------------<filter>    <filter-name>SetCharacterEncodingFilter</filter-name>    <filter-class>org.flyne.examples.SetCharacterEncodingFilter</filter-class>    <init-param>        <param-name>encoding</param-name>        <param-value>UTF-8</param-value>    </init-param></filter><filter-mapping>    <filter-name>SetCharacterEncodingFilter</filter-name>    <url-pattern>/*</url-pattern></filter-mapping>

2）NoCacheFilter：禁止客户端缓存动态资源

public void doFilter(ServletRequest req, ServletResponse resp,        FilterChain chain) throws IOException, ServletException {    //响应头为HTTP协议里的，需转换一下    HttpServletRequest request = null;    HttpServletResponse response = null;    try{        request = (HttpServletRequest)req;        response = (HttpServletResponse)resp;    }catch(Exception e){        throw new RuntimeException("not-http request or response");    }    response.setHeader("Expires", "0");    response.setHeader("Cache-Control", "no-cache");    response.setHeader("Pragma", "no-cache");    chain.doFilter(request, response);}------------------------web.xml配置------------------------<filter>    <filter-name>NoCacheFilter</filter-name>    <filter-class>org.flyne.examples.NoCacheFilter</filter-class></filter><filter-mapping>    <filter-name>NoCacheFilter</filter-name>    <url-pattern>/servlet/*</url-pattern>    <url-pattern>*.jsp</url-pattern></filter-mapping>

3）SetCacheExpiresFilter：控制静态资源缓存时间

public class SetCacheExpiresFilter implements Filter {    private int htmlExp;//HTML的缓存时间，单位为小时，下同    private int cssExp;//CSS的缓存时间    private int jsExp;//JS的缓存时间    public void init(FilterConfig filterConfig) throws ServletException {        htmlExp = Integer.parseInt(filterConfig.getInitParameter("html"));        cssExp = Integer.parseInt(filterConfig.getInitParameter("css"));        jsExp = Integer.parseInt(filterConfig.getInitParameter("js"));    }    public void doFilter(ServletRequest req, ServletResponse resp,            FilterChain chain) throws IOException, ServletException {        // 响应头为HTTP协议里的，需转换一下        HttpServletRequest request = null;        HttpServletResponse response = null;        try {            request = (HttpServletRequest) req;            response = (HttpServletResponse) resp;        } catch (Exception e) {            throw new RuntimeException("not-http request or response");        }        //根据请求资源的后缀名确定缓存时间        String uri = request.getRequestURI();        String extName = uri.substring(uri.lastIndexOf(".")+1);        long expTime = 0;        if("html".equals(extName)){            expTime = System.currentTimeMillis()+htmlExp*60*60*1000;        }else if("css".equals(extName)){            expTime = System.currentTimeMillis()+cssExp*60*60*1000;        }else if("js".equals(extName)){            expTime = System.currentTimeMillis()+jsExp*60*60*1000;        }        response.setDateHeader("Expires", expTime);        chain.doFilter(request, response);    }    public void destroy() {    }}------------------------web.xml配置------------------------<filter>    <filter-name>SetCacheExpiresFilter</filter-name>    <filter-class>org.flyne.examples.SetCacheExpiresFilter</filter-class>    <init-param>        <param-name>html</param-name>        <param-value>1</param-value>    </init-param>    <init-param>        <param-name>css</param-name>        <param-value>2</param-value>    </init-param>    <init-param>        <param-name>js</param-name>        <param-value>3</param-value>    </init-param></filter><filter-mapping>    <filter-name>SetCacheExpiresFilter</filter-name>    <url-pattern>*.html</url-pattern>    <url-pattern>*.css</url-pattern>    <url-pattern>*.js</url-pattern></filter-mapping>

4）AutoLoginFilter ：用户自动登录
当用户登陆时，将表单提交到LoginServlet处理，如果用户勾选了记住我，则将用户的登陆信息存入Cookie：Cookie名为“logInfo”，值为（用户名的base64加密结果_密码的md5加密结果）。下面的自动登录过滤器基于以上信息：

public class AutoLoginFilter implements Filter {    //表现层同service层打交道    private UserService service = new UserServiceImpl();    public void init(FilterConfig filterConfig) throws ServletException {    }    public void doFilter(ServletRequest req, ServletResponse resp,            FilterChain chain) throws IOException, ServletException {        // 转为Http协议的request和response        HttpServletRequest request = null;        HttpServletResponse response = null;        try {            request = (HttpServletRequest) req;            response = (HttpServletResponse) resp;        } catch (Exception e) {            throw new RuntimeException("not-http request or response");        }        HttpSession session = request.getSession();        // 判断用户有没有登录：只管没有登录的        User sUser = (User) session.getAttribute("user");        if (sUser == null) {            Cookie[] cookies = request.getCookies();            for (int i = 0; cookies != null && i < cookies.length; i++) {                Cookie cookie = cookies[i];                //名为logInfo的Cookie记录了登录信息（用户名、密码）                if ("logInfo".equals(cookie.getName())) {                    String value = cookie.getValue();                    //Cookie中的用户名是经过Base64加密的，所以需要解密                    String username = SecurityUtil.base64Decode(value.split("_")[0]);                    String password = value.split("_")[1];                    //Cookie中的密码是md5加密后的，所以第三个参数为true                    User user = service.login(username, password, true);                    //通过则在session中设置登陆标记                    if(user!=null){                        session.setAttribute("user", user);                    }                    break;                }            }        }        chain.doFilter(request, response);    }    public void destroy() {    }}

五、Filter高级开发：装饰设计模式
在Filter.doFilter中可以得到代表用户请求和响应的request、response对象，因此在编程中可以使用装饰模式（Decorator）对request、response对象进行包装，改写其中的某些方法，增强功能，再把包装对象传给目标资源，从而实现一些特殊需求。
在《数据库连接池（DataSource）》一文中讲过改写Connection.close功能的几种方法。在Filter的高级开发中也需要对request、response的进行功能上的改写。
Sun公司提供了HttpServletRequestWrapper、HttpServletResponseWrapper两个对HttpServletRequest、HttpServletRequest对象的简单包装类【作用同《数据库连接池（DataSource）》一文中的ConnectionAdapter 】如果要改写request或response对象的功能，只需继承HttpServletRequestWrapper、HttpServletResponseWrapper类覆写对应方法即可。
六、高级案例（4个）
1）SetCharacterEncodingFilter：解决全站中文乱码
上面的第一个案例解决了Post请求参数和响应输出的中文乱码问题，本案例是它的增强版：增加了get请求参数的中文乱码解决。
解决方法是改写request对象的getParameter方法。如何改写request对象的getParameter方法：装饰设计模式，见代码中的MyHttpServletRequest类。

class EncodingHttpServletRequest extends HttpServletRequestWrapper{    public EncodingHttpServletRequest(HttpServletRequest request) {        super(request);    }    //改写request对象的getParameter方法    public String getParameter(String name) {        String value = super.getParameter(name);        if(value == null) return null;        //解决get请求方式时的乱码问题        if("get".equalsIgnoreCase(super.getMethod())){            try {                return new String(value.getBytes("ISO-8859-1"),super.getCharacterEncoding());            } catch (UnsupportedEncodingException e) {                throw new RuntimeException(e);            }        }        return value;    }}public class SetCharacterEncodingFilter implements Filter {        ………………        //doFilter()        request.setCharacterEncoding(encoding);//解决POST请求参数的乱码        response.setCharacterEncoding(encoding);//输出流编码        request.setContentType("text/html;charset="+encoding);        EncodingHttpServletRequest ecRequest = new EncodingHttpServletRequest(request);        //往下传递的request对象是改写了getParameter方法的包装对象        chain.doFilter(ecRequest, request);}        ………………}

2）DirtyWordsFilter：过滤脏话
核心还是对request对象中getParameter方法的改写：

class DirtyWordsHttpServletRequest extends HttpServletRequestWrapper{    //脏话库    private String[] strs = {"日","插","草","操"};    public DirtyWordsHttpServletRequest(HttpServletRequest request) {        super(request);    }    public String getParameter(String name) {        String value = super.getParameter(name);        if(value==null) return null;        //遍历脏话库，对脏话用*替换        for(String s:strs){            value = value.replace(s, "*");        }        return value;    }}

3）HtmlFilter：过滤html标记
思路同DirtyWordsFilter，htmlFilter直接从Tomcat下的webapps\examples\WEB-INF\classes\util\HTMLFilter.java拷贝。

class HtmlHttpServletRequest extends HttpServletRequestWrapper{    public HtmlHttpServletRequest(HttpServletRequest request) {        super(request);    }    public String getParameter(String name) {        String value = super.getParameter(name);        if(value == null) return value;        //对HTML标记中的标记符号转义        value = htmlFilter(value);        return value;    }    //下面的一大段代码拷贝自webapps\examples\WEB-INF\classes\ util\HTMLFilter.java    private String htmlFilter(String message) {        if (message == null)            return (null);        char content[] = new char[message.length()];        message.getChars(0, message.length(), content, 0);        StringBuffer result = new StringBuffer(content.length + 50);        for (int i = 0; i < content.length; i++) {            switch (content[i]) {            case '<':                result.append("&lt;");                break;            case '>':                result.append("&gt;");                break;            case '&':                result.append("&amp;");                break;            case '"':                result.append("&quot;");                break;            default:                result.append(content[i]);            }        }        return (result.toString());    }}

4）GzipFilter：全站压缩（有难度）
下面的代码在一个普通的Java类中演示了Gzip压缩的过程：
String str = “压缩我吧！！！啊啊啊！！！！！！！！！！！”;

// 获得字节数组byte[] b = str.getBytes("utf-8");System.out.println("压缩前大小：" + b.length);//☆☆☆☆☆对数据进行压缩☆☆☆☆☆ByteArrayOutputStream out = new ByteArrayOutputStream();GZIPOutputStream gout = new GZIPOutputStream(out);gout.write(b);gout.close(); //这句话一定要有b = out.toByteArray();System.out.println("压缩后大小：" + b.length);

在web工程中对响应输出进行压缩前需要判断客户端是否支持Gzip压缩（请求头的Accept-Encoding字段是否含有gzip压缩），如果支持gzip压缩则进行压缩，并在响应头字段中告诉客户端响应消息为gzip压缩。
因为是对响应输出进行压缩，所以压缩代码应放在chain.doFilter()之后。全站压缩的最大难点在于如何拦截目标资源的响应输出。假设目标资源为一个Servlet，且Servlet中的相应输出代码如下：
ServletOutputStream out = response.getOutputStream();
out.write(b);

则截取该Servlet的响应输出思路如下：
① 继承HttpServletResponseWrapper，改写getOutputStream方法，返回一个自己定义的输出流。
② 该输出流继承ServletOutputStream，并覆写其中的write(int)方法，每次都向指定的地方输出（很关键，即下文的ByteArrayOutputStream对象），这样就完成了响应消息的截获。
下面的代码演示了这一过程，在改写response功能时，定义了一个ByteArrayOutputStream对象baos，并提供了获取该字节数组的getBufferedBytes方法。在getOutputStream()中，返回一个包装了baos的ServletOutputStream对象。

class GzipHttpServletResponse extends HttpServletResponseWrapper{    //截获输出流，放入baos    private ByteArrayOutputStream baos = new ByteArrayOutputStream();    private PrintWriter pw = null;    public GzipHttpServletResponse(HttpServletResponse response) {        super(response);    }    //返回包装了baos的ServletOutputStream对象，用户每次的输出都会被“截获”到baos中    public ServletOutputStream getOutputStream() throws IOException {        return new MyServletOutputStream(baos);    }    //截获字符流：放到baos中    public PrintWriter getWriter() throws IOException {        pw = new PrintWriter(new OutputStreamWriter(baos,super.getCharacterEncoding()));        return pw;    }    //获取截获的字节数组    public byte[] getBufferedBytes() {        try {            if(pw!=null){                pw.close();            }            baos.flush();        } catch (IOException e) {            e.printStackTrace();        }        return baos.toByteArray();    }}//改写ServletOutputStream --> 包装流class MyServletOutputStream extends ServletOutputStream{    private ByteArrayOutputStream baos = new ByteArrayOutputStream();    public MyServletOutputStream(ByteArrayOutputStream baos){        this.baos = baos;    }    public void write(int b) throws IOException {        baos.write(b);    }}

过滤器doFilter方法中的部分代码：

GzipHttpServletResponse gzipResponse = new GzipHttpServletResponse(response);chain.doFilter(request, gzipResponse);byte b[] = gzipResponse.getBufferedBytes();//得到原始的数据为编码的关键点System.out.println("压缩前大小："+b.length);//判断客户是否支持gzip压缩String acceptEncoding = request.getHeader("Accept-Encoding");if(acceptEncoding!=null&&acceptEncoding.contains("gzip")){  //支持    ByteArrayOutputStream out = new ByteArrayOutputStream();    GZIPOutputStream gout = new GZIPOutputStream(out);    gout.write(b);    gout.close();    b = out.toByteArray();//压缩后的数据    System.out.println("压缩后大小："+b.length);    //告知浏览器压缩方式    response.setHeader("Content-Encoding", "gzip");    response.setContentLength(b.length);//告知客户端，正文的长度}response.getOutputStream().write(b);

在配置web.xml的过滤范围时要注意，一般只过滤字符文件（.jsp,.html,.css,.js等），因为.jpg,.png,*.zip等都已经是压缩过的文件了（再压缩没意义，只会浪费服务器资源）。

<filter>    <filter-name>GzipFilter</filter-name>    <filter-class>org.flyne.filter.advanced.GzipFilter</filter-class></filter><filter-mapping>    <filter-name>GzipFilter</filter-name>    <url-pattern>*.jsp</url-pattern>    <url-pattern>*.html</url-pattern>    <url-pattern>*.js</url-pattern>    <url-pattern>*.css</url-pattern></filter-mapping>