JDK动态代理、责任链在mybatis中的应用

一：JDK的动态代理

概念性质的东西就不谈了，毕竟网上很多。JDK的动态代理要求接口和接口的实现类

public interface Target {
    public void execute();
}
/**
 * Target的实现类
 * @author wpr
 *
 */
public class TargetImpl implements Target {
    @Override
    public void execute() {
        System.out.println("execute");
    }
}

　　a.JDK原生的动态代理写法

　要求实现InvocationHandler接口，在invoke方法内实现拦截的逻辑（不懂得去看JDK的动态代理）

public class TargetProxy implements InvocationHandler{
    Target target;
    public TargetProxy(Target target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("拦截前");
        Object o= method.invoke(target, args);
        System.out.println("拦截后");
        return o;
    }
}

测试的类：

    @Test
    public void test3(){
        Target target = new TargetImpl();
        target = (Target) Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(),new TargetProxy(target));
        target.execute();
    }

以上就是JDK动态代理的实现，但是存在问题，Proxy.newProxyInstance(..)完全可以交给TargetProxy来处理，于是第二版出现

public class TargetProxy implements InvocationHandler{
    //...........上面的代码省略了...............
    public static Object bind(Target target){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), new TargetProxy(target));
    }
}

测试类：

@Test
public void test2(){
    Target target = new TargetImpl();
    target = (Target) TargetProxy.bind(target);
    target.execute();
}

但还是存在问题，业务代码如果是execute()的话，所有的逻辑都写死在invoke()方法里面了，不符合设计模式的要求。结合面向切面的编程，做如下说明，target.execute()视为业务代码，在invoke()方法前进行插入切面（例如记录日志、开启事务等），设计Interceptor接口

public interface Interceptor {
public void intercept();
}
intercept()方法负责处理各种前期准备，下面是Interceptor的两个实现类

public class LogInterceptor implements Interceptor{
    @Override
    public void intercept(){
        System.out.println("日志记录开始");
    }
}


public class TransactionInterceptor implements Interceptor {
    @Override
    public void intercept() {
        System.out.println("事务开启");
    }
}

代理对象进一步改变，为了形象的说明是拦截器栈，所以我用了Stack，但是感觉使用List（ArrayList更合理一点）

public class TargetProxy implements InvocationHandler{
private Target target;
private Stack<Interceptor> interceptorStack;

public TargetProxy(Target target, Stack<Interceptor> interceptorStack) {
    this.target = target;
    this.interceptorStack = interceptorStack;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    for(Interceptor interceptor:interceptorStack){
        interceptor.intercept();
    }
    return method.invoke(target, args);
}

}

在每次执行业务代码execute（…）之前都会拦截,测试代码如下：

@org.junit.Test
public void test() {
    Stack<Interceptor> interceptorStack =new Stack<>();
    interceptorStack.add(new LogInterceptor());
    interceptorStack.add(new TransactionInterceptor());

    Target target = new TargetImpl();
    target = (Target) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),new TargetProxy(target, interceptorStack));
    target.execute();
}

接下来更近一步，根据代码的设计准则，将不变的和变化的分离开。我们设计一个Invocation的类，先看下它的实现：

（其实这个地方还可以这样理解：为了在Interceptor中得到被拦截对象的信息，需要定义一种数据结构来表示被拦截的方法，就是Invocation。这样就实现了拦截器Interceptor和具体的对象之间的解耦）

public class Invocation {
private Object target;
private Method method;
private Object[] args;

public Invocation(Object target, Method method, Object[] args) {
    this.target = target;
    this.method = method;
    this.args = args;
}
/**
 * 调用代理类的方法
 * @return
 * @throws IllegalAccessException
 * @throws IllegalArgumentException
 * @throws InvocationTargetException
 */
public Object process() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    return method.invoke(target, args);
}
   //省略了getter和setter       
}

Invocation类就是将被代理的目标类对立出出来，target表示目标类，method是拦截的方法，args是方法参数，于是新的TargetProxy变成了下面的样子。仅仅是invoke

public class TargetProxy implements InvocationHandler{
private Target target;
private Interceptor interceptor;

public TargetProxy(Target target,Interceptor interceptor) {
    this.target = target;
    this.interceptor= interceptor;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    Invocation invocation = new Invocation(target, method, args);
    return interceptor.intercpt(invocation);
}

}
同时，要改变Interceptor的行为：

public interface Interceptor {

    public Object intercpt(Invocation invocation) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;
}

具体的实现如下，一定返回invocation.process();要不然拦截就会断掉

public class LogInterceptor implements Interceptor{

    @Override
    public Object intercpt(Invocation invocation) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        System.out.println("打印日志");
        return invocation.process();
    }

}
但是问题又出现了，我们希望目标类只需要了解拦截它的类就可以，并不需要知道它的代理类，于是把target的拦截过程放在Interceptor接口中完成（实际操作交个TargetProxy）。最终我们的Interceptor接口变成了

public interface Interceptor {
    public Object intercept(Invocation invocation) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;
    public Object register(Object object);
}
public class LogInterceptor implements Interceptor{
    @Override
    public Object intercept(Invocation invocation) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        System.out.println("日志拦截前：");
        return invocation.process();
    }
    @Override
    public Object register(Object target) {
        return TargetProxy.bind(target, this);
    }
}


public class TargetProxy implements InvocationHandler{
    private Object target;
    private Interceptor interceptor;

    public TargetProxy(Object target, Interceptor interceptor) {
        this.target = target;
        this.interceptor = interceptor;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Invocation invocation = new Invocation(target, method, args);
        return interceptor.intercept(invocation);
    }

    public static Object bind(Object target,Interceptor interceptor){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(),new TargetProxy(target,interceptor));
    }
}

到此为止，目标类仅需要知道在执行前应该由谁去拦截它就可以了，测试代码如下：

@org.junit.Test
public void test() {
    Target target = new TargetImpl();
    Interceptor interceptor = new LogInterceptor();
    target =(Target) interceptor.register(target);
    target.execute();
}

好处显而易见，在使用时根本不必知道代理的存在，只要定义业务逻辑，和对业务逻辑的拦截（切面），然后把他们绑定在一起就可以了。

二：责任链

以上代码实现了对一个业务的一次拦截，但如果对其进行多次拦截的话就需要用到责任链了（依然略过概念，自己google吧）

public class InterceptorChain {
    private Stack<Interceptor> interceptors;

    public InterceptorChain(Stack<Interceptor> interceptors) {
        this.interceptors = interceptors;
    }
    public Object registerAll(Object target){
        for(Interceptor interceptor:interceptors){
            target = TargetProxy.bind(target, interceptor);
        }
        return target;
    }
    public void addInterceptor(Interceptor interceptor){
        interceptors.add(interceptor);
    }
    public Stack<Interceptor> getInterceptor(){
        return (Stack<Interceptor>) Collections.unmodifiableCollection(interceptors);
    }
}

registerAll(…)方法来完成对目标的全部代理，一层一层的包裹，测试类

@Test
public void interceptorChainTest(){
    Stack<Interceptor> interceptors = new Stack<>();
    LogInterceptor logInterceptor = new LogInterceptor();
    TransactionInterceptor transactionInterceptor = new TransactionInterceptor();
    interceptors.add(logInterceptor);
    interceptors.add(transactionInterceptor);
    InterceptorChain interceptorChain = new InterceptorChain(interceptors);

    Target target = new TargetImpl();
    target= (Target)interceptorChain.registerAll(target);
    target.execute();
}

以上内容都比较基础和理论，但mybatis的Interceptor完全是我们这样实现的

注：摘自网络
原文地址
 https://www.cnblogs.com/kakaxisir/p/4579110.html

JDK动态代理、责任链在mybatis中的应用

猜你喜欢