JavaEE互联网轻量级框架整合开发（书籍）阅读笔记（4）：JDK动态代理+拦截器

一、拦截器的理解

　　学习拦截器之前需要对动态代理和反射有一定的基础。

　　官方说法：

　　        java里的拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行，同时也提供了一种可以提取action中可重用部分的方式。在AOP（Aspect-Oriented Programming）中拦截器用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。　

简单来说，就是拦截器可以提供一个在方法调用之前的方法，调用之后的方法，方便我们在方法执行的前后做拦截判或其他业务处理。

二、Jdk动态代理+拦截器

创建一个普通接口：HelloWorld.java

 package com.xfwl.proxy.jdk;

 public interface HelloWorld {
     public void  sayHelloWorld();
 }

创建一个上面皆接口的实现子类：HelloWorldImpl.java

 package com.xfwl.proxy.jdk;

 public class HelloWorldImpl implements HelloWorld {

     public void sayHelloWorld() {
         System.out.println("Hello World!");
     }
 }

创建一个拦截器的接口：Interceptor.java

package com.xfwl.interceptor;

import java.lang.reflect.Method;

/**
 * 定义一个拦截器接口
 * @function
 * @author 小风微凉
 * @time  2018-7-9 下午2:20:35
 */
public interface Interceptor {
    /**
     * 拦截器-真实方法调用之前before
     * @param proxy 代理对象
     * @param target 真实对象
     * @param method 真实方法
     * @param args 运行参数
     * @return 返回boolean  false则执行around(),true则不执行around()
     */
    public boolean before(Object proxy,Object target,Method method,Object[] args);
    /**
     * before()返回 false则执行around(),true则不执行around()
     * @param proxy 代理对象
     * @param target 真实对象
     * @param method 真实方法
     * @param args 运行参数
     */
    public void around(Object proxy,Object target,Method method,Object[] args);
    /**
     * before/around执行之后执行after()
     * @param proxy 代理对象
     * @param target 真实对象
     * @param method 真实方法
     * @param args 运行参数
     */
    public void after(Object proxy,Object target,Method method,Object[] args);
}

创建上面拦截器接口的实现子类：MyInterceptor.java

 package com.xfwl.interceptor;

 import java.lang.reflect.Method;
 /**
  * 拦截器实现子类
  * @function 理解拦截器之前需要理解动态代理+反射机制
  * @author 小风微凉
  * @time  2018-7-9 下午2:25:34
  */
 public class MyInterceptor implements Interceptor {

     @Override
     public boolean before(Object proxy, Object target, Method method,Object[] args) {
         System.out.println("反射方法前逻辑！");
         return false;
     }

     @Override
     public void around(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("取代了被代理对象的方法！");
     }

     @Override
     public void after(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("反射方法后逻辑！");
     }
 }

创建一个动态代理类：InterceptorJdkProxy.java

 package com.xfwl.interceptor;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 /**
  * JDK动态代理实现类
  * @function  在代理类中嵌入拦截器，关键点还是动态代理
  * @author 小风微凉
  * @time  2018-7-9 下午2:29:21
  */
 public class InterceptorJdkProxy implements InvocationHandler {
     //真实对象
     private Object target=null;
     //拦截器全称
     private String interceptorClass=null;
     //动态代理类构造器
     public InterceptorJdkProxy(){}
     public InterceptorJdkProxy(Object target,String interceptorClass){
         this.interceptorClass=interceptorClass;
         this.target=target;
     }
     /**
      *  给真实独享绑定代理对象
      * @param target  真实对象
      * @param interceptorClass  拦截器的全称
      * @return 代理对象【占位】
      */
     public  Object bind(Object target,String interceptorClass){
         return Proxy.newProxyInstance(
                 target.getClass().getClassLoader(),//真实对象的类加载器
                 target.getClass().getInterfaces(), //真实对象的实现接口
                 new InterceptorJdkProxy(target, interceptorClass)//实现了InvocationHandler接口的实现类，一般为当前代理类对象
         );
     }
     /**
      * 通过代理对象调用方法，首先进入这个方法
      * @param proxy 代理对象
      * @param method 方法
      * @param args 运行参数
      * @return
      */
     @Override
     public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
         //判断当前代理是否使用了拦截器
         if(interceptorClass==null){
             //没有拦截器，则直接执行真实对象的方法
             return method.invoke(this.target, args);
         }
         Object result=null;
         //通过反射拿到拦截器对象
         Interceptor interceptor =(Interceptor)Class.forName(interceptorClass).newInstance();
         //调用前置方法
         if(interceptor.before(proxy, args, method, args)){
             //反射真实对象原有的方法
             result=method.invoke(target, args);
         }else{
             //返回false，执行around方法
             interceptor.around(proxy, args, method, args);
         }
         //调用后置方法
         interceptor.after(proxy, args, method, args);
         return result;
     }
 }

创建一个测试类：TestInterceptor.java.

 package com.xfwl.interceptor;

 import com.xfwl.proxy.jdk.HelloWorld;
 import com.xfwl.proxy.jdk.HelloWorldImpl;

 /**
  * 拦截器测试
  * @function  测试一下拦截器是如何起作用的，
  * @author 小风微凉
  * @time  2018-7-9 下午2:19:15
  */
 public class TestInterceptor {

     /**
      * @param args
      */
     public static void main(String[] args) {
         //拿到代理对象，并绑定真实对象
         HelloWorld proxy=(HelloWorld) new InterceptorJdkProxy().bind(
                                                 new HelloWorldImpl(),
                                                 "com.xfwl.interceptor.MyInterceptor"
                                                 );
         //执行代理逻辑
         proxy.sayHelloWorld();

     }

 }

测试结果：

运行条件【1】：

 @Override
     public boolean before(Object proxy, Object target, Method method,Object[] args) {
         System.out.println("反射方法前逻辑！");
         return false;
     }

运行结果：

反射方法前逻辑！
取代了被代理对象的方法！
反射方法后逻辑！

运行条件【2】：

 @Override
     public boolean before(Object proxy, Object target, Method method,Object[] args) {
         System.out.println("反射方法前逻辑！");
         return true;
     }

运行结果：

反射方法前逻辑！
Hello World!
反射方法后逻辑！

从上面可以看出，拦截器生效了！