Servlet、Filter、Listener、Interceptor

由于最近两个月工作比较清闲，个人也比较“上进”，利用工作空余时间，也继续学习了一下，某天突然想起struts2和struts1的区别的时候，发现为什么struts1要用servlet，而struts2要用filter呢？一时又发现，servlet和filter有什么区别呢？于是看了看web.xml，一时又发现，咦，servlet、filter、listener？还有个interceptor？对于这几个概念，本应是初学者就掌握的东东了，可惜本人基础学的不好，只能是现在补课。于是就有了这篇博客。
 
         慢慢来吧，需要补课的地方还有很多很多呀。初学的时候都不知道他们存在呢。呵呵。
 
         下面从几个方面阐述一下题目中四个概念的区别与联系：
 
         1、概念
 
         2、生命周期
 
         3、职责
 
         4、执行过程
 
        
 
         一、概念：
 
         1、servlet：servlet是一种运行服务器端的java应用程序，具有独立于平台和协议的特性，并且可以动态的生成web页面，它工作在客户端请求与服务器响应的中间层。
 
         2、filter：filter是一个可以复用的代码片段，可以用来转换HTTP请求、响应和头信息。Filter不像Servlet，它不能产生一个请求或者响应，它只是修改对某一资源的请求，或者修改从某一的响应。
 
        3、listener：监听器，从字面上可以看出listener主要用来监听只用。通过listener可以监听web服务器中某一个执行动作，并根据其要求作出相应的响应。通俗的语言说就是在application，session，request三个对象创建消亡或者往其中添加修改删除属性时自动执行代码的功能组件。
 
         4、interceptor：是在面向切面编程的，就是在你的service或者一个方法，前调用一个方法，或者在方法后调用一个方法，比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。
 
      5、servlet、filter、listener是配置到web.xml中，interceptor不配置到web.xml中，struts的拦截器配置到struts.xml中。spring的拦截器配置到spring.xml中。
 
 
        二、生命周期：
 
        1、servlet：servlet的生命周期始于它被装入web服务器的内存时，并在web服务器终止或重新装入servlet时结束。servlet一旦被装入web服务器，一般不会从web服务器内存中删除，直至web服务器关闭或重新结束。
          (1)、装入：启动服务器时加载Servlet的实例；
        (2)、初始化：web服务器启动时或web服务器接收到请求时，或者两者之间的某个时刻启动。初始化工作有init（）方法负责执行完成；
        (3)、调用：从第一次到以后的多次访问，都是只调用doGet()或doPost()方法；
        (4)、销毁：停止服务器时调用destroy()方法，销毁实例。
 
        
 
           2、filter：（一定要实现javax.servlet包的Filter接口的三个方法init()、doFilter()、destroy()，空实现也行）
         (1)、启动服务器时加载过滤器的实例，并调用init()方法来初始化实例；
         (2)、每一次请求时都只调用方法doFilter()进行处理；
         (3)、停止服务器时调用destroy()方法，销毁实例。

       

3、listener：类似于servlet和filter
 
           web.xml 的加载顺序是：context- param -> listener -> filter -> servlet
 
       4、interceptor：以struts的拦截器为例，加载了struts.xml以后，初始化相应拦截器。当action请求来时调用intercept方法，服务器停止销毁interceptor。
 
       三、职责
 
       1、servlet：
 
        创建并返回一个包含基于客户请求性质的动态内容的完整的html页面；
        创建可嵌入到现有的html页面中的一部分html页面（html片段）；
        读取客户端发来的隐藏数据；
        读取客户端发来的显示数据；
        与其他服务器资源（包括数据库和java的应用程序）进行通信；
        通过状态代码和响应头向客户端发送隐藏数据。
 
       2、filter：
 
        filter能够在一个请求到达servlet之前预处理用户请求，也可以在离开servlet时处理http响应：
        在执行servlet之前，首先执行filter程序，并为之做一些预处理工作；
        根据程序需要修改请求和响应；
        在servlet被调用之后截获servlet的执行
 
         3、listener：职责如概念。
 
          servlet2.4规范中提供了8个listener接口，可以将其分为三类，分别如下：
         第一类：与servletContext有关的listner接口。包括：ServletContextListener、ServletContextAttributeListener
         第二类：与HttpSession有关的Listner接口。包括：HttpSessionListner、HttpSessionAttributeListener、HttpSessionBindingListener、                      HttpSessionActivationListener；
         第三类：与ServletRequest有关的Listener接口，包括：ServletRequestListner、ServletRequestAttributeListener
 
        4、interceptor：与过滤器十分相似，通过层层拦截，处理用户的请求和响应。
 
 
 
 
        四、几个区别：
 
        1,servlet 流程是短的，url传来之后，就对其进行处理，之后返回或转向到某一自己指定的页面。它主要用来在 业务处理之前进行控制.
        2,filter 流程是线性的， url传来之后，检查之后，可保持原来的流程继续向下执行，被下一个filter, servlet接收等，而servlet 处理之后，不会继续向下传递。filter功能可用来保持流程继续按照原来的方式进行下去，或者主导流程，而servlet的功能主要用来主导流程。
         filter可用来进行字符编码的过滤，检测用户是否登陆的过滤，禁止页面缓存等
        3, servlet,filter都是针对url之类的，而listener是针对对象的操作的，如session的创建，session.setAttribute的发生，在这样的事件发生时做一些事情。
     可用来进行：Spring整合Struts,为Struts的action注入属性，web应用定时任务的实现，在线人数的统计等
 
       4，interceptor 拦截器，类似于filter,不过在struts.xml中配置，不是在web.xml,并且不是针对URL的，而是针对action,当页面提交action时，进行过滤操作，相当于struts1.x提供的plug-in机制，可以看作，前者是struts1.x自带的filter,而interceptor 是struts2 提供的filter.
    与filter不同点：（１）不在web.xml中配置，而是在struts.xml中完成配置，与action在一起
                            ( 2  ) 可由action自己指定用哪个interceptor 来在接收之前做事   

由于Interceptor（HandlerInterceptor ）是Spring MVC的功能组件，所以需要把此拦截器配置在springmvc的xml配置文件中 。见 http://blog.csdn.net/zzy7075/article/details/52925317

       5，struts2中的过滤器和拦截器的区别与联系：
 
      （1）、拦截器是基于java反射机制的，而过滤器是基于函数回调的。
      （2）、过滤器依赖与servlet容器，而拦截器不依赖与servlet容器。
      （3）、拦截器只能对Action请求起作用，而过滤器则可以对几乎所有请求起作用。
      （4）、拦截器可以访问Action上下文、值栈里的对象，而过滤器不能。
      （5）、在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时被调用一次。
 
        
 
        五、执行流程图：
 
         1、servlet：

          

            2、filter：           

                                          3、listener：              

            4、interceptor：             

=============================================================

Java之Interceptor和Filter

 

 

最近研究了下Spring的HandlerInterceptor和Java的Filter，因为经常搞混它们两个，今天整理个笔记记录一下。

 

HandlerInterceptor 是Spring里面的拦截器

Filter是Java里面的过滤器

 

共同点 还是贴下Java里面的注释吧，解释还是很到位的：

 * <p>A HandlerInterceptor gets called before the appropriate HandlerAdapter

 * triggers the execution of the handler itself. This mechanism can be used

 * for a large field of preprocessing aspects, e.g. for authorization checks,

 * or common handler behavior like locale or theme changes. Its main purpose

 

 * is to allow for factoring out repetitive handler code.

 

 * <p>HandlerInterceptor is basically similar to a Servlet 2.3 Filter, but in

 * contrast to the latter it just allows custom pre-processing with the option

 * of prohibiting the execution of the handler itself, and custom post-processing.

 * Filters are more powerful, for example they allow for exchanging the request

 * and response objects that are handed down the chain. Note that a filter

 * gets configured in web.xml, a HandlerInterceptor in the application context.

 *

 * <p>As a basic guideline, fine-grained handler-related preprocessing tasks are

 * candidates for HandlerInterceptor implementations, especially factored-out

 * common handler code and authorization checks. On the other hand, a Filter

 * is well-suited for request content and view content handling, like multipart

 * forms and GZIP compression. This typically shows when one needs to map the

 * filter to certain content types (e.g. images), or to all requests.

 

  解释下吧：

  HandlerInteceptor一般用于权限验证，以及一些处理风格本地化等公共代码。

  Filter一般用于修改请求内容和界面的解析处理相关。

 

  Inteceptor的三个方法：

  

Java代码  

1. //做实际的请求之前调用  
2. //返回true会接着链式调用  
3. //返回false终止链式调用  
4. boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)  
5.         throws Exception;  
6.   
7.   
8. //请求之后，解析视图界面之前调用  
9. void postHandle(  
10.             HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)  
11.             throws Exception;  
12.   
13. //解析完界面之后调用  
14. void afterCompletion(  
15.             HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)  
16.             throws Exception;  
17.   
18. // 在mvc-dispatcher-servlet.xml或者applicationContext.xml中配置  
19.     <!--interceptors begin-->  
20.     <mvc:interceptors>  
21.         <bean class="com.xxx.AllInterceptor"/>  
22.     </mvc:interceptors>  
23.     <!--interceptors end-->  

   

    Filter配置

    

Java代码  

1. @Component  
2. public class RequestLogFilter implements Filter{  
3.   
4.     @Override  
5.     public void destroy() {  
6.         System.out.println("destory");  
7.     }  
8.   
9.     @Override  
10.     public void doFilter(ServletRequest request, ServletResponse response,  
11.             FilterChain chain) throws IOException, ServletException {  
12.         // TODO Auto-generated method stub  
13.         System.out.println("doFilter");  
14.         chain.doFilter(request , response);  
15.           
16.     }  
17.   
18.     @Override  
19.     public void init(FilterConfig filterConfig) throws ServletException {  
20.         // TODO Auto-generated method stub  
21.         System.out.println("init");  
22.           
23.     }  
24.   
25. }  
26.   
27.   
28. // web.xml配置  
29. <filter>  
30.     <filter-name>testFilter</filter-name>  
31.     <filter-class>com.abcd.system.RequestLogFilter</filter-class>  
32. </filter>  
33. <filter-mapping>  
34.     <filter-name>testFilter</filter-name>  
35.     <url-pattern>/*</url-pattern>  
36. </filter-mapping>  

   

   测试结果顺序：发现filter会在前面处理

   init

   doFilter

   preHandle

   postHandle

   afterCompletion

=================================================

前段时间参与一个项目，过滤器用的是Interceptor 觉得比以前用的Filter好用很多，现在拿出来比较一下
Filter
    该过滤器的方法是创建一个类XXXFilter实现此接口，并在该类中的doFilter方法中声明过滤规则，然后在配置文件web.xml中声明他所过滤的路径
    <filter>
        <filter-name>XXXFilter</filter-name>
        <filter-class>
            com.web.util.XXXFilter
        </filter-class>
    </filter>
    
    <filter-mapping>
        <filter-name>XXXFilter</filter-name>
        <url-pattern>*.act

ion</url-pattern>
    </filter-mapping>

Interceptor 
     该过滤器的方法也是创建一个类XXXInterceptor实现此接口,在该类中intercept方法写过滤规则，不过它过滤路径的方法和Filter不同，它与strut.xml结合使用，
   创建一个strus.xml的子配置文件struts-l99-default.xml，它继承与struts2的struts-default，此配置文件是其他子配置文件的父类，只要是继承与该文件的配置文件所声明的路径都会被它过滤 如下
 <package name="XXX-default" namespace="/" extends="struts-default">
        <interceptors>
            <interceptor name="authentication" class="com.util.XXXInterceptor" />
            
            <interceptor-stack name="user">
                <interceptor-ref name="defaultStack" />
                <interceptor-ref name="authentication" />
            </interceptor-stack>

            <interceptor-stack name="user-submit">
                <interceptor-ref name="user" />
                <interceptor-ref name="token" />
            </interceptor-stack>

            <interceptor-stack name="guest">
                <interceptor-ref name="defaultStack" />
            </interceptor-stack>

            <interceptor-stack name="guest-submit">
                <interceptor-ref name="defaultStack" />
                <interceptor-ref name="token" />
            </interceptor-stack>

        </interceptors>
        <default-interceptor-ref name="user" />
   </package>
 比较一,filter基于回调函数，我们需要实现的filter接口中doFilter方法就是回调函数，而interceptor则基于java本身的反射机制,这是两者最本质的区别。
 比较二,filter是依赖于servlet容器的，即只能在servlet容器中执行，很显然没有servlet容器就无法来回调doFilter方法。而interceptor与servlet容器无关。
 比较三，Filter的过滤范围比Interceptor大,Filter除了过滤请求外通过通配符可以保护页面，图片，文件等等，而Interceptor只能过滤请求。
 比较四，Filter的过滤例外一般是在加载的时候在init方法声明,而Interceptor可以通过在xml声明是guest请求还是user请求来辨别是否过滤。

================================

首先，JSP/Servlet规范中定义了Servlet、Filter、Listener这三种角色，并没有定义Interceptor这个角色，Interceptor是某些MVC框架中的角色，比如Struts2中，Interceptor是用来拦截Action中的方法的调用，在被拦截的Action方法被执行前，先执行响应的拦截器中的方法。
servlet、filter、listener是配置到web.xml中，interceptor不配置到web.xml中，struts的拦截器配置到struts.xml中。spring的拦截器配置到spring.xml中。


servlet、filter、listener三者的加载顺序与它们在 web.xml 文件中配置的先后顺序无关。即不会因为filter写在listener的前面而会先加载filter：加载它们的先后顺序是：listener -> filter -> servlet
同时还存在着这样一种配置节：context-param，它用于向 ServletContext 提供键值对，即应用程序上下文信息。我们的 listener, filter 等在初始化时会用到这些上下文中的信息，那么 context-param 配置节是不是应该写在 listener 配置节前呢？实际上 context-param 配置节可写在任意位置，因此真正的加载顺序为：context-param -> listener -> filter -> servlet


context-param、listener、 filter、 servlet的加载顺序不是配置时先后顺序的影响，但是多个filter时，filter之间的加载顺是受影响的。web 容器启动时初始化每个 filter 时，是按照 filter 配置节出现的顺序来初始化的，当请求资源匹配多个 filter-mapping 时，filter 拦截资源是按照 filter-mapping 配置节出现的顺序来依次调用 doFilter() 方法的。


==================================Filter=============================================
filter过滤器是在Java Servlet规范2.3中定义的，在Java Servlet规范2.3出来之前，是没有filter这个角色的。
filter这个角色是用来：在请求到达servlet之前，先截获请求，对请求先做一些预处理(例如编码转换，权限验证)。处理完后在把请求转发给servlet或把不符合某些规则的请求丢弃掉，不再转发给servlet了。当servlet处理好请求后，返回响应给浏览器时，filter拦截响应，对响应做一些处理之后，再返回给浏览器。由此可见，filter这个角色的职责就是：帮servlet做一些前期预处理工作(先于servlet处理request)和善后工作(后于servlet处理response)的辅助角色，它就像servlet的助手一样，但它并不是必须的，因为在之前没有filter的时候，servlet也能很好地工作。只是如果有filter的帮助的话，servlet就能更专注处理一些核心的业务。
多个filter可以协同工作，它们之间采用了职责链的设计模式来协同工作。一个filter处理完后，调用下一个filter来处理，每个filter负责处理不同的工作，而这些filter之间可以根据需要灵活组合。filter的先后顺序按filter在web.xml中配置的先后顺序。
filter需要servlet容器(tomcat)的支持，能运行filter的servlet容器必须实现在Java Servlet规范2.3版中定义的功能。servlet容器是对javax.servlet.Filter这个接口进行编程的，所以你自己写的filter必须直接或间接的实现了javax.servlet.Filter这个接口，否则servlet容器不能跟你定义的filter进行交互(因为在编程实现容器时，就把javax.servlet.Filter这个接口编进容器代码中了，容器只能调用javax.servlet.Filter接口的实现类）。




=====================================Listener============================================
listener是对事件进行监听和处理的角色，它采用观察者模式，只有当在这个listener上注册了的事件
发生时，listener才会执行事件处理方法。这些事件举例：上下文(context)加载事件；session创建或销毁事件；容器、session或请求的属性设置或移除事件等。


servlet2.4规范中提供了8个listener接口，可以将其分为三类，分别如下：
第一类：与servletContext(Application)有关的listner接口。包括：ServletContextListener、ServletContextAttributeListener
第二类：与HttpSession有关的Listner接口。包括：HttpSessionListner、HttpSessionAttributeListener、HttpSessionBindingListener、                                                     HttpSessionActivationListener；
第三类：与ServletRequest有关的Listener接口，包括：ServletRequestListner、ServletRequestAttributeListener




=====================================Interceptor=========================================
Interceptor是某些MVC框架中的角色，比如Struts2中，Interceptor是用来拦截Action中的方法的调用，在被拦截的Action方法被执行前，先执行响应的拦截器中的方法。interceptor：是在面向切面编程的，就是在你的service或者一个方法，前调用一个方法，或者在方法后调用一个方法，比如动态代理就是拦截器的简单实现。filter是在servlet前面拦截请求，而interceptor是利用面向切面编程的技术，在Struts的内部Action中拦截调用方法请求。