Java动态代理机制分析

前言

Java动态代理通过反射的机制实现在运行时，基于传入的指定一组接口及委托类对象，动态的产生代理类，代理类负责将所有的方法调用分派到委托对象上反射执行。动态代理类的创建十分简单：

InvocationHandler handler = new MyInvocationHandler(...);
     Class proxyClass = Proxy.getProxyClass(
         Foo.class.getClassLoader(), new Class[] { Foo.class });
     Foo f = (Foo) proxyClass.
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });

或者

 Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);

有动态代理，那一定有静态代理。所以我们先从静态代理看起，一步步分析Java的动态代理机制。

静态代理

说到静态代理，其实就是我们手工对代理模式的实现。代理模式是什么呢？

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

代理模式的UML图如下所示：

Markdown

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

我们看一个简单的代理模式的例子：

public interface Bird {
    public void fly();
}
public class RealBird implements Bird {
    private String name;

    public RealBird(String name) {
        this.name = name;
    }

    public void fly() {
        System.out.println(String.format("%s is flying...", name));
    }
}

public class ProxyBird implements Bird{
    private String name;
    
    private Bird bird;
    
    public ProxyBird(String name) {
        this.name = name;
    }

    public void fly() {
        if (null == bird){
            this.bird = new RealBird(name);
        }
        bird.fly();
    }
}
public class ProxyExample {
    public static void main(String[] args){
        Bird eagle = new RealBird("eagle");
        Bird swan = new ProxyBird("swan");
        eagle.fly();
        swan.fly();
    }
}
eagle is flying...
swan is flying...

代理模式使得代理类控制了客户端对委托类的访问，这使得我们可以在代理类中做一些其他的操作，如日志记录、统计、缓存等，这些都是对用户隐藏的。同时代理类实现与委托类相同接口，代理模式的使用对用户来说是透明的。
Java动态代理使得我们不必手写大量代理类，通过反射方式，在使用时动态的生成代理类。

动态代理

相关类与接口

动态代理的核心就在于java.lang.reflect.Proxy类与java.lang.reflect.InvocationHandler这个接口。

• Proxy类：它是Java动态代理的生成器，它提供了以下静态方法来生成动态代理类。

public static Class getProxyClass(ClassLoader loader,
                                         Class... interfaces);//根据传入的类加载器、接口生成代理类对象
public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h);//根据传入的类加载器、接口、调用处理器动态生成代理类
public static InvocationHandler getInvocationHandler(Object proxy);//获取代理类对应的调用处理器

• InvocationHandler

public Object invoke(Object proxy, Method method, Object[] args);//调用处理器接口，每个动态类必须关联一个InvocationHandler，通过反射在代理类上执行传入的方法。

源码分析

我们通过一个简单的动态代理的例子来具体分析动态代理机制。

public interface Subject {
    public void doSomething();
}
public class RealSubject implements Subject{

    public void doSomething() {
        System.out.println("do something...");
    }
}
public class ProxyInvocationHandler implements InvocationHandler{
    private Object proxies;
    
    public ProxyInvocationHandler(Object proxies){
        this.proxies = proxies;
    }
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        //此处可以做一些方法调用的前置操作
        PrintUtil.print(String.format("proxy:%s,method:%s,args:%s", proxies,method,args));
        result = method.invoke(proxies, args);
        //此处可以做一些方法调用的后置操作
        return result;
    }
}
public class ProxyTest {
    public static void main(String[] args){
        Subject realSubject = new RealSubject();//实际对象
        Subject subject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[]{Subject.class}, new ProxyInvocationHandler(realSubject));
        subject.doSomething();
    }
}
do something...

从上面的简单例子我们可以总结出使用Java的动态代理的几个步骤：

我们从Proxy类的静态方法newProxyInstance开始追踪起，源码如下：

public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException{
        if (h == null) {
            throw new NullPointerException();
        }

        final Class[] intfs = interfaces.clone();//复制interfaces接口数组
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);//接口权限检查
        }

        /*
         * Look up or generate the designated proxy class.
         * 查找或生成代理类
         */
        Class cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            final Constructor cons = cl.getConstructor(constructorParams);//获取代理类的构造器对象
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction