java-过滤器、拦截器

1.基础知识

1.1面向对象编程（OOP）、面向切面编程（AOP）

面向对象编程：

将需求功能划分为不同的、相对独立的和封装良好的类，使他们有属于自己的行为，依靠继承和多态等来定义彼此的关系。

面向切面编程：

将通用需求功能从不相关的类中分离出来，使很多类共享一个行为，一旦发生变化，只需修改这个行为即可。

http://blog.csdn.net/small_mouse0/article/details/62895790这个例子解释的比较容易理解。

1.2 Java反射机制

反射概念： 主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

反射机制的作用：

1，反编译：.class-->.java

2,通过反射机制访问java对象的属性，方法，构造方法等；

反射机制的类：

（Java反射相关的API在包java.lang.reflect中。）

java.lang.Class;

java.lang.reflect.Constructor; java.lang.reflect.Field;

java.lang.reflect.Method;

java.lang.reflect.Modifier;

反射就是把Java的各种成分映射成相应的Java类。

1.3 过滤器和拦截器的区别

　　①拦截器是基于Java的反射机制的，而过滤器是基于函数回调。

　　②拦截器不依赖与servlet容器，过滤器依赖与servlet容器。

　　③拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。

　　④拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。

　　⑤在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

⑥拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

1.过滤器是JavaEE标准，采用函数回调的方式进行。是在请求进入容器之后，还未进入Servlet之前进行预处理，并且在请求结束返回给前端这之间进行后期处理。

@Override

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

System.out.println("before...");

chain.doFilter(request, response);

System.out.println("after...");

}

　　chain.doFilter(request, response);这个方法的调用作为分水岭。事实上调用Servlet的doService()方法是在chain.doFilter(request, response);这个方法中进行的。

　　

2.拦截器是被包裹在过滤器之中的。

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

System.out.println("preHandle");

return true;

}

@Override

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

System.out.println("postHandle");

}

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

System.out.println("afterCompletion");

}

　　a.preHandle()这个方法是在过滤器的chain.doFilter(request, response)方法的前一步执行，也就是在 [System.out.println("before...")][chain.doFilter(request, response)]之间执行。

　　b.preHandle()方法之后，在return ModelAndView之前进行，可以操控Controller的ModelAndView内容。

　 c.afterCompletion()方法是在过滤器返回给前端前一步执行，也就是在[chain.doFilter(request, response)][System.out.println("after...")]之间执行。

3.SpringMVC的机制是由同一个Servlet来分发请求给不同的Controller，其实这一步是在Servlet的service()方法中执行的。所以过滤器、拦截器、service()方法，dispatc()方法的执行顺序应该是这样的，大致画了个图：其实非常好测试，自己写一个过滤器，一个拦截器，然后在这些方法中都加个断点，一路F8下去就得出了结论。

2.拦截器Interceptor

拦截器依赖的技术就是Java的动态代理。

2.1 模型分为以下模块

　　业务组件：是被代理和被拦截的对象。

　　代理处理器：实现了InvocationHandler接口的一个对象

　　代理对象：Proxy对象。

　　拦截器：普通的JavaBean，在调用业务方法的之前或者之后会自动拦截并执行自己的一些方法。

客户端：执行业务处理的入口。

2.2 模型的实现

　一、业务组件：分为业务接口和业务

/**

　　* 业务组件接口

　　*/

　　public interface BusinessInterface {

　　public void doSomething();

　　}

　　/**

　　* 业务组件

　　*/

　　public class BusinessClass implements BusinessInterface{

　　public void doSomething() {

　　System.out.println("业务组件BusinessClass方法调用:doSomething()");

　　}

　　}

二、代理处理器：包含了业务对象绑定动态代理类的处理，并实现了InvocationHandler接口的invoke方法。

import java.lang.reflect.InvocationHandler;

　　import java.lang.reflect.Method;

　　import java.lang.reflect.Proxy;

　　/**

　　* 动态代理处理器工具

　　*/

　　public class DynamicProxyHandler implements InvocationHandler {

　　private Object business; //被代理对象

　　private InterceptorClass interceptor = new InterceptorClass(); //拦截器

　　/**

　　* 动态生成一个代理类对象,并绑定被代理类和代理处理器

　　* @param business

　　* @return 代理类对象

　　*/

　　public Object bind(Object business) {

　　this.business = business;

　　return Proxy.newProxyInstance(

　　 //被代理类的ClassLoader

　　 business.getClass().getClassLoader(),

　　 //要被代理的接口,本方法返回对象会自动声称实现了这些接口

　　 business.getClass().getInterfaces(),

　　 //代理处理器对象

　　 this);

　　}

　　/**

　　* 代理要调用的方法,并在方法调用前后调用连接器的方法.

　　*

　　* @param proxy 代理类对象

　　* @param method 被代理的接口方法

　　* @param args 被代理接口方法的参数

　　* @return 方法调用返回的结果

　　* @throws Throwable

　　*/

　　public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

　　Object result = null;

　　interceptor.before();

　　result=method.invoke(business,args);

　　interceptor.after();

　　return null; //To change body of implemented methods use File | Settings | File Templates.

　　}

　　}

三、拦截器：普通的JavaBean，在调用业务方法的之前或者之后会自动拦截并执行自己的一些方法。

　　/**

　　* 拦截器

　　*/

　　public class InterceptorClass {

　　public void before(){

　　System.out.println("拦截器InterceptorClass方法调用:before()!");

　　}

　　public void after(){

　　System.out.println("拦截器InterceptorClass方法调用:after()!");

　　}

　　}

四、模拟客户端：执行业务处理的入口。

　　/**

　　* 客户端

　　*/

　　public class Client {

　　public static void main(String args[]) {

　　DynamicProxyHandler handler = new DynamicProxyHandler();

　　BusinessInterface business = new BusinessClass();

　　BusinessInterface businessProxy = (BusinessInterface) handler.bind(business);

　　businessProxy.doSomething();

　　}

　　}

2.3 SpringMVC中使用Interceptor拦截器

一、定义Interceptor实现类

SpringMVC 中的Interceptor 拦截请求是通过HandlerInterceptor 来实现的。在SpringMVC 中定义一个Interceptor 非常简单，主要有两种方式，第一种方式是要定义的Interceptor类要实现了Spring 的HandlerInterceptor 接口，或者是这个类继承实现了HandlerInterceptor 接口的类，比如Spring 已经提供的实现了HandlerInterceptor 接口的抽象类HandlerInterceptorAdapter ；第二种方式是实现Spring的WebRequestInterceptor接口，或者是继承实现了WebRequestInterceptor的类。

（一）实现HandlerInterceptor接口

HandlerInterceptor 接口中定义了三个方法，我们就是通过这三个方法来对用户的请求进行拦截处理的。

（1）preHandle (HttpServletRequest request, HttpServletResponse response, Object handle) 方法，顾名思义，该方法将在请求处理之前进行调用。SpringMVC 中的Interceptor 是链式的调用的，在一个应用中或者说是在一个请求中可以同时存在多个Interceptor 。每个Interceptor 的调用会依据它的声明顺序依次执行，而且最先执行的都是Interceptor 中的preHandle 方法，所以可以在这个方法中进行一些前置初始化操作或者是对当前请求的一个预处理，也可以在这个方法中进行一些判断来决定请求是否要继续进行下去。该方法的返回值是布尔值Boolean 类型的，当它返回为false 时，表示请求结束，后续的Interceptor 和Controller 都不会再执行；当返回值为true 时就会继续调用下一个Interceptor 的preHandle 方法，如果已经是最后一个Interceptor 的时候就会是调用当前请求的Controller 方法。

（2）postHandle (HttpServletRequest request, HttpServletResponse response, Object handle, ModelAndView modelAndView) 方法，由preHandle 方法的解释我们知道这个方法包括后面要说到的afterCompletion 方法都只能是在当前所属的Interceptor 的preHandle 方法的返回值为true 时才能被调用。postHandle 方法，顾名思义就是在当前请求进行处理之后，也就是Controller 方法调用之后执行，但是它会在DispatcherServlet 进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller 处理之后的ModelAndView 对象进行操作。postHandle 方法被调用的方向跟preHandle 是相反的，也就是说先声明的Interceptor 的postHandle 方法反而会后执行，这和Struts2 里面的Interceptor 的执行过程有点类型。Struts2 里面的Interceptor 的执行过程也是链式的，只是在Struts2 里面需要手动调用ActionInvocation 的invoke 方法来触发对下一个Interceptor 或者是Action 的调用，然后每一个Interceptor 中在invoke 方法调用之前的内容都是按照声明顺序执行的，而invoke 方法之后的内容就是反向的。

（3）afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handle, Exception ex) 方法，该方法也是需要当前对应的Interceptor 的preHandle 方法的返回值为true 时才会执行。顾名思义，该方法将在整个请求结束之后，也就是在DispatcherServlet 渲染了对应的视图之后执行。这个方法的主要作用是用于进行资源清理工作的。

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;

import org.springframework.web.servlet.ModelAndView;

public class SpringMVCInterceptor implements HandlerInterceptor {

/**

* preHandle方法是进行处理器拦截用的，顾名思义，该方法将在Controller处理之前进行调用，SpringMVC中的Interceptor拦截器是链式的，可以同时存在多个Interceptor，然后SpringMVC会根据声明的前后顺序一个接一个的执行，而且所有的Interceptor中的preHandle方法都会在 Controller方法调用之前调用。SpringMVC的这种Interceptor链式结构也是可以进行中断的，这种中断方式是令preHandle的返回值为false，当preHandle的返回值为false的时候整个请求就结束了。

*/

@Override

public boolean preHandle(HttpServletRequest request,

HttpServletResponse response, Object handler) throws Exception {

// TODO Auto-generated method stub

return false;

}

/**

* 这个方法只会在当前这个Interceptor的preHandle方法返回值为true的时候才会执行。postHandle是进行处理器拦截用的，它的执行时间是在处理器进行处理之

* 后，也就是在Controller的方法调用之后执行，但是它会在DispatcherServlet进行视图的渲染之前执行，也就是说在这个方法中你可以对ModelAndView进行操

* 作。这个方法的链式结构跟正常访问的方向是相反的，也就是说先声明的Interceptor拦截器该方法反而会后调用，这跟Struts2里面的拦截器的执行过程有点像，

* 只是Struts2里面的intercept方法中要手动的调用ActionInvocation的invoke方法，Struts2中调用ActionInvocation的invoke方法就是调用下一个Interceptor

* 或者是调用action，然后要在Interceptor之前调用的内容都写在调用invoke之前，要在Interceptor之后调用的内容都写在调用invoke方法之后。

*/

@Override

public void postHandle(HttpServletRequest request,

HttpServletResponse response, Object handler,

ModelAndView modelAndView) throws Exception {

// TODO Auto-generated method stub

}

/**

* 该方法也是需要当前对应的Interceptor的preHandle方法的返回值为true时才会执行。该方法将在整个请求完成之后，也就是DispatcherServlet渲染了视图执行，

* 这个方法的主要作用是用于清理资源的，当然这个方法也只能在当前这个Interceptor的preHandle方法的返回值为true时才会执行。

*/

@Override

public void afterCompletion(HttpServletRequest request,

HttpServletResponse response, Object handler, Exception ex)

throws Exception {

// TODO Auto-generated method stub

}

}

3.过滤器Filter

Servlet技术中的一种技术。

3.1 配置

在web.xml文件中配置该Filter，使用init-param元素为该Filter配置参数，init-param可接受如下两个子元素：

param-name：指定参数名。

param-value：指定参数值。

filter 、filter-mapping 、servlet、servlet-mapping 才构成一个完整的拦截器配置。

Filter类需要实现Filter接口，该接口有init、doFilter、destroy3个方法,，3个方法顺序执行。

1、新建一个类，实现Filter接口

2、实现doFilter()方法，打印一句话，来证明能够进行拦截

3、在web.xml中进行配置（参照Servlet配置）

4、访问一个页面，看看能不能拦截

1>[java] view plaincopy

package com.test.filter;

import java.io.IOException;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

public class Demo1Filter implements Filter {

private FilterConfig filterConfig;

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

{

System.out.println("Demo1过滤前");

System.out.println(filterConfig.getInitParameter("param1"));

chain.doFilter(request, response);//放行。让其走到下个链或目标资源中

System.out.println("Demo1过滤后");

}

public void init(FilterConfig filterConfig) throws ServletException {

System.out.println("初始化了");

this.filterConfig = filterConfig;

}

public void destroy() {

System.out.println("销毁了");

}

}

2>在web.xml中进行配置  [html] view plaincopy

<filter>

<filter-name>Demo1Filter</filter-name>

<filter-class>com.itheima.filter.Demo1Filter</filter-class>

<init-param>

<param-name>param1</param-name>

<param-value>value</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>Demo1Filter</filter-name>

<url-pattern>/*</url-pattern>

<dispatcher>REQUEST</dispatcher> <!-- 没有配置dispatcher就是默认request方式的 -->

<dispatcher>FORWARD</dispatcher>

<dispatcher>ERROR</dispatcher>

<dispatcher>INCLUDE</dispatcher>

</filter-mapping>

3.2 应用场景

1> 通过控制对chain.doFilter的方法的调用，来决定是否需要访问目标资源。

比如，可以在用户权限验证等等。判断用户是否有访问某些资源的权限，有权限放行，没权限不执行chain.doFilter方法。

2> 通过在调用chain.doFilter方法之前，做些处理来达到某些目的。

比如，解决中文乱码的问题等等。可以在doFilter方法前，执行设置请求编码与响应的编码。甚至可以对request接口进行封装装饰来处理get请求方式的中文乱码问题(重写相应的request.getParameter方法)。

3> 通过在调用chain.doFilter方法之后，做些处理来达到某些目的。

比如对整个web网站进行压缩。在调用chain.doFilter方法之前用类A对response对象进行封装装饰，重写getOutputStream和重写getWriter方法。在类A内部中，将输出内容缓存进ByteArrayOutputStream流中，然后在chain.doFilter方法执行后，获取类A中ByteArrayOutputStream流缓存数据，用GZIPOutputStream流进行压缩下。

3.3 实现拦截的原理

Filter接口中有一个doFilter方法，当开发人员编写好Filter类实现doFilter方法，并配置对哪个web资源进行拦截后，WEB服务器每次在调用web资源的service方法之前(服务器内部对资源的访问机制决定的)，都会先调用一下filter的doFilter方法。

3.4 生命周期

和Servlet一样Filter的创建和销毁也是由WEB服务器负责。不过与Servlet区别的是，它是：

1>在应用启动的时候就进行装载Filter类(与Servlet的load-on-startup配置效果相同)。

2>容器创建好Filter对象实例后，调用init()方法。接着被Web容器保存进应用级的集合容器中去了等待着，用户访问资源。

3>当用户访问的资源正好被Filter的url-pattern拦截时，容器会取出Filter类调用doFilter方法，下次或多次访问被拦截的资源时，Web容器会直接取出指定Filter对象实例调用doFilter方法(Filter对象常驻留Web容器了)。

4>当应用服务被停止或重新装载了，则会执行Filter的destroy方法，Filter对象销毁。

注意：init方法与destroy方法只会直接一次。