javaweb 中的过滤器包装器

时间：2015-07-30 13:37:09 阅读：166 评论：0 收藏：0 [点我收藏+]

标签：

过滤器要做的事情:
请求过滤器:完成安全检查，重新格式化请求首部或体，建立请求审计或日志
响应过滤器:
   压缩响应流，追加或修改响应流创建一个完全不同的响应.

过滤器和servlet三个相似地方:
1.容器知道过滤器的api,过滤器api的其他成员可以访问ServletContext 还可以与其它过滤器链接
2.容器管理过滤器的生命周期，过滤器有init和destroy方法，还有doFilter方法
3.web应用可以有很多过滤器，需要在配置文件中配置

过滤器的生命周期
init 容器实例化一个过滤器时，在init方法中完成调用过滤器之前所有的初始化任务。保存filterConfig对象
的一个引用，以备过滤去以后使用.
其次调用 doFIlter 可以保存用户名记录到一个文件中，压缩响应输出。
最后destroy删除一个过滤器实例，

FilterChain的doFIlter 方法要负责明确接下来调用谁的doFilter放大，如果到达链尾,则要确定调用哪个servlet的service方法。

在配置文件中确定过滤器的顺序
在配置文件中做三件事
1.声明过滤器
2.将过滤器映射到你想过滤的web资源
3，组织这些映射，创建过滤器调用序列
声明过滤器
<filter>
   <filter-name>BeerRequest</filter-name>
   <filter-class>com.gac.test.BeerRequestFilter</filter-class>
   <init-param>
       <param-name>LogFileName</param-name>
       <param-value>UserLog.txt</param-value>
   </init-param>
</filter>
声明url模式的过滤器映射
<filter-mapping>
   <filter-name>BeerRequest</filter-name>
   <url-pattern>*.do</url-pattern>
</filter-mapping>
声明对应servlet名的过滤器映射
<filter-mapping>
   <filter-name>BeerRequest</filter-name>
   <servlet-name>AdviceServlet</servlet-name>
</filter-mapping>

为通过请求分派请求的web资源声明一个过滤器映射
<filter-mapping>
   <filter-name>MonitorFilter</filter-name>
   <url-pattern>*.do</url-pattern>
   <dispatcher>REQUEST</dispatcher>
   和/或
   <dispatcher>INCLUDE</dispatcher>
   和/或
   <dispatcher>FORWARD</dispatcher>
   和/或
   <dispatcher>ERRO</dispatcher>
</filter-mapping>
声明规则:
必须要有filter-name
必须要有url-pattern或servlet-name元素其中之一
可以有0-4个dispatcher
Request值表示对客户端请求启用过滤器，如果没有指定<dispatcher>元素，则默认为
Rquest

INCLUDE值表示对由一个include()调用分派来的请求启用过滤器
FORWARD值表示对一个由forward()调用分派来的请求启用过滤器
ERROR值表示对错误处理调用资源启用过滤器

过滤器请求路径例子
<filter-mapping>
   <filter-name>Filter1</filter-name>
   <url-pattern>/Recipes/*<url-pattern>       /Recipes/HopsReport.do 过滤器序列 1 5

</filter-mapping>                  /Recipes/HopsList.do 过滤器 15 2
<filter-mapping>
   <filter-name>Filter2</filter-name>          /Recipes/Modify/ModRecipes.do 过滤器 1 5 4
   <url-pattern>/Recipes/HopsList.do<url-pattern> /HopsList.do 过滤器 5
</filter-mapping>
<filter-mapping>                                         /Recipes/Add/AddRecipes.do 过滤器 1 3 5
   <filter-name>Filter3</filter-name>
   <url-pattern>/Recipes/Add/*<url-pattern>
</filter-mapping>
<filter-mapping>
   <filter-name>Filter4</filter-name>
   <url-pattern>/Recipes/Modify/ModRecipes.do<url-pattern>
</filter-mapping>
<filter-mapping>
   <filter-name>Filter5</filter-name>
   <url-pattern>/*<url-pattern>

</filter-mapping>

/**************************************************************/

//过滤器必须实现Filter接口
public class BeerRequestFilter implements Filter{

   private FilterConfig fc;
   //完成清理工作
   @Override
   public void destroy() {
       // TODO Auto-generated method stub

   }

   //具体的业务逻辑
   @Override
   public void doFilter(ServletRequest req, ServletResponse resp,
           FilterChain chain) throws IOException, ServletException {
       // TODO Auto-generated method stub
       HttpServletRequest httpReq = (HttpServletRequest) req;//可以将请求和响应对象强制转换为Http类型
       String name = httpReq.getRemoteUser();
       if(name != null){
           fc.getServletContext().log("User"+name +"is updating");
       }
       chain.doFilter(req, resp);//接下来要调用的过滤器或者servlet

   }

   //必须实现init 通常仅仅在其中保存配置config对象
   @Override
   public void init(FilterConfig config) throws ServletException {
       // TODO Auto-generated method stub
       this.fc = config;
   }

}

/***************************************************************/

为过滤器压缩数据响应为了不实现太多的函数减少复杂性可以利用包装器，
利用包装器的示例
public class CompressFilter implements Filter{

   private ServletContext ctx;
   private FilterConfig cfg;
   @Override
   public void destroy() {
       // TODO Auto-generated method stub
       cfg = null;
       ctx = null;
   }


   //这个过滤器核心是用装饰包装响应对象，他用一个压缩的IO流包装输出流.
   //当且仅当客户包含一个Accept-Encoding首部才会完成输出流压缩
   @Override
   public void doFilter(ServletRequest request, ServletResponse response,
           FilterChain chain) throws IOException, ServletException {
       // TODO Auto-generated method stub
       HttpServletRequest req = (HttpServletRequest)request;
       HttpServletResponse resp =(HttpServletResponse) response;

       String valid_encodings = req.getHeader("Accept-Encoding");//客户是否接收gzip压缩
       if( valid_encodings.indexOf("gzip") > -1 ){
           ComPressResponseWrapper wrappedResp = new ComPressResponseWrapper(resp);
           wrappedResp.setHeader("Content-Encoding","gzip");
           chain.doFilter(req, wrappedResp);

           GZIPOutputStream gzos = wrappedResp.getGZIPOutputStream();
           gzos.finish();
           ctx.log(cfg.getFilterName()+": finished the request. ");

       }else{
           ctx.log(cfg.getFilterName()+": no encoding performed.");
       }
   }

   //init方法保存配置对象，并保存servlet上下文对象的一个直接引用以便完成日志记录
   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
       // TODO Auto-generated method stub
       this.cfg = filterConfig;
       ctx = cfg.getServletContext();
       ctx.log(cfg.getFilterName()+" initialized.");
   }

}

public class ComPressResponseWrapper extends HttpServletResponseWrapper{

   private GZIPServletOutputStream servletGzipOS = null;//servlet响应的压缩输出流
   private PrintWriter pw = null;

   public ComPressResponseWrapper(HttpServletResponse response) {
       super(response);
       // TODO Auto-generated constructor stub
   }

   public void setContentLength(int len){}

   /*过滤器使用这个装饰器的方法压缩过滤器提供一个GZIP输出流的句柄，以便过滤器完成和刷新输出GZIP流*/
   public GZIPOutputStream getGZIPOutputStream(){
       return this.servletGzipOS.internalGzipOS;

   }

   private Object streamUsed = null;//允许访问所装饰的servlet输出流
   public ServletOutputStream getOutputStream()throws IOException{
       //仅当servlet还没有访问打印书写器时允许servlet访问servlet输出流
           if((null != streamUsed) && (streamUsed!=pw)){
               throw new IllegalStateException();
           }

           //用我们的压缩输出流包装原来的servlet输出流
           if(servletGzipOS == null){
               servletGzipOS =
                       new GZIPServletOutputStream(getResponse().getOutputStream());

               streamUsed = servletGzipOS;
           }
           return servletGzipOS;
   }

   //运行访问所装饰的打印书写器
   public PrintWriter getWriter() throws IOException{
       if((streamUsed != null) && (streamUsed != servletGzipOS)){
           throw new IllegalStateException();
       }
       if(pw == null){
           servletGzipOS =
                   new GZIPServletOutputStream(getResponse().getOutputStream());
           OutputStreamWriter osw =
                   new OutputStreamWriter(servletGzipOS,getResponse().getCharacterEncoding());
           pw = new PrintWriter(osw);
           streamUsed = pw;
       }
       return pw;
   }

}
class GZIPServletOutputStream extends ServletOutputStream{

   /*internalGzipOs保存对原始Gzip流的一个引用，这个实例变量在包范围内私有，所以响应包装器可以访问这个变量*/
   GZIPOutputStream internalGzipOS;
   //装饰器构造函数
   GZIPServletOutputStream(ServletOutputStream sos) throws IOException{
       this.internalGzipOS = new GZIPOutputStream(sos);
   }
   //这个方法把write调用委托给GZIP压缩流从而实现压缩装饰 GZIP压缩流包装了原来的ServletOutputStream
   @Override
   public void write(int b) throws IOException {
       // TODO Auto-generated method stub
       internalGzipOS.write(b);
   }

}

javaweb 中的过滤器包装器

标签：

原文地址：http://blog.csdn.net/gaoanchen/article/details/47147717

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

javaweb 中的过滤器 包装器

javaweb 中的过滤器包装器