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!
反射方法后逻辑！

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