精选文章 编程小白的毕设开发教程-filter实战

编程小白的毕设开发教程-filter实战

在filter中可以得到代表用户请求和响应的request、response对象,因此在编程中可以使用Decorator(装饰器)模式对request、response对象进行包装,再把包装对象传给目标资源,从而实现一些特殊需求。

一、Decorator设计模式

1.1、Decorator设计模式介绍

  当某个对象的方法不适应业务需求时,通常有2种方式可以对方法进行增强:

  1. 编写子类,覆盖需增强的方法。
  2. 使用Decorator设计模式对方法进行增强。

  在阎宏博士的《JAVA与模式》一书中开头是这样描述装饰(Decorator)模式的:装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案。装饰模式是在不必改变原类文件和使用继承的情况下,动态的扩展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。

  那么在实际应用中遇到需增强对象的方法时,到底选用哪种方式比较好呢?这个没有具体的定式,只能是根据具体的需求来采用具体的方式,不过有一种情况下,必须使用Decorator设计模式:即被增强的对象,开发人员只能得到它的对象,无法得到它的class文件。比如request、response对象,开发人员之所以在servlet中能通过sun公司定义的HttpServletRequest\response接口去操作这些对象,是因为Tomcat服务器厂商编写了request、response接口的实现类。web服务器在调用servlet时,会用这些接口的实现类创建出对象,然后传递给servlet程序。此种情况下,由于开发人员根本不知道服务器厂商编写的request、response接口的实现类是哪个?在程序中只能拿到服务器厂商提供的对象,因此就只能采用Decorator设计模式对这些对象进行增强。

1.2、Decorator设计模式的实现

  1.首先看需要被增强对象继承了什么接口或父类,编写一个类也去继承这些接口或父类。
  2.在类中定义一个变量,变量类型即需增强对象的类型。
  3.在类中定义一个构造函数,接收需增强的对象。
  4.覆盖需增强的方法,编写增强的代码。

 二、使用Decorator设计模式增强request对象

  Servlet API 中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper,HttpServletRequestWrapper 类实现了request 接口中的所有方法,但这些方法的内部实现都是仅仅调用了一下所包装的的 request 对象的对应方法,以避免用户在对request对象进行增强时需要实现request接口中的所有方法。

2.1、使用Decorator模式包装request对象解决get和post请求方式下的中文乱码问题

  编写一个用于处理中文乱码的过滤器CharacterEncodingFilter,代码如下:

编程小白的毕设开发教程-filter实战1

  1 package me.gacl.web.filter;
  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.http.HttpServletRequest;
 12 import javax.servlet.http.HttpServletRequestWrapper;
 13 import javax.servlet.http.HttpServletResponse;
 14 
 15 /**
 16 * @ClassName: CharacterEncodingFilter
 17 * @Description: 此过滤器用来解决解决get、post请求方式下的中文乱码问题
 18 * @author: 孤傲苍狼
 19 * @date: 2014-8-31 下午11:09:37
 20 *
 21 */ 
 22 public class CharacterEncodingFilter implements Filter {
 23 
 24     private FilterConfig filterConfig = null;
 25     //设置默认的字符编码
 26     private String defaultCharset = "UTF-8";
 27 
 28     public void doFilter(ServletRequest req, ServletResponse resp,
 29             FilterChain chain) throws IOException, ServletException {
 30         
 31         HttpServletRequest request = (HttpServletRequest) req;
 32         HttpServletResponse response = (HttpServletResponse) resp;
 33         //得到在web.xml中配置的字符编码
 34         String charset = filterConfig.getInitParameter("charset");
 35         if(charset==null){
 36             charset = defaultCharset;
 37         }
 38         request.setCharacterEncoding(charset);
 39         response.setCharacterEncoding(charset);
 40         response.setContentType("text/html;charset="+charset);
 41         
 42         MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);
 43         chain.doFilter(requestWrapper, response);
 44     }
 45 
 46     public void init(FilterConfig filterConfig) throws ServletException {
 47         //得到过滤器的初始化配置信息
 48         this.filterConfig = filterConfig;
 49     }
 50     
 51     public void destroy() {
 52 
 53     }
 54 }
 55 
 56 /**
 57 * @ClassName: MyCharacterEncodingRequest
 58 * @Description: Servlet API中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper,
 59 * (HttpServletRequestWrapper类实现了request接口中的所有方法,但这些方法的内部实现都是仅仅调用了一下所包装的的 request对象的对应方法)
 60 * 以避免用户在对request对象进行增强时需要实现request接口中的所有方法。
 61 * 所以当需要增强request对象时,只需要写一个类继承HttpServletRequestWrapper类,然后在重写需要增强的方法即可
 62 * @author: 孤傲苍狼
 63 * @date: 2014-9-2 下午10:42:57
 64 *     1.实现与被增强对象相同的接口 
 65     2、定义一个变量记住被增强对象
 66     3、定义一个构造函数,接收被增强对象
 67     4、覆盖需要增强的方法
 68     5、对于不想增强的方法,直接调用被增强对象(目标对象)的方法
 69 */ 
 70 class MyCharacterEncodingRequest extends HttpServletRequestWrapper{
 71     //定义一个变量记住被增强对象(request对象是需要被增强的对象)
 72     private HttpServletRequest request;
 73     //定义一个构造函数,接收被增强对象
 74     public MyCharacterEncodingRequest(HttpServletRequest request) {
 75         super(request);
 76         this.request = request;
 77     }
 78     /* 覆盖需要增强的getParameter方法
 79      * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
 80      */
 81     @Override
 82     public String getParameter(String name) {
 83         try{
 84             //获取参数的值
 85             String value= this.request.getParameter(name);
 86             if(value==null){
 87                 return null;
 88             }
 89             //如果不是以get方式提交数据的,就直接返回获取到的值
 90             if(!this.request.getMethod().equalsIgnoreCase("get")) {
 91                 return value;
 92             }else{
 93                 //如果是以get方式提交数据的,就对获取到的值进行转码处理
 94                 value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
 95                 return value;
 96             }
 97         }catch (Exception e) {
 98             throw new RuntimeException(e);
 99         }
100     }
101 }

编程小白的毕设开发教程-filter实战2

  在web.xml文件中配置CharacterEncodingFilter

编程小白的毕设开发教程-filter实战3

 1 
 2   
 3       CharacterEncodingFilter
 4       me.gacl.web.filter.CharacterEncodingFilter
 5   
 6   
 7   
 8       CharacterEncodingFilter
 9       /*
10   

编程小白的毕设开发教程-filter实战4

  编写jsp测试页面,如下:

编程小白的毕设开发教程-filter实战5

 1 <%@ page language="java" pageEncoding="UTF-8"%>
 2 <%--引入jstl标签库 --%>
 3 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
 4 
 5 
 6   
 7     使用字符过滤器解决解决get、post请求方式下的中文乱码问题
 8   
 9   
10   
11        <%--使用c:url标签构建url,构建好的url存储在servletDemo1变量中--%>
12        
13            <%--构建的url的附带的中文参数 ,参数名是:username,值是:孤傲苍狼--%>
14            
15        
16       <%--使用get的方式访问 --%>
17        超链接(get方式请求)
18        
19 <%--使用post方式提交表单 --%> 20
21 用户名: 22 23
24 25 26

编程小白的毕设开发教程-filter实战6

  编写处理用户请求的ServletDemo1

编程小白的毕设开发教程-filter实战7

 1 package me.gacl.web.controller;
 2 
 3 import java.io.IOException;
 4 import java.io.PrintWriter;
 5 
 6 import javax.servlet.ServletException;
 7 import javax.servlet.http.HttpServlet;
 8 import javax.servlet.http.HttpServletRequest;
 9 import javax.servlet.http.HttpServletResponse;
10 
11 public class ServletDemo1 extends HttpServlet {
12 
13     public void doGet(HttpServletRequest request, HttpServletResponse response)
14             throws ServletException, IOException {
15         //接收参数
16         String username = request.getParameter("username");
17         //获取请求方式
18         String method = request.getMethod();
19         //获取输出流
20         PrintWriter out = response.getWriter();
21         out.write("请求的方式:"+method);
22         out.write("
"); 23 out.write("接收到的参数:"+username); 24 } 25 26 public void doPost(HttpServletRequest request, HttpServletResponse response) 27 throws ServletException, IOException { 28 doGet(request, response); 29 } 30 31 }

编程小白的毕设开发教程-filter实战8

  测试结果如下:

  编程小白的毕设开发教程-filter实战9

  从运行结果中可以看到,无论是get请求方式还是post请求方式,中文乱码问题都可以完美解决了。

2.2、使用Decorator模式包装request对象实现html标签转义功能

  编写一个html转义过滤器,代码如下:

编程小白的毕设开发教程-filter实战10

  1 package me.gacl.web.filter;
  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.http.HttpServletRequest;
 12 import javax.servlet.http.HttpServletRequestWrapper;
 13 import javax.servlet.http.HttpServletResponse;
 14 
 15 /**
 16 * @ClassName: HtmlFilter
 17 * @Description: html转义过滤器
 18 * @author: 孤傲苍狼
 19 * @date: 2014-9-2 下午11:28:41
 20 *
 21 */ 
 22 public class HtmlFilter implements Filter {
 23 
 24     public void doFilter(ServletRequest req, ServletResponse resp,
 25             FilterChain chain) throws IOException, ServletException {
 26         
 27         HttpServletRequest request = (HttpServletRequest) req;
 28         HttpServletResponse response = (HttpServletResponse) resp;
 29 
 30         MyHtmlRequest myrequest = new MyHtmlRequest(request);
 31         chain.doFilter(myrequest, response);
 32         
 33     }
 34 
 35     
 36     public void destroy() {
 37         
 38     }
 39 
 40     
 41     public void init(FilterConfig filterConfig) throws ServletException {
 42         
 43     }
 44 }
 45 
 46 /**
 47 * @ClassName: MyHtmlRequest
 48 * @Description: 使用Decorator模式包装request对象,实现html标签转义功能
 49 * @author: 孤傲苍狼
 50 * @date: 2014-9-2 下午11:29:09
 51 *
 52 */ 
 53 class MyHtmlRequest extends HttpServletRequestWrapper {
 54 
 55     private HttpServletRequest request;
 56 
 57     public MyHtmlRequest(HttpServletRequest request) {
 58         super(request);
 59         this.request = request;
 60     }
 61 
 62     /* 覆盖需要增强的getParameter方法
 63      * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
 64      */
 65     @Override
 66     public String getParameter(String name) {
 67         String value = this.request.getParameter(name);
 68         if (value == null) {
 69             return null;
 70         }
 71         //调用filter转义value中的html标签
 72         return filter(value);
 73     }
 74 
 75     /**
 76     * @Method: filter
 77     * @Description: 过滤内容中的html标签
 78     * @Anthor:孤傲苍狼
 79     * @param message
 80     * @return
 81     */ 
 82     public String filter(String message) {
 83         if (message == null){
 84             return null;
 85         }
 86         char content[] = new char[message.length()];
 87         message.getChars(0, message.length(), content, 0);
 88         StringBuffer result = new StringBuffer(content.length + 50);
 89         for (int i = 0; i < content.length; i++) {
 90             switch (content[i]) {
 91             case '<':
 92                 result.append("<");
 93                 break;
 94             case '>':
 95                 result.append(">");
 96                 break;
 97             case '&':
 98                 result.append("&");
 99                 break;
100             case '"':
101                 result.append(""");
102                 break;
103             default:
104                 result.append(content[i]);
105             }
106         }
107         return result.toString();
108     }
109 }

编程小白的毕设开发教程-filter实战11

  在web.xml文件中配置HtmlFilter

编程小白的毕设开发教程-filter实战12

 1 
 2   
 3       HtmlFilter
 4       me.gacl.web.filter.HtmlFilter
 5   
 6   
 7   
 8       HtmlFilter
 9       /*
10   

编程小白的毕设开发教程-filter实战13

  编写jsp测试页面,如下:

编程小白的毕设开发教程-filter实战14

 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 2 
 3 
 4   
 5     html过滤器测试
 6   
 7   
 8   
 9        
10 留言: 11 19 20
21 22

编程小白的毕设开发教程-filter实战15

  编写处理用户请求的ServletDemo2

编程小白的毕设开发教程-filter实战16

 1 package me.gacl.web.controller;
 2 
 3 import java.io.IOException;
 4 
 5 import javax.servlet.ServletException;
 6 import javax.servlet.http.HttpServlet;
 7 import javax.servlet.http.HttpServletRequest;
 8 import javax.servlet.http.HttpServletResponse;
 9 
10 public class ServletDemo2 extends HttpServlet {
11 
12     public void doGet(HttpServletRequest request, HttpServletResponse response)
13             throws ServletException, IOException {
14         //获取用户输入的内容
15         String message = request.getParameter("message");
16         response.getWriter().write("您上次的留言是:
" + message); 17 } 18 19 public void doPost(HttpServletRequest request, HttpServletResponse response) 20 throws ServletException, IOException { 21 doGet(request, response); 22 } 23 }

编程小白的毕设开发教程-filter实战17

测试结果如下:

  编程小白的毕设开发教程-filter实战18

  从运行结果中可以看到,所有的html标签都被转义输出了。

2.3、使用Decorator模式包装request对象实现敏感字符过滤功能

  编写一个敏感字符过滤器,代码如下:

编程小白的毕设开发教程-filter实战19

  1 package me.gacl.web.filter;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.IOException;
  5 import java.io.InputStream;
  6 import java.io.InputStreamReader;
  7 import java.io.UnsupportedEncodingException;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 import javax.servlet.Filter;
 11 import javax.servlet.FilterChain;
 12 import javax.servlet.FilterConfig;
 13 import javax.servlet.ServletException;
 14 import javax.servlet.ServletRequest;
 15 import javax.servlet.ServletResponse;
 16 import javax.servlet.http.HttpServletRequest;
 17 import javax.servlet.http.HttpServletRequestWrapper;
 18 import javax.servlet.http.HttpServletResponse;
 19 
 20 /**
 21 * @ClassName: DirtyFilter
 22 * @Description: 敏感词过滤器
 23 * @author: 孤傲苍狼
 24 * @date: 2014-9-6 上午10:43:11
 25 *
 26 */ 
 27 public class DirtyFilter implements Filter {
 28 
 29     private FilterConfig config = null;
 30     
 31     @Override
 32     public void init(FilterConfig filterConfig) throws ServletException {
 33         this.config = filterConfig;
 34     }
 35 
 36     @Override
 37     public void doFilter(ServletRequest req, ServletResponse resp,
 38             FilterChain chain) throws IOException, ServletException {
 39         
 40         HttpServletRequest request = (HttpServletRequest) req;
 41         HttpServletResponse response = (HttpServletResponse) resp;
 42         DirtyRequest dirtyrequest = new DirtyRequest(request);
 43         
 44         chain.doFilter(dirtyrequest, response);
 45     }
 46 
 47     @Override
 48     public void destroy() {
 49 
 50     }
 51     
 52     /**
 53     * @Method: getDirtyWords
 54     * @Description: 获取敏感字符
 55     * @Anthor:孤傲苍狼
 56     *
 57     * @return
 58     */ 
 59     private List getDirtyWords(){
 60         List dirtyWords = new ArrayList();
 61         String dirtyWordPath = config.getInitParameter("dirtyWord");
 62         InputStream inputStream = config.getServletContext().getResourceAsStream(dirtyWordPath);
 63         InputStreamReader is = null;
 64         try {
 65             is = new InputStreamReader(inputStream,"UTF-8");
 66         } catch (UnsupportedEncodingException e2) {
 67             e2.printStackTrace();
 68         }
 69         BufferedReader reader = new BufferedReader(is);
 70         String line;
 71         try {
 72             while ((line = reader.readLine())!= null) {//如果 line为空说明读完了
 73                 dirtyWords.add(line);
 74             }
 75         } catch (IOException e) {
 76             e.printStackTrace();
 77         } 
 78         return dirtyWords;
 79     }
 80     
 81     /**
 82     * @ClassName: DirtyRequest
 83     * @Description: 使用Decorator模式包装request对象,实现敏感字符过滤功能
 84     * @author: 孤傲苍狼
 85     * @date: 2014-9-6 上午11:56:35
 86     *
 87     */ 
 88     class DirtyRequest extends HttpServletRequestWrapper{
 89 
 90         private List dirtyWords = getDirtyWords();
 91         private HttpServletRequest request;
 92         public DirtyRequest(HttpServletRequest request) {
 93             super(request);
 94             this.request = request;
 95         }
 96         /* 重写getParameter方法,实现对敏感字符的过滤
 97          * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
 98          */
 99         @Override
100         public String getParameter(String name) {
101             
102             String value = this.request.getParameter(name);
103             if(value==null){
104                 return null;
105             }
106             
107             for(String dirtyWord : dirtyWords){
108                 if(value.contains(dirtyWord)){
109                     System.out.println("内容中包含敏感词:"+dirtyWord+",将会被替换成****");
110                     //替换敏感字符
111                     value = value.replace(dirtyWord, "****");
112                 }
113             }
114             return value;
115         }
116     }
117 }

编程小白的毕设开发教程-filter实战20

  在web.xml文件中配置DirtyFilter

编程小白的毕设开发教程-filter实战21

 1  
 2   
 3       DirtyFilter
 4       me.gacl.web.filter.DirtyFilter
 5       
 6       
 7          dirtyWord    
 8          /WEB-INF/DirtyWord.txt
 9     
10   
11   
12   
13       DirtyFilter
14       /*
15   

编程小白的毕设开发教程-filter实战22

  当用户填写的内容包含一些敏感字符时,在DirtyFilter过滤器中就会将这些敏感字符替换掉。

  我们如果将上述的CharacterEncodingFilter、HtmlFilter、DirtyFilter这三个过滤器联合起来使用,那么就相当于是把request对象包装了3次,request对象的getParameter方法经过3次重写,使得getParameter方法的功能大大增强,可以同时解决中文乱码,html标签转义,敏感字符过滤这些需求。

  在实际开发中完全可以将上述的三个过滤器合并成一个,让合并后的过滤器具有解决中文乱码,html标签转义,敏感字符过滤这些功能,例如:

编程小白的毕设开发教程-filter实战23

  1 package me.gacl.web.filter;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.IOException;
  5 import java.io.InputStream;
  6 import java.io.InputStreamReader;
  7 import java.io.UnsupportedEncodingException;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 
 11 import javax.servlet.Filter;
 12 import javax.servlet.FilterChain;
 13 import javax.servlet.FilterConfig;
 14 import javax.servlet.ServletException;
 15 import javax.servlet.ServletRequest;
 16 import javax.servlet.ServletResponse;
 17 import javax.servlet.http.HttpServletRequest;
 18 import javax.servlet.http.HttpServletRequestWrapper;
 19 import javax.servlet.http.HttpServletResponse;
 20 
 21 /**
 22 * @ClassName: AdvancedFilter
 23 * @Description: 这个过滤器是用来解决中文乱码,转义内容中的html标签,过滤内容中的敏感字符的
 24 * @author: 孤傲苍狼
 25 * @date: 2014-9-6 下午6:17:37
 26 *
 27 */ 
 28 public class AdvancedFilter implements Filter {
 29 
 30     private FilterConfig filterConfig = null;
 31     //设置默认的字符编码
 32     private String defaultCharset = "UTF-8";
 33     
 34     @Override
 35     public void init(FilterConfig filterConfig) throws ServletException {
 36         //得到过滤器的初始化配置信息
 37         this.filterConfig = filterConfig;
 38     }
 39 
 40     @Override
 41     public void doFilter(ServletRequest req, ServletResponse resp,
 42             FilterChain chain) throws IOException, ServletException {
 43         HttpServletRequest request = (HttpServletRequest) req;
 44         HttpServletResponse response = (HttpServletResponse) resp;
 45         //得到在web.xml中配置的字符编码
 46         String charset = filterConfig.getInitParameter("charset");
 47         if(charset==null){
 48             charset = defaultCharset;
 49         }
 50         request.setCharacterEncoding(charset);
 51         response.setCharacterEncoding(charset);
 52         response.setContentType("text/html;charset="+charset);
 53         
 54         AdvancedRequest requestWrapper = new AdvancedRequest(request);
 55         chain.doFilter(requestWrapper, response);
 56     }
 57 
 58     @Override
 59     public void destroy() {
 60 
 61     }
 62 
 63     class AdvancedRequest extends HttpServletRequestWrapper{
 64         
 65         private List dirtyWords = getDirtyWords();
 66         
 67         //定义一个变量记住被增强对象(request对象是需要被增强的对象)
 68         private HttpServletRequest request;
 69         //定义一个构造函数,接收被增强对象
 70         public AdvancedRequest(HttpServletRequest request) {
 71             super(request);
 72             this.request = request;
 73         }
 74         /* 覆盖需要增强的getParameter方法
 75          * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
 76          */
 77         @Override
 78         public String getParameter(String name) {
 79             try{
 80                 //获取参数的值
 81                 String value= this.request.getParameter(name);
 82                 if(value==null){
 83                     return null;
 84                 }
 85                 //如果不是以get方式提交数据的,就直接返回获取到的值
 86                 if(!this.request.getMethod().equalsIgnoreCase("get")) {
 87                     //调用filter转义value中的html标签
 88                     value= filter(value);
 89                 }else{
 90                     //如果是以get方式提交数据的,就对获取到的值进行转码处理
 91                     value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
 92                     //调用filter转义value中的html标签
 93                     value= filter(value);
 94                 }
 95                 
 96                 for(String dirtyWord : dirtyWords){
 97                     if(value.contains(dirtyWord)){
 98                         System.out.println("内容中包含敏感词:"+dirtyWord+",将会被替换成****");
 99                         //替换敏感字符
100                         value = value.replace(dirtyWord, "****");
101                     }
102                 }
103                 return value;
104             }catch (Exception e) {
105                 throw new RuntimeException(e);
106             }
107         }
108     }
109 
110     /**
111     * @Method: filter
112     * @Description: 过滤内容中的html标签
113     * @Anthor:孤傲苍狼
114     * @param value
115     * @return
116     */ 
117     public String filter(String value) {
118         if (value == null){
119             return null;
120         }
121         char content[] = new char[value.length()];
122         value.getChars(0, value.length(), content, 0);
123         StringBuffer result = new StringBuffer(content.length + 50);
124         for (int i = 0; i < content.length; i++) {
125             switch (content[i]) {
126             case '<':
127                 result.append("<");
128                 break;
129             case '>':
130                 result.append(">");
131                 break;
132             case '&':
133                 result.append("&");
134                 break;
135             case '"':
136                 result.append(""");
137                 break;
138             default:
139                 result.append(content[i]);
140             }
141         }
142         return (result.toString());
143     }
144     
145     /**
146     * @Method: getDirtyWords
147     * @Description: 获取敏感字符
148     * @Anthor:孤傲苍狼
149     *
150     * @return
151     */ 
152     private List getDirtyWords(){
153         List dirtyWords = new ArrayList();
154         String dirtyWordPath = filterConfig.getInitParameter("dirtyWord");
155         InputStream inputStream = filterConfig.getServletContext().getResourceAsStream(dirtyWordPath);
156         InputStreamReader is = null;
157         try {
158             is = new InputStreamReader(inputStream,defaultCharset);
159         } catch (UnsupportedEncodingException e2) {
160             e2.printStackTrace();
161         }
162         BufferedReader reader = new BufferedReader(is);
163         String line;
164         try {
165             while ((line = reader.readLine())!= null) {//如果 line为空说明读完了
166                 dirtyWords.add(line);
167             }
168         } catch (IOException e) {
169             e.printStackTrace();
170         } 
171         return dirtyWords;
172     }
173 }

编程小白的毕设开发教程-filter实战24

  在web.xml文件中配置AdvancedFilter

编程小白的毕设开发教程-filter实战25

 1   
 2       AdvancedFilter
 3       me.gacl.web.filter.AdvancedFilter
 4       
 5          charset    
 6          UTF-8
 7     
 8       
 9          dirtyWord    
10          /WEB-INF/DirtyWord.txt
11     
12   
13   
14   
15       AdvancedFilter
16       /*
17   

编程小白的毕设开发教程-filter实战26

  AdvancedFilter过滤器同时具有解决中文乱码,转义内容中的html标签,过滤内容中的敏感字符这些功能。

三、使用Decorator设计模式增强response对象

  Servlet  API 中提供了response对象的Decorator设计模式的默认实现类HttpServletResponseWrapper ,HttpServletResponseWrapper类实现了response接口中的所有方法,但这些方法的内部实现都是仅仅调用了一下所包装的的 response对象的对应方法,以避免用户在对response对象进行增强时需要实现response接口中的所有方法。

3.1、response增强案例——压缩响应正文内容

  应用HttpServletResponseWrapper对象,压缩响应正文内容。

  具体思路:通过filter向目标页面传递一个自定义的response对象。在自定义的response对象中,重写getOutputStream方法和getWriter方法,使目标资源调用此方法输出页面内容时,获得的是我们自定义的ServletOutputStream对象。在我们自定义的ServletOuputStream对象中,重写write方法,使写出的数据写出到一个buffer中。当页面完成输出后,在filter中就可得到页面写出的数据,从而我们可以调用GzipOuputStream对数据进行压缩后再写出给浏览器,以此完成响应正文件压缩功能。

  编写压缩过滤器,代码如下:

编程小白的毕设开发教程-filter实战27

  1 package me.gacl.web.filter;
  2 
  3 import java.io.ByteArrayOutputStream;
  4 import java.io.IOException;
  5 import java.io.OutputStreamWriter;
  6 import java.io.PrintWriter;
  7 import java.util.zip.GZIPOutputStream;
  8 
  9 import javax.servlet.Filter;
 10 import javax.servlet.FilterChain;
 11 import javax.servlet.FilterConfig;
 12 import javax.servlet.ServletException;
 13 import javax.servlet.ServletOutputStream;
 14 import javax.servlet.ServletRequest;
 15 import javax.servlet.ServletResponse;
 16 import javax.servlet.http.HttpServletRequest;
 17 import javax.servlet.http.HttpServletResponse;
 18 import javax.servlet.http.HttpServletResponseWrapper;
 19 
 20 /**
 21 * @ClassName: GzipFilter
 22 * @Description: 压缩过滤器,将web应用中的文本都经过压缩后再输出到浏览器
 23 * @author: 孤傲苍狼
 24 * @date: 2014-9-7 上午10:52:42
 25 *
 26 */ 
 27 public class GzipFilter implements Filter {
 28 
 29     public void doFilter(ServletRequest req, ServletResponse resp,
 30             FilterChain chain) throws IOException, ServletException {
 31         
 32         HttpServletRequest request = (HttpServletRequest) req;
 33         HttpServletResponse response = (HttpServletResponse) resp;
 34         
 35         BufferResponse myresponse = new BufferResponse(response);
 36         chain.doFilter(request, myresponse);
 37         //拿出缓存中的数据,压缩后再打给浏览器
 38         byte out[] = myresponse.getBuffer();
 39         System.out.println("原始大小:" + out.length);
 40         
 41         ByteArrayOutputStream bout = new ByteArrayOutputStream();
 42         //压缩输出流中的数据
 43         GZIPOutputStream gout = new GZIPOutputStream(bout);
 44         gout.write(out);
 45         gout.close();
 46         
 47         byte gzip[] = bout.toByteArray();
 48         System.out.println("压缩后的大小:" + gzip.length);
 49         
 50         response.setHeader("content-encoding", "gzip");
 51         response.setContentLength(gzip.length);
 52         response.getOutputStream().write(gzip);
 53     }
 54     
 55     public void destroy() {
 56         
 57     }
 58 
 59     public void init(FilterConfig filterConfig) throws ServletException {
 60         
 61     }
 62 }
 63 
 64 class BufferResponse extends HttpServletResponseWrapper{
 65 
 66     private ByteArrayOutputStream bout = new ByteArrayOutputStream();
 67     private PrintWriter pw;
 68     private HttpServletResponse response;
 69     public BufferResponse(HttpServletResponse response) {
 70         super(response);
 71         this.response = response;
 72     }
 73     @Override
 74     public ServletOutputStream getOutputStream() throws IOException {
 75         return new MyServletOutputStream(bout);
 76     }
 77     @Override
 78     public PrintWriter getWriter() throws IOException {
 79         pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
 80         return pw;
 81     }
 82     
 83     public byte[] getBuffer(){
 84         try{
 85             if(pw!=null){
 86                 pw.close();
 87             }
 88             if(bout!=null){
 89                 bout.flush();
 90                 return bout.toByteArray();
 91             }
 92             
 93             
 94             return null;
 95         }catch (Exception e) {
 96             throw new RuntimeException(e);
 97         }
 98     }
 99 }
100 
101 class MyServletOutputStream extends ServletOutputStream{
102 
103     private ByteArrayOutputStream bout;
104     public MyServletOutputStream(ByteArrayOutputStream bout){
105         this.bout = bout;
106     }
107     
108     @Override
109     public void write(int b) throws IOException {
110         this.bout.write(b);
111     }
112 }

编程小白的毕设开发教程-filter实战28

  在web.xml中配置压缩过滤器

编程小白的毕设开发教程-filter实战29

 1  
 2       配置压缩过滤器
 3       GzipFilter
 4       me.gacl.web.filter.GzipFilter
 5   
 6   
 7   
 8   
 9       GzipFilter
10       *.jsp
11       
12       
15       FORWARD
16       
17       REQUEST
18   
19   
20   
21       GzipFilter
22       *.js
23   
24   
25   
26       GzipFilter
27       *.css
28   
29   
30   
31       GzipFilter
32       *.html
33   

编程小白的毕设开发教程-filter实战30

 3.2、response增强案例——缓存数据到内存

  对于页面中很少更新的数据,例如商品分类,为避免每次都要从数据库查询分类数据,因此可把分类数据缓存在内存或文件中,以此来减轻数据库压力,提高系统响应速度。

  编写缓存数据的过滤器,代码如下:

编程小白的毕设开发教程-filter实战31

  1 package me.gacl.web.filter;
  2 
  3 import java.io.ByteArrayOutputStream;
  4 import java.io.IOException;
  5 import java.io.OutputStreamWriter;
  6 import java.io.PrintWriter;
  7 import java.util.HashMap;
  8 import java.util.Map;
  9 
 10 import javax.servlet.Filter;
 11 import javax.servlet.FilterChain;
 12 import javax.servlet.FilterConfig;
 13 import javax.servlet.ServletException;
 14 import javax.servlet.ServletOutputStream;
 15 import javax.servlet.ServletRequest;
 16 import javax.servlet.ServletResponse;
 17 import javax.servlet.http.HttpServletRequest;
 18 import javax.servlet.http.HttpServletResponse;
 19 import javax.servlet.http.HttpServletResponseWrapper;
 20 
 21 /**
 22 * @ClassName: WebResourceCachedFilter
 23 * @Description: Web资源缓存过滤器
 24 * @author: 孤傲苍狼
 25 * @date: 2014-9-8 上午12:20:16
 26 *
 27 */ 
 28 public class WebResourceCachedFilter implements Filter {
 29     /**
 30     * @Field: map
 31     *          缓存Web资源的Map容器
 32     */ 
 33     private Map map = new HashMap();
 34     
 35     @Override
 36     public void init(FilterConfig filterConfig) throws ServletException {
 37 
 38     }
 39 
 40     @Override
 41     public void doFilter(ServletRequest req, ServletResponse resp,
 42             FilterChain chain) throws IOException, ServletException {
 43         HttpServletRequest request = (HttpServletRequest) req;
 44         HttpServletResponse response = (HttpServletResponse) resp;
 45         //1.得到用户请求的uri
 46         String uri = request.getRequestURI();
 47         //2.看缓存中有没有uri对应的数据
 48         byte b[] = map.get(uri);
 49         //3.如果缓存中有,直接拿缓存的数据打给浏览器,程序返回
 50         if(b!=null){
 51             //根据字节数组和指定的字符编码构建字符串
 52             String webResourceHtmlStr = new String(b,response.getCharacterEncoding());
 53             System.out.println(webResourceHtmlStr);
 54             response.getOutputStream().write(b);
 55             return;
 56         }
 57         //4.如果缓存没有,让目标资源执行,并捕获目标资源的输出
 58         BufferResponse myresponse = new BufferResponse(response);
 59         chain.doFilter(request, myresponse);
 60         //获取缓冲流中的内容的字节数组
 61         byte out[] = myresponse.getBuffer();
 62         //5.把资源的数据以用户请求的uri为关键字保存到缓存中
 63         map.put(uri, out);
 64         //6.把数据打给浏览器
 65         response.getOutputStream().write(out);
 66     }
 67 
 68     @Override
 69     public void destroy() {
 70 
 71     }
 72 
 73     class BufferResponse extends HttpServletResponseWrapper{
 74         private ByteArrayOutputStream bout = new ByteArrayOutputStream();  //捕获输出的缓存
 75         private PrintWriter pw;
 76         private HttpServletResponse response;
 77         public BufferResponse(HttpServletResponse response) {
 78             super(response);
 79             this.response = response;
 80         }
 81         @Override
 82         public ServletOutputStream getOutputStream() throws IOException {
 83             return new MyServletOutputStream(bout);
 84         }
 85         @Override
 86         public PrintWriter getWriter() throws IOException {
 87             pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
 88             return pw;
 89         }
 90         
 91         public byte[] getBuffer(){
 92             try{
 93                 if(pw!=null){
 94                     pw.close();
 95                 }
 96                 return bout.toByteArray();
 97             }catch (Exception e) {
 98                 throw new RuntimeException(e);
 99             }
100         }
101     }
102 
103     class MyServletOutputStream extends ServletOutputStream{
104         private ByteArrayOutputStream bout;
105         public MyServletOutputStream(ByteArrayOutputStream bout){  //接收数据写到哪里
106             this.bout = bout;
107         }
108         @Override
109         public void write(int b) throws IOException {
110             bout.write(b);
111         }
112     }
113 }

编程小白的毕设开发教程-filter实战32

  在web.xml中配置Web资源缓存过滤器

编程小白的毕设开发教程-filter实战33

 1   
 2        Web资源缓存过滤器
 3       WebResourceCachedFilter
 4       me.gacl.web.filter.WebResourceCachedFilter
 5   
 6   
 7   
 8       WebResourceCachedFilter
 9       
10       /login.jsp
11       /test.jsp
12       /test2.jsp
13   

编程小白的毕设开发教程-filter实战34

勿删,copyright占位
分享文章到微博
分享文章到朋友圈

上一篇:java基础学习笔记(七)-反射--注解

下一篇:Elasticsearch 升级 7.x 版本后,我感觉掉坑里了!

您可能感兴趣

  • 基于生物特征信息的身份识别(指纹、面部识别的方式和原理)的使用问题的思考

    1.应用现状及应用案例介绍 近年来,随着互联网的飞速发展,各式各样的应用也不断发展,给我们的生活带来了极大的便捷。生活中,我们日常使用我们个人的指纹以及面部信息来识别个人身份,还有虹膜技术和声纹识别技术。 以上提到的四种技术,都是将我们的个人身份特征信息用于身份识别,但严格来说,我们的个人身份信息都是属于我们的个人隐私,个人隐私的界定是在个人生活中不愿为他人公开或知悉的秘密,判断是否属于个人...

  • WebRTC资源

    一、官方资源 官方网站:http://webrtc.org(官网还是最权威的) 2013谷歌I/O大会对WebRTC的介绍:视频(https://www.youtube.com/watch?v=p2HzZkd2A40),ppt(http://io13webrtc.appspot.com/#1)(讲的不错) 2012谷歌I/O大会对WebRTC的介绍:http://youtu.be/E8C8o...

  • 计算机必备专用英语词汇

    非常好的单词整理,转载一下当作笔记 1.单词说明:   command n. 命令,指令 [kə'mɑ:nd]   单词拼写 名词 单词含义 音标(发音)   提示:着重记忆单词对应的意思,有能力最好词性也记忆。 2.词性说明: n v vi vt conj prep pron adj adv 名词 动词 非及物动词 及物动词 连词 介词 代词 形容词 副词 3.单词列表: 1.file,n...

  • 单日课程超10万节!VIPKID 如何通过实时计算提升上课体验?

    行业解决方案、产品招募中!想赚钱就来传!>>> 摘要:对于以互联网形式的在线教育来说,实时计算应用的场景非常之多,如何通过数据计算来更快、更高效地反馈学习效果保证课程质量是在线教育领域不断探索的主题。本文将从以下四个部分分享,与大家探讨在直播上课过程中如何通过实时计算来提高人效以及系统处理能力。 VIPKID 介绍 核心业务场景 技术实现 总结 Tips: 查看更多最佳实践文章可点击文末链接...

  • 人工智能那么火~如今AI的应用场景都有哪些?

    作者:新智元 链接:https://www.zhihu.com/question/282715644/answer/1329782546 来源:知乎 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 【未来5年AI应用报告】谷歌、DeepMind、英伟达科学家支招企业AI应用 ReWork的一份最新AI落地应用报告,阐述了企业该如何使用AI技术。谷歌的Ian GoodFe...

  • 没有美术功底想学3D建模可能吗?

    一 3d建模一般学多久?太长的话,我就不玩了。 3d建模学多久这个问题不是很好回答,鬼才知道你的实力怎么样,努力的态度怎么样,如果你三天打鱼两天晒网,我估计一万年也学不会。如果你全力以赴认真的学,五六个月就能很好的玩转3D建模,当然如果你想达到大神级别的水平,还得在有实力的基础上,练个两三年,毕竟高手也不是一下是高手的,曾经也是小菜鸟,想一步登天的,容易踩空,扯着大腿跟。 有的小伙伴说如果3...

  • 工业界如何解决NER问题?12个trick,与你分享~

    NER是一个已经解决了的问题吗?或许,一切才刚刚开始。 例如,面对下面笔者在工作中遇到的12个关于NER的系列问题,你有什么好的trick呢?不着急,让我们通过本篇文章,逐一解答~ Q1、如何快速有效地提升NER性能(非模型迭代)? Q2、如何在模型层面提升NER性能? Q3、如何构建引入词汇信息(词向量)的NER? Q4、如何解决NER实体span过长的问题? Q5、如何客观看待BERT在...

  • 新职业教育的三节课,凭什么做到今天这样

    历时7天、翻遍15个平台渠道、访谈25位参与课程的从业者、挖掘了136条推文的标题和内容,我们得到了12500字的拆解。可以点击右上角☝:收藏、分享、在看,不用担心看一半,找不到文章。 本文信息公开来源:三节课官方公众号、虎嗅网、36氪、深网、东方财富网、新榜、知乎、简书、增长黑盒、短书··· 我们认为,这可能比任何官方复盘更能诠释:「三节课」是如何在3年内,做到互联网职业教育(Almost...

华为云40多款云服务产品0元试用活动

免费套餐,马上领取!
CSDN

CSDN

中国开发者社区CSDN (Chinese Software Developer Network) 创立于1999年,致力为中国开发者提供知识传播、在线学习、职业发展等全生命周期服务。