设计模式－动态代理模式

之前介绍了代理模式，大家也都了解了代理模式，不过之前介绍的代理模式是静态代理，静态代理什么意思？静态代理指的是代理类是事先定义好的，在使用代理类的时候也是明确初始化定义的代理类。但是如果有非常多的类需要代理，那么一个个那么定义静态代理类的工作量将是非常大的，其实JDK已经给我们提供了现成的动态代理类，可以不用事先定义好所有的代理类，下面我们就介绍下JDK动态代理类。

JDK中动态代理主要涉及到的是两个类：java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy。下面我们先定义一下Subject接口和两个功能一样的实现类用于测试。

Subject.java 接口类

public interface Subject {
    public String doSomething(String name);
}

RealSubject.java 实际提供功能的类

public class RealSubject implements Subject {
    @Override
    public String doSomething(String name) {
        System.out.println(name + " do something!");
        return name + " do something!";
    }
}

需要实现动态代理功能的话实现一个代理类实现InvocationHandler的接口，并实现invoke方法。

例子中实现DynamicProxyAOP类用于在Subject类前后分别实现其他功能，类似AOP切面功能，其实Spring AOP的内部核心实现就是通过动态代理实现的。可以看到public Object invoke(Object proxy, Method method, Object[] args)方法有3个入参，proxy表示代理类，method表示调用的Subject主类的方法名，args表示调用代理方法的参数数组，在内部的具体实现我们通过反射方法通过method.invode来调用实际Subject方法。

public class DynamicProxyAOP implements InvocationHandler {
    private Object subject;

    public DynamicProxyAOP(Object subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //在执行真实subject执行的方法
        System.out.println("before do something");
        //执行真实subject方法
        Object rtn = method.invoke(subject, args);
        //在执行结束后再执行的方法
        System.out.println("after do something");

        return rtn;
    }
}

这样就定义好了动态代理的核心类，最后我们看下如何调用动态代理类。先分别定义RealSubject和RealSubject2两个类的对象，再分别实现两个DynamicProxyAOP的代理对象，DynamicProxyAOP的入参分别为这两个Subject的对象。接下来我们创建动态代理对象，通过调用Proxy的Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)来创建动态代理对象，第一个参数为实现代理类的ClassLoader，第二个参数为被代理类的接口数组，最后一个参数为继承自InvocationHandler的handler实现具体的代理功能。

public class DynamicProxyMain {

    public static void main(String[] args){
        Subject realSubject = new RealSubject();
        Subject realSubject2 = new RealSubject2();

        InvocationHandler handler = new DynamicProxyAOP(realSubject);
        InvocationHandler handler2 = new DynamicProxyAOP(realSubject2);

        Subject subject = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(),
                handler);

        Subject subject2 = (Subject) Proxy.newProxyInstance(realSubject2.getClass().getClassLoader(),
                realSubject2.getClass().getInterfaces(),
                handler2);

        String rtn = subject.doSomething("tester ");
        String rtn2 = subject2.doSomething("tester ");
    }
}

从打印出的日志可以发现，定义了两个不同的继承自Subject的类，但是动态代理对象是动态创建的，不需要像静态代理那样，再为每一个Subject实现类创建代理类，是不是很方便，后续大家如果要自己实现一些切面功能，就可以通过动态代理模式来实现，例如纪录日至之类的。

before do something
tester  do something!
after do something
before do something
tester  do something2!
after do something

本文实例中的源码：https://github.com/feiweiwei/designpattern