JAVA动态代理源码分析

1.Proxy.newProxyInstance源码

Proxy的部分源码:

//Proxy类开始有这样的一个定义
private final static Class[] constructorParams = { InvocationHandler.class };
protected InvocationHandler h;

protected Proxy(InvocationHandler h) {
    // 给Proxy的成员h赋值,$Proxy类实例对象时会调用,使得Proxy父类持有InvocationHandler代理处理器
    this.h = h;
}

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

    // Proxy类的方法getProxyClass，根据传入的接口的Class对象与类加载器创建$proxy0类
    Class cl = getProxyClass(loader, interfaces);

    // 通过反射带参数构造传入h实例化$proxy0，$proxy0类的带参构造内部为super(h)，其实就是给Proxy的成员h赋值，并返回此对象
    Constructor cons = cl.getConstructor(constructorParams);
    return (Object) cons.newInstance(new Object[] { h });
}

2.$Proxy0源码

• 自动生成的$Proxy0源码:

在调用Proxy.newProxyInstance之前，加一句System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”);，就会在项目的根目录生成一个com.sun.proxy.$Proxy0.class，本来这是字节码文件不能直接查看的，但IDEA会自动帮我们反编译class文件

• 源码介绍:
  0、程序运行时产生一个类$proxy01、$proxy0类继承自Proxy类,实现了目标对象的父类接口
  2、$proxy0类有多个Method成员变量，它的静态代码块给Method赋值为我们自己的接口的实现类的对应的Method对象3、$proxy0实现接口的方法调用了super.h.invoke(参数)，这里的参数包括Method变量

//java的动态代理只能代理接口interface。因为它已经继承了Proxy类，那么可变部分只有implements Subject了，如果同时代理了两个接口，那么这里implements后面会跟两个
public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        // InvocationHandler子类对象通过构造函数里的super(var1);传给了父类(Proxy)的成员变量h
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    // 接口的实现类的方法request
    public final void request() throws  {
        try {
            // 每次调用方法时执行InvocationHandler子类对象的invoker方法
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            //m3 = Class.forName("接口的实现类的路径").getMethod("实现类的方法",  new Class[0]); 
            m3 = Class.forName("dynamincProxy.Subject").getMethod("request");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

3.实验代码

1、创建接口
2、创建接口实现类
3、创建代理处理器，持有目标对象
4、使用Proxy.newProxyInstance动态生成代理对象，调用接口方法时就会执行代理处理器的invoke方法，该方法会调用真实目标对象的方法(接口方法的实现)

// 接口
public interface Subject {
    public void request();
}

//目标对象
class SubjectImpl implements Subject {

    @Override
    public void request(){
        System.out.println("I am dealing the request.");
    }
}

/**
 * 代理类的调用处理器
 */
class ProxyHandler implements InvocationHandler{
    private Subject subject;
    public ProxyHandler(Subject subject){
        this.subject = subject; // 持有真实的目标对象
    }
    
    // 自动生成的$Proxy0源
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    
    /*
    * 此函数在代理对象调用任何一个方法时都会被调用
    * proxy: 代理对象
    * method: 具体哪个方法被调用
    * args: 具体形参
    *
    * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    	System.out.println(proxy.getClass().getName()); // 输出代理类的名字
    	//定义预处理的工作，当然你也可以根据 method 的不同进行不同的预处理工作
        System.out.println("====before====");
        System.out.println(method);
        Object result = method.invoke(subject, args); // 调用真实的目标对象
        System.out.println("====after====");
        return result;
    }
}
import java.lang.reflect.Proxy;

//动态代理模式
public class DynamicProxyDemo {
    public static void main(String[] args) {
    	//1.创建目标对象
    	Subject realSubject = new SubjectImpl();
    	
    	//2.创建调用处理器对象
    	ProxyHandler handler = new ProxyHandler(realSubject); 
    	
        /*
        * 3.动态生成代理对象
        * proxySubject真实类型com.sun.proxy.$Proxy0
        * proxySubject继承Proxy类，实现Subject接口
        * newProxyInstance的第二个参数，就是指定代理对象的接口
        * */
        Subject proxySubject = 
        		(Subject)Proxy.newProxyInstance
        		  (SubjectImpl.class.getClassLoader(),
                   SubjectImpl.class.getInterfaces(), handler); 

        //4.客户端通过代理对象调用方法
        //本次调用将自动被代理处理器的invoke方法接收
        proxySubject.request();    
        
        System.out.println(proxySubject.getClass().getName());
        System.out.println(proxySubject.getClass().getSuperclass().getName());
    }
}

4.动态代理流程图