Servlet 4 过滤器

简单的Servlet， 但是一定要记住的是，Servlet 一共分为三种

    简单Servlet，是作为一种程序所必须的开发结构保存下来的

   过滤Servlet

   监听Servlet

   既然是一个Servlet，之前是采用了继承HttpServlet类的形式完成的，但是在过滤器中使用的不再是类而是接口

   如果想要完成一个过滤器开发的话，则首先必须让一个类实现Filter接口。此接口是javax.servlet包中的，那么根据此包的特点就可以发现，此接口的主要功能是完成公共协议操作的。

实现过滤器

   在Servlet中，如果要定义一个过滤器，则直接让一个类实现javax.servlet.Filter 接口即可，此接口地ing有了三个操作方法：

 1、void init(FilterConfig filterConfig) throwsServletException

  2、void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException, ServletException

  3、void destroy()

[java] view plain copy print ?

1. package org.gz.filter;  
2. import javax.servlet.*;  
3. import java.io.*;  
4.   
5.   
6. public class SimpleFilter implements Filter {  
7.     public void init(FilterConfig config) throws ServletException {  
8.         String info = config.getInitParameter("ref");  
9.         System.out.println("***  过滤器初始化开始  ***" + info);  
10.     }  
11.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
12.         throws IOException, ServletException {  
13.         System.out.println("执行doFilter");  
14.     }  
15.   
16.     public void destroy() {  
17.       System.out.println("******  过滤器销毁  ******");  
18.     }  
19. }  

  一个普通的Servlet，则在使用的时候必须手工调用，例如在form表单的action之中编写路径

  但是过滤这种操作本身可是 属于自动完成的。

    过滤器完成之后肯定也要开始进行配置的操作，但是在配置之前，先讲服务器启动一下，观察没有过滤器时的操作。

    此时，可以正确的出现文件的列表，下面开始增加配置

   

[html] view plain copy print ?

1. <servlet>  
2.         <servlet-name>filter</servlet-name>  
3.         <servlet-class>package org.gz.filter.SimpleFilter</servlet-class>  
4.         <init-param>  
5.             <param-name>ref</param-name>  
6.             <param-value>zhongtian</param-value>  
7.         </init-param>  
8.     </servlet>  
9.     <servlet-mapping>  
10.         <servlet-name>filter</servlet-name>  
11.         <url-pattern>/*</url-pattern>  
12.     </servlet-mapping>  

    此处配置的url-pattern 表示的是一个过滤器的过滤路径，现在既然是“/” 则表示对一个目录中的全部内容进行过滤

    过滤器不需要任何的配置就可以在服务器启动的时候自动的完成初始化的操作

    一个过滤器的基本生命周期与Servlet是非常相似的，但是现在为什么界面上生命都不显示了呢？

    FilterChain 表示把请求向下传递，如果后面还有过滤器，则继续过滤，如果没有则直接到目的地

    过滤器实际上是执行两次的，

    与Servlet一样，过滤器本身也可以对多个路径执行过滤，例如：

[html] view plain copy print ?

1. <filter-mapping>  
2.         <filter-name>simple</filter-name>  
3.         <url-pattern>/*</url-pattern>   
4.     </filter-mapping>  
5.     <filter-mapping>  
6.         <filter-name>simple</filter-name>  
7.         <url-pattern>/jsp/dom</url-pattern>   
8.     </filter-mapping>  
9.     <filter-mapping>  
10.         <filter-name>simple</filter-name>  
11.         <url-pattern>/jsp/*</url-pattern>   
12.     </filter-mapping>  

     实际上过滤器的基本概念比较简单，而且也比较好理解，但是该这么使用呢？从实际上来讲过滤器在开发中使用最频繁的两种操作，编码过滤，登录验证。

     对于编码肯定是所有页面都要使用的，而且只要是页面都要缩写： request.setCharaterEncoding()  方法 进行编码设置

[html] view plain copy print ?

1. <filter>  
2.         <filter-name>encoding</filter-name>  
3.         <filter-class>org.gz.filter.EncodingFilter</filter-class>  
4.         <init-param>  
5.             <param-name>charset</param-name>  
6.             <param-value>GBK</param-value>  
7.         </init-param>  
8.     </filter>  
9.     <filter-mapping>  
10.         <filter-name>encoding</filter-name>  
11.         <url-pattern>/*</url-pattern>   

[java] view plain copy print ?

1. package org.gz.filter;  
2. import javax.servlet.*;  
3. import java.io.*;  
4. // 在web.xml 下面设置所有被过滤的文件编码是 GBK  
5. public class LoginFilter implements Filter {  
6.     private String charSet;  
7.     public void init(FilterConfig config) throws ServletException {  
8.         this.charSet = config.getInitParameter("charset");  
9.     }  
10.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
11.         throws IOException, ServletException {  
12.         request.setCharacterEncoding(this.charSet);  
13.         chain.doFilter(request,response);  
14.           
15.     }  
16.   
17.     public void destroy() {  
18.     }  
19. }  

[java] view plain copy print ?

1. package org.gz.filter;  
2. import javax.servlet.*;  
3. import java.io.*;  
4.   
5. //org.gz.filter.SimpleFilter  
6. public class SimpleFilter implements Filter {  
7.     public void init(FilterConfig config) throws ServletException {  
8.         String info = config.getInitParameter("ref");  
9.         System.out.println("***  过滤器初始化开始  ***" + info);  
10.     }  
11.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
12.         throws IOException, ServletException {  
13.         System.out.println("执行doFilter() 之前");  
14.         chain.doFilter(request,response);  
15.         System.out.println("执行doFilter() 之后");  
16.     }  
17.   
18.     public void destroy() {  
19.       System.out.println("******  过滤器销毁  ******");  
20.       try  
21.       {  
22.         Thread.sleep(3000);  
23.       }  
24.       catch (Exception e)  
25.       {  
26.           e.printStackTrace();  
27.       }  
28.     }  
29. }  

   至于登录验证也是一个很重要的内容，因为在很多情况都需要通过session 完成登录验证的操作，但是如果每个页面都编写重复的 session 属性的判断，那么就变得相当的复杂，而且维护也不方便，所以可以对一些需要限制的地方采用登录验证操作

   先完成登录验证的过滤器

[java] view plain copy print ?

1. package org.gz.filter;  
2. import javax.servlet.*;  
3. import java.io.*;  
4. import javax.servlet.http.*;  
5. // 在web.xml 下面设置所有被过滤的文件编码是 GBK  
6. public class EncodingFilter implements Filter {  
7.   
8.     public void init(FilterConfig config) throws ServletException {  
9.       
10.       
11.     }  
12.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
13.         throws IOException, ServletException {  
14.         //session 术语http 协议范畴  
15.         HttpServletRequest req = (HttpServletRequest) request;  
16.         HttpSession ses = req.getSession();  
17.         if(ses.getAttribute("userid") != null) {  
18.             // 已经登录过了，则可以访问  
19.             chain.doFilter(request,response);  
20.         } else {  
21.             request.getRequestDispatcher("login.jsp").forward(request,response);      
22.         }  
23.           
24.     }  
25.   
26.     public void destroy() {  
27.     }  
28. }