引子

/**
     * 获得动态代理
     * 
     * @return
     */
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
                realInstance.getClass().getClassLoader(),
                realInstance.getClass().getInterfaces(),
                this);
        //那么这个对象到底是如何创建出来的呢？
        
    }

只是一句话而已，就能得到一个接口的动态代理。但是一直没有时间将原理探索过程写下来。今天得空，来填了这个坑。静态动态代理的写法我就不展开说了，今天只探究Proxy的实现原理.

正文

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

/**
 * 动态代理对象
 * 
 * 所谓，动态代理，它的优势，就是我使用之后，获取代理对象，不再依赖外部传入的接口，外部接口变化，我只需要改变真实对象的实例即可。
 * 
 * @author GC-HANK
 *
 */
public class DynamicProxyInstance implements InvocationHandler {

    // 动态代理，这里不限制具体使用的接口是什么，而是使用Object表示真实对象
    private Object realInstance;

    public void init(Object realInstance) {
        this.realInstance = realInstance;
    }

    /**
     * 获得动态代理
     * 
     * @return
     */
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(realInstance.getClass().getClassLoader(), realInstance.getClass().getInterfaces(),
                this);
        // 那么这个对象到底是如何创建出来的呢？

    }

    /**
     * 售前
     */
    private void doBefore() {
        System.out.println("售前");
    }

    /**
     * 售后
     */
    private void doAfter() {
        System.out.println("售后");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        doBefore();
        Object res = method.invoke(realInstance, args);
        doAfter();
        return res;
    }

    public static void main(String[] args) {

        // 动态代理和静态代理的唯一区别，就是在获取代理对象的时候，静态代理获取的是一个不可变功能的对象，一旦获取到，那么它的功能也就确定了
        // 而，动态代理，

        DynamicProxyInstance instance = new DynamicProxyInstance();
        instance.init(new RealInstance());
        CommInterface commInterface = (CommInterface) instance.getProxyInstance();
        // 先看看这个对象在debug的时候，是怎么样的一个对象引用
        commInterface.buyManTools(30);

        // 现在，出现了一个 购买女性用品的接口，和它的实现类，也要用代理来访问
        // 这样做
        instance.init(new RealInstance2());
        CommInterface2 commInterface2 = (CommInterface2) instance.getProxyInstance();
        commInterface2.buyWomenTools(60);

        // 看到了吧，同样的一个代理对象，可以实现多个真实对象的代理功能，而不是像静态代理一样，需要改动代理类
    }
}

其他关联的类和接口是:

/**
 * 公共接口，统一定义代理类和被代理类的行为
 * 
 * @author GC-HANK
 *
 */
public interface CommInterface {
    /**
     * 购买情趣娃娃
     * 
     * @param size 娃娃的尺寸
     */
    abstract void buyManTools(int size);
}

/**
 * 公共接口，统一定义代理类和被代理类的行为
 * 
 * @author GC-HANK
 *
 */
public interface CommInterface2 {
    /**
     * 购买情趣娃娃
     * 
     * @param size 娃娃的尺寸
     */
    abstract void buyWomenTools(int size);
}

/**
 * 真实对象
 * 
 * @author GC-HANK
 *
 */
public class RealInstance implements CommInterface {

    @Override
    public void buyManTools(int size) {
        System.out.println("购买男性用品:size" + size);
    }

}

/**
 * 真实对象
 * 
 * @author GC-HANK
 *
 */
public class RealInstance2 implements CommInterface2 {

    @Override
    public void buyWomenTools(int size) {
        System.out.println("购买女性用品::size" + size);
    }

}

OK,代码贴完了，现在开始实例讲解：

public Object getProxyInstance() {
        return Proxy.newProxyInstance(realInstance.getClass().getClassLoader(), realInstance.getClass().getInterfaces(),
                this);
        // 那么这个对象到底是如何创建出来的呢？

    }

而，拿到这个对象之后，强转为了CommInterface

// 先看看这个对象在debug的时候，是怎么样的一个对象引用
CommInterface commInterface = (CommInterface) instance.getProxyInstance();
commInterface.buyManTools(30);

为什么它可以强转为 CommInterface?因为instance.init(new RealInstance()); 这一句当中，RealInstance是CommIntance的子类。从结果上来看，通过getInstance方法拿到的Object，直接就具备realInstance的功能. 那这个Object到底是什么东西？它是如何生成的？

回到getInstance()方法，通过debug，我们发现，

它是一个名为$Proxy0的类的实例，其真实类型是RealInstance . $Proxy0名字很诡异，但是先别想这么多，继续往下看，

从0到1，看上去像是有一个整形序列在参与它的命名，也就是说，如果我们再来一次，肯定就是 $Proxy2。
那$Proxy + 1个数字，这个类是如何生成的？在我们的代码里面命名没有去定义它啊？
进入源码：proxy.java的 newProxyInstance方法

newProxyInstance方法往下看：结果发现：

通过K和P，得到V，也就是通过 ClassLoader和Class<?>[] 得到 Class<?> ,
有些人看到这里应该有些迷了，感觉被泛型绕晕了，其实很简单，ClassLoader是类加载器，用来创建Class对象的，Class<?>[] 其实就是接口数组，Class<?> 是最终得到的Class对象。
之前我们探索的就是$Proxy1这个类的来源，那么到底是不是来自于这里呢？
当我们探究源码中的一个 方法的时候,关注3个点：

它走的是这个过程：

返回出去之后，

上面这段代码的红色标记如果看懂了的话，就基本明白了，他这里就是建了一个无限循环检测机制，最终结果都是要从supplier中get一个value返回出去，如果supplier是空，那就建一个Factory赋值给supplier(其实Factory是继承子Supplier的)
那么下一步，我们的关注点转移到，当supplier为空的时候，源码是如何建立一个Factory作为它的实例的？
关注这一段：

这段代码太复杂，我就只贴出关键点了（依然和之前一样，入参，使用入参的地方，返回值）：
这次我们从返回值开始反过来推断：

源码直接返回了一个defineClass0(.....), 点进去一看，居然是一个native方法，那么探索只能到头了，当然，从结果上来看，它是生成了一个像这样$Proxy0 的 Class代理对象，那么代理class对象的特征，就只能从参数值来判断了，一个一个参数看:

上面说的 proxyClassNamePrefix，其实就是

而这个num，它只是一个全局的计数器而已，让程序直到下一个代理类对象应该以什么数字命名.

而上面的字节数组byte[] proxyClassFile 其实就是定义了这个代理类的行为，它应该能包含怎么样的方法，这些方法就是当初传进来的interfaces决定的。

OK，探究完了，代理类的生成已经查完了，那么回到起点：

那么它是如何发挥作用的呢？（下面的东西我就不细写过程了，直接给结论）