Go语言视频零基础入门到精通

javalearner

如果想用过滤器捕获Servlet对客户端的响应输出并且对它进行修改，就必须在响应被发送回客户端之前，在服务器端缓存这个响应。Servlet API为我们提供了：
     HttpServletResponseWrapper类
利用它我们可以截获响应并在本地缓存，然后想做什么就做什么。
下面是一个可重用的响应包装器：
/*
* CharResponseWrapper
*@author Karl Moss
*/ package com.omh.filters; import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
  
  
   
   
     
   

     
   
  

1. /**
   
2. * Simple response wrapper that utilizes a local CharArrayWriter
   
3. * for output
   
4. */
   
5. public class CharResponseWrapper
   
6.         extends HttpServletResponseWrapper
   
7. {
   
8.     protected CharArrayWriter charWriter;//将响应缓存在这个写入器中
   
9.     protected PrintWriter writer;
   
10.     protected boolean getOutputStreamCalled;
    
11.     protected boolean getWriterCalled;
    
12.     public CharResponseWrapper(HttpServletResponse response)
    
13.     {
    
14.         super(response);
    
15.         // Create the writer
    
16.         charWriter = new CharArrayWriter();
    
17.     }
    
18.     public ServletOutputStream getOutputStream()
    
19.         throws IOException
    
20.     {
    
21.         // Can"t call getOutputStream if getWriter
    
22.         // has already been called
    
23.         if (getWriterCalled)
    
24.         {
    
25.             throw new IllegalStateException(
    
26.                     "getWriter already called");
    
27.         }
    
28.         getOutputStreamCalled = true;
    
29.         return super.getOutputStream();
    
30.     }
    
31.     public PrintWriter getWriter()
    
32.         throws IOException
    
33.     {
    
34.         if (writer != null)
    
35.         {
    
36.             return writer;
    
37.         }
    
38.         // Can"t call getWriter if getOutputStream
    
39.         // has already been called
    
40.         if (getOutputStreamCalled)
    
41.         {
    
42.             throw new IllegalStateException(
    
43.                     "getOutputStream already called");
    
44.         }
    
45.         getWriterCalled = true;
    
46.         writer = new PrintWriter(charWriter);
    
47.         return writer;
    
48.     }
    
49.     public String toString()//将响应数据用字符串返回
    
50.     {
    
51.         String s = null;
    
52.         // Only return a String if the writer was
    
53.         // used.
    
54.         if (writer != null)
    
55.         {
    
56.             s = charWriter.toString();
    
57.         }
    
58.         return s;
    
59.     }
    
60.    
61.    public char[] toCharArray(){//将响应数据以字符数组返回
    
62.                 return(charWriter.toCharArray());
63.   }
    
64. }
    

复制代码

利用上面包装器把一个servlet响应全部改变成大写形式：

1. /*
   
2. * UpperCaseFilter
   
3. * @author  Karl Moss
   
4. */
   
5. package com.omh.filters;
   
6. import javax.servlet.*;
   
7. import javax.servlet.http.*;
   
8. import java.io.*;
   
9. /**
   
10. * Filter that uses a response wrapper to convert all
    
11. * output to upper case
    
12. */
    
13. public class UpperCaseFilter
    
14.         implements Filter
    
15. {
    
16.     protected FilterConfig config;
    
17.     public void init(FilterConfig config)
    
18.         throws ServletException
    
19.     {
    
20.         // Save the config object
    
21.         this.config = config;
    
22.     }
    
23.     public void destroy()
    
24.     {
    
25.     }
    
26.     public void doFilter(ServletRequest request,
    
27.                          ServletResponse response,
    
28.                          FilterChain chain)
    
29.         throws ServletException, IOException
    
30.     {
    
31.         ServletResponse newResponse = response;
    
32.         // If this is an HttpRequest, wrap the response
    
33.         // with our CharArrayWriter so that we can get
    
34.         // the contents
    
35.         if (request instanceof HttpServletRequest)
    
36.         {
    
37.             newResponse = new CharResponseWrapper(
    
38.                     (HttpServletResponse) response);
    
39.         }
    
40.         // Invoke the next filter/servlet in the chain
    
41.         // using (perhaps) a wrapped response
    
42.         chain.doFilter(request, newResponse);
    
43.         if (newResponse instanceof CharResponseWrapper)
    
44.         {
    
45.             // Get the contents of the output. A String
    
46.             // is returned only if a Writer was used,
    
47.             // indicating text output. If getOutputStream
    
48.             // was used the output will go to the "real"
    
49.             // underlying output stream back to the client
    
50.             String text = newResponse.toString();
    
51.             if (text != null)
    
52.             {
    
53.                 text = text.toUpperCase();
    
54.                 // Now write the output to the real
    
55.                 // output stream that goes back to
    
56.                 // the client
    
57.                 response.getWriter().write(text);
    
58.             }
    
59.         }
    
60.     }
    
61. }
    
62.             

复制代码

过滤器配置： <filter>
<filter-name>Upper Case Filter</filter-name>
<filter-class>com.omh.filters.UpperCaseFilter</filter-class>
</filter>  <filter-mapping>
<filter-name>Upper Case Filter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
  运行图：   

  
  
   
   

     
   

     
   
  

复制代码

源码下载：http://file.javaxxz.com/2014/10/10/065926781.zip