JDK的动态代理解读

动态代理即在不改变某个类的源码（被代理类）的情况下对源码做些操作，比如统计某个方法的执行时间，在某个方法前边或后边输出条日志等等。比如AOP

废话：无

正事：start

请先阅读代码后在看这段文字辅助理解。

我理解的动态代理原理：

Subject subject = Proxy.newProxyInstance(
        handler.getClass().getClassLoader(),
        realiSubject.getClass().getInterfaces(),
        handler);

这行代码直接生成了动态代理类实例（如何生成的...理解不够不晓得咋描述），

它有三个参数，分别为：

1：代理类或被代理类的类加载器（类加载器这块有点薄弱，理解下）

2：被代理类所实现的接口

3：实现了InvocationHandler接口的代理类

返回值subject这个局部变量就是被生成的动态代理类实例$Proxy0（这点很重要）

至于subject.hello("lilei") （subject.hai()同理）这行代码是如何执行的动态代理操作的，则可以通过第二部分的代码块代码阅读发现。

我们可以看见$Proxy0中的hello()方法就做了一个事就是

调用父类（Proxy类）h变量（InvocationHandler，这是个接口）的invoke方法，接口的方法在实际执行的时候都是执行的实现该接口的具体类的实例的方法，所以这个方法执行的是我们实现了InvocationHandler接口的代理类中的invoke。

invoke的参数可以自己查看$Proxy0中的hello方法，注：proxy参数是个形参，我认为无用，有知道的可以评论补充下。

注：$Proxy0中的静态代码块应一定阅读

代码：

这段代码是我们手动敲的代理代码（可直接复制到你的idea中），其中：

RealSubject：被代理类

Subject：被代理类实现的接口

DynamicProxy：代理类

InvocationHandler：jdk自带的动态代理类接口

DemoProxy：main方法所在的类

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

public class DemoProxy {

    public static void main(String[] args) {
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        Subject realiSubject = new RealSubject();
        InvocationHandler handler = new DynamicProxy(realiSubject);
        Subject subject = (Subject) Proxy.newProxyInstance(
                handler.getClass().getClassLoader(),
                realiSubject.getClass().getInterfaces(),
                handler);
        System.out.println(subject.getClass().getName());
        subject.hello("lilei");
        subject.hai();
    }

}

interface Subject {
    void hello (String str);

    void hai ();
}

class RealSubject implements Subject {

    @Override
    public void hello(String str) {
        System.out.println("hello " + str);
    }

    @Override
    public void hai() {
        System.out.println("hai");
    }
}

class DynamicProxy implements InvocationHandler {

    private Object subject;

    public DynamicProxy (Object obj) {
        subject = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before hello ...");
        System.out.println("Method: " + method + "" + method.getDeclaringClass().getName());

        method.invoke(subject, args);
//        Subject subj = (Subject)subject;
//        subj.hello(args == null ? "" : (String)args[0]);
        System.out.println("after hello ...");
        return null;
    }
}

 下边的这个代码是上边的代码生成的动态代理类，在Proxy.newProxyInstance这行代码执行完后生成的。将生成的动态代理类展示（就这个意思）出来的代码是这行：（我用的jdk8）

System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

这段代码没必要赋值，你执行成功上边的代码，这段代码就会自动生成了

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

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

    public $Proxy0(InvocationHandler var1) throws  {
        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);
        }
    }

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

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

    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");
            m4 = Class.forName("com.mashibing.nw.dongtaidaili.Subject").getMethod("hai");
            m3 = Class.forName("com.mashibing.nw.dongtaidaili.Subject").getMethod("hello", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

简单提醒：

idea在debug模式下会每走一步就调用一下toString方法（为啥调用不清楚，清楚的大佬评论补充下），所以故而导致我们的invoke方法会被多次执行

在run模式下就没有这些问题