Java动态代理研究

浅说动态代理

关于java的代理模式，此处不过多讲解。所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。动态代理指被代理者委托代理者完成相应的功能，是拦截器的一种实现方式，其用于拦截类或接口，内部可通过判断实现对某个方法的拦截。
日常使用中可能经常需要在方法调用时进行拦截，如调用前记录一下调用开始时间，调用结束后记录结束时间，就可以很方便的计算出调用方法的业务逻辑处理耗时。

动态代理使用

简单的看下最简单的使用：

1. 编写一个接口：

package my.java.reflect.test;

public interface Animal {
    void sayHello();
}

2. 委托类

public class Dog implements Animal {
    public void sayHello() {
        System.out.println("wang wang!");
    }
}

3. 拦截器

package my.java.reflect.test;

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

public class MyInvocationHandler implements InvocationHandler {
    private Object target;
    
    public Object bind(Object realObj) {
        this.target = realObj;
        Class[] interfaces = target.getClass().getInterfaces();
        ClassLoader classLoader = this.getClass().getClassLoader();
        return Proxy.newProxyInstance(classLoader, interfaces, this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy method");
        return method.invoke(target, args);
    }
    
}

4. 测试类

package my.java.reflect.test;

import org.junit.Test;

public class ProxyTest {
    
    @Test
    public void testNewProxyInstance() {
        Dog dog = new Dog();
        Animal proxy = (Animal) new MyInvocationHandler().bind(dog);
        proxy.sayHello();
    }

}

5. 输出

proxy method
wang wang!

动态代理原理总结

之所以将原理先总结了，因为希望把原理先用最简洁的语言说清楚，再来深入分析，否则在深入分析阶段粘贴过多的源码可能会导致阅读兴趣下降。

1. 通过Proxy#newProxyInstance方法得到代理对象实例；
2. 这个代理对象有着和委托类一模一样的方法；
3. 当调用代理对象实例的方法时，这个实例会调用你实现InvocationHandler里的invoke方法。

而这里，最复杂的显然是得到代理对象实例了，怎么得到的呢？来，看看源码！

动态代理原理

要了解java动态代理的原理只要从Proxy#newProxyInstance入手即可。

1. 先看newProxyInstance方法，关注有中文注释的地方即可

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
                                      Class[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    if (h == null) {// 没有实现InvocationHandler，直接失败
        throw new NullPointerException();
    }

    final Class[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     * 查找或者生成代理类的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