Java动态代理，底层详细解析

1.动态代理需要了解的知识

类反射机制

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

实例化Class类对象
1、前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高

Class cl = String.class;

2、前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象

Class cl ="abcabc".getClass();

3、前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出 ClassNotFoundException

Class cla= Class.forName("java.lang.String");

了解以下几个包下的类

• java.lang.Class:代表一个类
• java.lang.reflect.Method:代表类的方法
• java.lang.reflect.Field:代表类的成员变量
• java.lang.reflect.Constructor:代表类的构造方法

2.动态代理例子

要用到的几类和方法在如下包：

-java.lang.reflect.proxy
-java.lang.reflect.InvocationHandler

---

1.public interface InvocationHandler

参数
loader ：类加载器来定义代理类
interfaces ： 代理类实现的接口列表
h ：调度方法调用的调用处理函数

---

动态代理模拟图

1.Job接口

//抽象角色（要被代理的）
public interface Job {
    public void request();
}

2.Job的实现类

//真实角色
public class Company implements Job {
    public void request() {
        System.out.println("要招聘人才");
    }
}

3.动态生成类

用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
    //Setter被代理的接口
    private Job job;
    public void setJob(Job job){
        this.job=job;
    }
    //核心就在这个方法了，它返回的是一个代理对象
    public Object getProxy(){
        Job proxy = (Job)Proxy.newProxyInstance(this.getClass().getClassLoader(), job.getClass().getInterfaces(), this);
        System.out.println(proxy.getClass().toString());
        return proxy;
    }

    //处理代理实例，执行Job的方法，也就是说实现“要招聘人才”需求
    //重写InvocationHandler，invoke的方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before calling " + method);
        method.invoke(job, args);
        System.out.println("after calling " + method);
        return null;
    }
}

测试类

public class Client {
    public static void main(String[] args) {
   		 //真实角色，
        Company company = new Company();
        pih.setJob(company);
        //实例化动态生成代理的类
         ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //动态生成代理
    //System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        Job proxy = (Job)pih.getProxy();
        proxy.request();
    }
}

结果：

只看第三行，输出"要招聘人才"，确实通过代理模式把它输出了。其他不用看是我测试用的

3.疑惑解析

1.关于newProxyInstance()的三个参数

Proxy.newProxyInstance(this.getClass().getClassLoader(), 
job.getClass().getInterfaces(), this);

1.this.getClass().getClassLoader()这个是类加载器，用来定义代理类

拓展：因为每个编写的”.java”拓展名类文件都存储着需要执行的程序逻辑，这些”.java”文件经过Java编译器编译成拓展名为”.class”的文件，”.class”文件中保存着Java代码经转换后的虚拟机指令，当需要使用某个类时，虚拟机将会加载它的”.class”文件，并创建对应的class对象。而将class文件加载到虚拟机的内存，这个过程称为类加载
（如果在深入就要去了解Java虚拟机）

2.job.getClass().getInterfaces()就是获得这个接口

3.因为第三个参数需要传InvocationHandler对象，而我们当前类继承了这个接口，所以用this

2.由始至终没有调用invoke()方法，而会走它呢？

可以看到，在测试类中或者生成代理类中，我们并没有显示的调用invoke()方法。
1.我们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);
    }
    /*
     * Look up or generate the designated proxy class.
     */
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
}

看点：
1.Class<?> cl = getProxyClass0(loader, intfs);
2.final Constructor<?> cons = cl.getConstructor(constructorParams)

看点1中，泛型不用管，我们没有用到，这个两个参数loader，intfs就是我们刚刚传的类加载和接口（抽象角色）并且返回一个Class类对象cl，这个类就是我们要的创建代理类。

其实这个代理类的真实类名叫$Proxy0，在代码中我已经将这个代理类名输出了。
class com.sun.proxy.$Proxy0

这个.Clss类（所谓代理类）是Java虚拟机帮我们生成的，在虚拟机内存。我们现在把这个.class文件输出，反编译后，继续查看底层代码

//如果想看$Proxy0源码，可以在测试类上加这句话
//.class文件会生成在idea/当前项目/com/下
//（不是用Idea自己找,差不多，idea可以帮我们将.class文件反编译）
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

看点：
1.构造方法
2.方法 public final void request()

public final class $Proxy0 extends Proxy implements Job {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
......

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

当执行proxy.request()方法时，就调用了$Proxy0类中的request()方法，进而调用父类Proxy中的h的invoke()方法.即InvocationHandler.invoke()。就是代理类中实现的接口下的方法哦。

如果还不是不懂，继续看下面~~~
（这还是没return代理类对象前的那段代码…）

final Constructor<?> cons = cl.getConstructor(constructorParams);

将实例化$Proxy0并在构造方法中把类名为(ProxyInvocationHandler，这个类实现了InvocationHandler接口)传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下：

class Proxy{  
    InvocationHandler h=null;  
    protected Proxy(InvocationHandler h) {  
        this.h = h;  
    }  
    ....
}  

3.为什么用Job接收代理类对象

在查看完 $Proxy0 源码，就知道啦，它实现了Job接口，并且继承了Proxy 类

public final class $Proxy0 extends Proxy implements Job{
}

4.区分method.invoke()和重写的public Object invoke()

1.method.invoke()是method类下的方法：
public final class Method extends Executable {
public Object invoke(Object obj, Object… args)
}
2.InvocationHandler接口下的方法
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
}