JDK动态代理原理

静态代理

生活中代理的例子不胜枚举：
张三由于工作很忙，迟迟没有结婚，家里人很着急。他爸爸拿着他的照片帮他张罗着相亲，他爸爸就是他的一个代理。
- 定义接口

public interface People {
    /**
     * 找对象
     */
    public void Zhaoduixiang();
}

• 张三

public class ZhangSan implements People{
    public void Zhaoduixiang() {
        System.out.println(this.getClass().getName()+":要求不多,人美胸大活好!");
    }
}

• 张三他爸

public class ZhangSanFather implements People{
    /**
     * 被代理对象的引用,相当于他爸拿着张三的照片
     */
    private ZhangSan zhangSan;

    public ZhangSanFather(){

    }
    public ZhangSanFather(ZhangSan zhangSan){
        this.zhangSan = zhangSan;
    }

    /**
     * 代理
     */
    public void Zhaoduixiang() {
        before();
        this.zhangSan.Zhaoduixiang();
        after();
    }

    /**
     *  想跟我儿子好,我先要审核下
     */
    private void before(){
        System.out.println(this.getClass().getName()+":要求人品好,家境好!");
    }

    /**
     * 评价这个菇凉
     */
    private void after(){
        System.out.println(this.getClass().getName()+":这个菇凉阔以!");
    }
}

• 测试

    @Test
    public void testStaticProxy(){
        People zhangSanFather = new ZhangSanFather(new ZhangSan());
        zhangSanFather.Zhaoduixiang();
    }

proxy.staticProxy.ZhangSanFather:要求人品好,家境好!
proxy.staticProxy.ZhangSan:要求不多,人美胸大活好!
proxy.staticProxy.ZhangSanFather:这个菇凉阔以!

重要特点：
- 代理类持有被代理类的引用

动态代理

张三没结婚，请个保姆做饭，洗碗，张三自己只用张嘴吃饭就行。保姆就是张三的代理。
- 接口

public interface People {
    /**
     * 吃东西
     */
    void eat(String food) throws Throwable;
}

• 张三

public class ZhangSan implements  People{
    /**
     * 吃
     * @param food 食物
     */
    public void eat(String food) {
        System.out.println(this.getClass().getName()+":吃"+food+"!");
    }
}

• 代理

public class ProxyHandler implements InvocationHandler{
    /**
     * 被代理对象的引用
     */
    private People people;

    public ProxyHandler(People people){
       this.people = people;
    }

    /**
     * 代理方法
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        method.invoke(people,args);
        after();
        return null;
    }

    /**
     * 执行在代理方法之前
     */
    private void before(){
        System.out.println(this.getClass().getName()+":做饭!");
    }

    /**
     * 执行在代理方法之后
     */
    private void after(){
        System.out.println(this.getClass().getName()+":洗碗!");
    }
}

• 测试

    @Test
    public void testJDKDynamicProxy() throws Throwable {
        //创建代理
        People people = (People) Proxy.newProxyInstance(
                People.class.getClassLoader(),
                new Class[]{People.class},
                new ProxyHandler(new ZhangSan()));
        System.out.println(people.getClass().getName());
        //执行操作
        people.eat("炸鸡,喝啤酒!");
    }

com.sun.proxy.$Proxy0
proxy.dynamicProxy.ProxyHandler:做饭!
proxy.dynamicProxy.ZhangSan:吃炸鸡,喝啤酒!!
proxy.dynamicProxy.ProxyHandler:洗碗!

到这里，效果虽然看到了，但是为什么要使用动态代理呢？

保姆给张三做饭、洗碗，大多时候不会像张三他爸那样长期固定，可能会因各种原因辞职，而重新帮另外的人做饭、洗碗。她代理的具体事情没有变化，变化的只是被代理的对象，如果使用静态代理，那么每次都要重新定义代理（不符合开闭原则），或者新增代理（代码冗余，不宜维护）。

那么jdk动态代理又是如何工作的呢？

前面代码中

System.out.println(people.getClass().getName());

打印的结果是

com.sun.proxy.$Proxy0

• 这就是jdk动态生成的，处于内存中的代理。还是一头雾水，必须要看看他具体的内容是什么

/**
     * 生成代理的Class文件
     */
    public static void createProxyClassFile(){
        //生成代理类的字节流
        byte[] $Proxy0s = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{People.class});
        //生成文件
        try {
            FileOutputStream fout = new FileOutputStream("src/main/java/proxy/dynamicProxy/$Proxy0.class");
            fout.write($Proxy0s);
            fout.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

• 重新运行程序，生成代理文件

@Test
    public void testJDKDynamicProxy() throws Throwable {
        //创建代理
        People people = (People) Proxy.newProxyInstance(
                People.class.getClassLoader(),
                new Class[]{People.class},
                new ProxyHandler(new ZhangSan()));
        System.out.println(people.getClass().getName());
        //执行操作
        people.eat("炸鸡,喝啤酒!");
        createProxyClassFile();
    }

如上图，这个$Proxy0.class就是jdk动态生成的，反编译打开该文件，真相就在里面！

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

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

    public final boolean equals(Object var1) throws  {
       ...
    }

    public final int hashCode() throws  {
       ...
    }

    public final void eat(String var1) throws Throwable {
        super.h.invoke(this, m3, new Object[]{var1});
    }

    public final String toString() throws  {
        ...
    }

    static {
        try {
            ...
            m3 = Class.forName("proxy.dynamicProxy.People").getMethod("eat", new Class[]{Class.forName("java.lang.String")});
            ...
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

从源码可以看出$Proxy0的真实身份：
1、它实际上实现了People接口，所以可以具体实现eat(String var1)方法。
2、而且它继承了Proxy类，在jdk源码中可以看到它有一个成员变量InvocationHandler，是不是很眼熟，这就是我们自定义代码ProxyHandler实现的接口。

public class Proxy implements java.io.Serializable{
    ...
    protected InvocationHandler h;
    ...
}

3、这里逻辑就很清晰了，eat(String var1)的具体实现就是调用InvocationHandler接口的invoke方法，并把真实的eat方法反射生成通过参数传入invoke方法，所以我们才能在ProxyHandler中调用method.invoke(people,args)，从而实现动态代理。

动态代理完美的诠释的开闭原则，即对扩展开放，对修改关闭。非常适用于程序扩展，非常非常重要，在各种框架中广泛应用，如大名鼎鼎的SpirngAOP。