Java 代理模式（动态代理）

代理模式

为其他对象提供一个代理以控制对某个对象的访问。代理类主要负责为委托了（真实对象）预处理消息、过滤消息、传递消息给委托类，代理类不现实具体服务，而是利用委托类来完成服务，并将执行结果封装处理，动态代理在Java中有着广泛的应用，最常见的可能就是Spring AOP了，还有Java注解对象获取、日志等各个方面。

由于Java动态代理与Java反射机制关系紧密，所以在阅读这篇文章之前读者需要对Java反射机制有一定的了解，如果不了解反射机制也不需要慌，这里推荐一篇文章反射机制详解，这篇文章对Java反射的各个方面都做了详细的解说，相信看完这篇文章之后就不会对Java反射机制那么陌生了。

动态代理的整个流程

1. 创建被代理的类（委托类、真实类）（RealSubject）及其接口（RealSubjectInterface）
2. 创建一个实现接口InvocationHandler的类（InvocationHandlerImpl），它必须实现接口的invoke方法
3. 通过Proxy的静态方法newProxyInstance（）， 创建一个代理对象（realSubjectProxy），RealSubjectInterface realSubjectProxy = (RealSubjectInterface)roxy.newProxyInstance(loader,interfaces,handler);
4. 通过代理对象（realSubjectProxy）调用 委托类对象（ realSubject）的方法

代码实现

• 先定义一个接口（RealSubjectInterface）

/**
 * 真实对象的实现接口:需要动态代理的接口
 */
public interface Person {
    void Pay();
}

• 接着创建一个被代理的类（RealSubject）继承这个接口

public class Student implements Person {

    @Override
    public void Pay() {
        Log.d("LEE", "Student.Pay: 支付50刀");
    }
}

• 创建一个实现接口InvocationHandler的类InvocationHandlerImpl

 /**
 * 每次生成动态代理类对象的时候都需要指定一个实现了该接口的调用处理器类
 **/
public class StudentProxy implements InvocationHandler {
    //我们要代理的真实对象
    private Student student;
    //构造函数，为真实对象赋初值
    StudentProxy(Student student) {
        this.student = student;
    }
    

    //三个参数分别对应的是：代理对象，方法以及方法的参数
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        //在代理真实对象前可以添加额外操作
        Log.d("LEE", "StudentProxy(Before).Pay: 支付50刀");
        //当代理对象调用真实对象的方法时，其会自动跳转到代理对象关联的handler对象的invoke方法来进行调用
        method.invoke(student,objects);
        //在代理真实对象之后可以添加额外操作
        Log.d("LEE", "StudentProxy(After).Pay: 支付50刀");
        return null;
    }
}

• 调用代理类

        Student student = new Student();
        InvocationHandler handler = new StudentProxy(student);
        //创建一个代理对象person ，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        Person person = (Person) Proxy.newProxyInstance(student.getClass().getClassLoader(),student.getClass().getInterfaces(),handler);
        person.Pay();

newProxyInstance：最终真正的代理类，它继承自Proxy并实现了我们定义的RealSubjectInterface 接口

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
loader:　　    一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces:　　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)
h:　　         一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

NewProxyInstance源码（这里只挑重要的来讲解）

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
         //生成代理类对象
        Class<?> cl = getProxyClass0(loader, intfs);

        //使用指定的调用处理程序获取代理类的构造函数对象
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            //如果Class作用域为私有，通过 setAccessible 支持访问
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //获取Proxy Class构造函数，创建Proxy代理实例。
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

Class<?> cl = getProxyClass0(loader, intfs);
重点在于这句话，利用getProxyClass0(loader, intfs)生成代理类Proxy的Class对象

  private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        //如果接口数量大于65535，抛出非法参数错误
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

       
        //如果指定接口的代理类已经存在与缓存中，则不用新创建，直接从缓存中取即可；
        //如果缓存中没有指定代理对象，则通过ProxyClassFactory来创建一个代理对象。
        return proxyClassCache.get(loader, interfaces);
    }

总结动态代理的原理如下：
1、根据代理类接口先得到代理类的类全限名、方法列表、异常列表
2、根据步骤1中的类全限名、方法列表、异常列表、接口列表生成class文件格式的字节流，其中方法的实现会最终调用InvoationHanlder的invoke方法
3、使用类加载器加载步骤2中的字节流，创建生成动态代理类对象
4、使用步骤3中创建生成的代理类对象