拦截器与动态代理

拦截器与动态代理

---

在开发中动态代理比较难以理解，程序设计者会设计一个拦截器接口供实际开发者使用，开发者只需要知道接口中方法的含义以及作用即可，无须考虑动态代理如何实现。

首先，我们先定义一个拦截器接口

import java.lang.reflect.Method;

public interface Interceptor {
    /**
     * 
     * @param proxy 代理对象
     * @param target 真实对象
     * @param method 方法
     * @param args 参数
     * @return
     */

    //在方法调度之前执行，返回true则反射真实方法；返回false 调用around方法
    public boolean before(Object proxy,Object target,Method method,Object[] args);

    public void around(Object proxy,Object target,Method method,Object[] args);
    //在真实方法或者around方法执行后执行
    public void after(Object proxy,Object target,Method method,Object[] args);
}

我们要理解，在动态代理中的代理对象调用的方法实际上是InvocationHandler接口中的invoke方法，在这个方法中可以添加程序设计者自己的逻辑，甚至无须反射真实方法。其中我们的拦截器就可以理解为程序设计者自己的逻辑。

下面我们来实现这个拦截器接口

import java.lang.reflect.Method;

public class MyInterceptor implements Interceptor {

    @Override
    public boolean before(Object proxy, Object target, Method method,
            Object[] args) {
        System.err.println("在反射方法前执行的逻辑");
        return false;//返回false则意味不反射真实方法
    }

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

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

}

接下来将在JDK动态代理中使用拦截器

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import com.lean.ssm.chapter2.proxy.HelloWorld;
import com.lean.ssm.chapter2.proxy.HelloWorldImpl;

public class InterceptorJdkProxy implements InvocationHandler{

    private Object target; // 真实对象

    private String interceptorClass = null; //拦截器的全限定名                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

    //在构造方法中初始化属性
    public InterceptorJdkProxy(Object target , String interceptorClass){
        this.target = target;
        this.interceptorClass = interceptorClass;
    }

    //绑定代理对象和真实对象的关系

    public static Object bind(Object target, String interceptorClass){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new InterceptorJdkProxy(target, interceptorClass) );
    }


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

        if(interceptorClass == null){
                //  如果没有设置拦截器则自动反射原有方法
            return method.invoke(target, args);
        }
        Object result = null;

        //通过反射生成拦截器实例
        Interceptor interceptor = (Interceptor) Class.forName(interceptorClass).newInstance();

        //通过before方法判断执行around 或者是 原有方法
        if(interceptor.before(proxy, args, method, args)){
            result = method.invoke(target, args);
        }else{
            interceptor.around(proxy, args, method, args);
        }
        interceptor.after(proxy, args, method, args);
        return result;
    }

    //测试方法
    public static void main(String[] args) {
        HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImpl(),
                "com.lean.ssm.chapter2.interceptor.MyInterceptor");

        proxy.sayHelloWorld();
    }
}