细读Spring源码（三）---深度剖析动态代理底层原理

往期回顾：

• 细读Spring源码（一）---refresh()方法概览

• 细读Spring源码（二）---关于Spring中用到的设计模式

动态代理传送门（两篇比较好的文章，搬运过来）：

Java 动态代理作用是什么?

java动态代理实现与原理详细分析

上一篇文章梳理了Spring中用到的设计模式，其中就用代码演示了JDK和CGLIB两种动态代理的实现方式，本文会稍微跟一下这两种代理的源代码，为后面的AOP做准备。在介绍这两种代理之前先看一下下面这段代码：

public class ShowReflect {

    public static void main(String[] args) {
        Face faceInstance = getFaceInstance();
        faceInstance.setEye("hello");
        faceInstance.setSize(1);
        System.out.println(faceInstance);
    }

    public static Face getFaceInstance() {
        Class<Face> faceClass = Face.class;
        Constructor<?>[] constructors = faceClass.getConstructors();
        Face face = null;
        for (Constructor con : constructors) {
            Parameter[] parameters = con.getParameters();
            if (parameters == null || parameters.length == 0) {
                try {
                    face = (Face) con.newInstance();
                } catch (InstantiationException e) {
                    e.printStackTrace();
                    System.out.println(e);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                    System.out.println(e);
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                    System.out.println(e);
                }
            }
        }
        return face;
    }
}

猜猜最后会打印什么呢？没错，是Face{eye='hello',size='1'}，其实getFaceIntance()方法的效果就等同于Face face = new Face();，下面来看下解析：

上面的例子其实就是通过反射的方式创建了一个Face类的实例，然后就可以对它进行各种操作了，为什么要先提反射呢？因为它是动态代理的底层实现原理，不管是JDK动态代理，还是CGLIB动态代理，在动态创建代理对象的过程中，都是通过反射机制实现。

上一篇文章已经通过两个demo实现了，下面来看看这两种实现方式的底层源码：

一、JDK动态代理

下面是创建代理对象的过程

Class[] interfaces = {UserService.class};
UserService userService = (UserService) Proxy.newProxyInstance(UserJdkProxy.class.getClassLoader(), interfaces, new UserJdkProxy(new UserServiceImpl()));

从上面第2行代码看出，jdk通过Proxy类的静态方法newProxyInstance创建了一个代理对象newProxyInstance一探究竟

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
        Objects.requireNonNull(h);
        //1.克隆一个目标接口的Class对象，该接口就是被代理对象的接口
        final Class<?>[] intfs = interfaces.clone();
        //2.检查并设置目标接口Class对象intfs的访问权限
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        /*
         * Look up or generate the designated proxy class.
         * 3.获取一个代理类Class对象，这个代理类就是要动态创建的目标，返回的是一个名称为com.sun.proxy.$Proxy0的Class对象
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         * 4.用给定的invocation handler回调它的构造器
         */
        try {
            //4.1 检查并设置代理类的Class对象cl的访问权限
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //4.2 获取代理类的构造器
            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;
                    }
                });
            }
            //4.2 通过构造器创建一个实例
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException | InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

这一切的一切就是创建一个代理对象的底层实现原理，其步骤总结下来就是：

1、克隆目标接口的Class对象intfs

2、以目标接口的Class对象intfs为参数获取代理类的Class对象cl（备注：这里要这样实现，我想是因为代理类中维护了被代理的目标对象，所以需要在其Class对象中定义这个字段，这个过程可以理解为动态地生成一个Class对象）

3、通过代理类的Class对象cl得到其构造器

4、通过构造器创建实例

上面的第三步和第四步有没有觉得眼熟呢？没错，它就是反射！

奔着既知其一又知其二的心态，接下来，我们逐步跟进，看一下上面的第14行，也就是第三步获取代理类的Class对象方法如下：

/**
     * Generate a proxy class.  Must call the checkProxyAccess method
     * to perform permission checks before calling this.
     * 生成一个代理类。在调用该方法之前，必须调用checkProxyAccess方法执行权限检查
     */
    private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        // If the proxy class defined by the given loader implementing the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        //如果一个代理类已经被实现了给定接口的给定类加载器所定义，那么久直接返回该缓存的副本，否则将会通过代理类工厂ProxyClassFactory创建一个代理对象
        return proxyClassCache.get(loader, interfaces);
    }

这个方法有趣的一点是，方法名上居然有个数字0，我们知道0在计算机中就是第一个的意思，再看源码注释第10行，说如果一个代理类已经存在，则返回其缓存，否则创建一个新的，我想这就能解释为什么方法名中要带0了吧，即永远取已经存在的，也就是第一个了。

下面继续跟踪第13行，因为调用链比较长，我摘出了下面这段精髓代码，来一睹代理类的Class对象创建诞生过程：

首先，会在Proxy的ProxyClassFactory方法中调用proxyClassCache.get方法

然后，在WeakCache类的get方法中调用subKeyFactory.apply(key, parameter)，其中的subKeyFactory是一个类型为BiFunction的接口，该接口有一个实现类ProxyClassFactory，是Proxy的一个静态内部类

接着，在ProxyClassFactory中实现apply接口，其实get方法中最后调用的还是ProxyClassFactory.apply()方法

下面来看下这个神奇的匿名内部的源代码：

/**
     * A factory function that generates, defines and returns the proxy class given
     * the ClassLoader and array of interfaces.
     * 这是Proxy的一个静态内部类，它是一个工厂，具备这些功能：生成、定义和返回给定类加载器和一组接口对应代理类
     */
    private static final class ProxyClassFactory
            implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
        // prefix for all proxy class names
        //代理类的名称的前缀
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names
        //生成下一个唯一代理类名称的数字
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 * 验证类加载器解析的与这个接口同名的Class对象：其实就是再校验被代理接口是否是该类加载器所加载的
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                            intf + " is not visible from class loader");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 * 验证Class对象的确是一个接口，这就是为什么jdk动态代理需要实现接口的原因！！！
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                            interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
                 * //验证这个接口不是重复的
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                            "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             * 定义一个包名，如果被代理类的接口是非公开的，则所有代理类都会生成到这个包下：反正这里就是生成一个存放含有非公开方法的代理类Class文件的包
             */
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                //如果要代理的类中不包含非公开方法，则使用com.sun.proxy作为代理类的包名
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * Choose a name for the proxy class to generate.
             * 为代理类Class生成一个名称：包名+$Proxy+数字（自动增长）
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * Generate the specified proxy class.
             * 生成指定的代理类：一个自己数组
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
            try {
                //通过生成的字节数组定义一个Class对象：最后会在com.sun.proxy包下生成一个名为$Proxy+num的Class文件，如：com.sun.proxy.$Proxy0.class
                return defineClass0(loader, proxyName,
                        proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

 看了源代码，才知道通常所说的$Proxy0是这样来的，这个类其实就是一个工厂，它会定义并生成一个代理类的Class对象，生成过程会根据被代理接口中的方法是否是public，来确定包名，还会通过$Proxy+数字的形式给代理类命名。下面根据第96行，来看看这个代理类是怎么生成的？

/**
     * Generate a proxy class given a name and a list of proxy interfaces.
     * 根据给定的名称和一组代理接口生成一个代理类
     *
     * @param name        the class name of the proxy class  代理类的名称
     * @param interfaces  proxy interfaces 代理接口
     * @param accessFlags access flags of the proxy class 代理类的访问标识
     */
    public static byte[] generateProxyClass(final String name, Class<?>[] interfaces, int accessFlags) {
        //1、创建一个代理生成器对象实例gen
        ProxyGenerator gen = new ProxyGenerator(name, interfaces, accessFlags);
        /*2、调用实例gen的generateClassFile方法生成Class字节码数组，该方法内完成了如下事件：
           第一步：添加hashCode、equals、toString等方法
           第二步：添加代理接口中的方法，按照接口的顺序，先添加的接口优先
           第三步：验证代理方法的返回类型
           第四步：为该类中所有属性和方法转配FiledInfo和MethodInfo的结构体
           第五步：开始写入DataOutputStream，即构建一个class对象
           第六步：返回字节数组
          */
        final byte[] classFile = gen.generateClassFile();
        //3、如果需要保存该文件，则在指定路径下生成.class的文件
        if (saveGeneratedFiles) {
            java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedAction<Void>() {
                        public Void run() {
                            try {
                                int i = name.lastIndexOf('.');
                                Path path;
                                if (i > 0) {
                                    Path dir = Paths.get(name.substring(0, i).replace('.', File.separatorChar));
                                    Files.createDirectories(dir);
                                    path = dir.resolve(name.substring(i + 1, name.length()) + ".class");
                                } else {
                                    path = Paths.get(name + ".class");
                                }
                                Files.write(path, classFile);
                                return null;
                            } catch (IOException e) {
                                throw new InternalError(
                                        "I/O exception saving generated file: " + e);
                            }
                        }
                    });
        }
        //4、返回字节数组
        return classFile;
    }

上面代码中我都添加了注释，其实核心的代码还不在这里，而是第20行，返回一个final修饰的字节数组，它里面的主要步骤我已经添加到注释中，为了一探究竟，我还是决定把它的代码附上，保证看到它的你会直呼牛逼！！！

/**
     * Generate a class file for the proxy class.  This method drives the
     * class file generation process.
     * 为代理对象生成一个class文件，这个方法会驱动class文件生成程序
     */
    private byte[] generateClassFile() {

        /* ============================================================
         * Step 1: Assemble ProxyMethod objects for all methods to
         * generate proxy dispatching code for.
         */

        /*
         * Record that proxy methods are needed for the hashCode, equals,
         * and toString methods of java.lang.Object.  This is done before
         * the methods from the proxy interfaces so that the methods from
         * java.lang.Object take precedence over duplicate methods in the
         * proxy interfaces.
         */
        //第一步：添加hashCode、equals、toString等方法
        //第二步：添加代理接口中的方法，按照接口的顺序，先添加的接口优先
        //第三步：验证代理方法的返回类型
        //第四步：为该类中所有属性和方法转配FiledInfo和MethodInfo的结构体
        //第五步：开始写入DataOutputStream，即构建一个class对象
        //第六步：返回字节数组
        addProxyMethod(hashCodeMethod, Object.class);
        addProxyMethod(equalsMethod, Object.class);
        addProxyMethod(toStringMethod, Object.class);

        /*
         * Now record all of the methods from the proxy interfaces, giving
         * earlier interfaces precedence over later ones with duplicate
         * methods.
         */
        //第二步：添加代理接口中的方法，按照接口的顺序，先添加的接口优先
        // 这里其实就是将所有被代理接口中的方法都封装成一个ProxyMethod对象，该对象中定义了方法名、参数类型、返回类型、异常类型、方法来源、方法中的局部变量名等
        for (Class<?> intf : interfaces) {
            for (Method m : intf.getMethods()) {
                addProxyMethod(m, intf);
            }
        }

        /*
         * For each set of proxy methods with the same signature,
         * verify that the methods' return types are compatible.
         */
        //第三步：验证每一个方法中的返回类型
        for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
            checkReturnTypes(sigmethods);
        }

        /* ============================================================
         * Step 2: Assemble FieldInfo and MethodInfo structs for all of
         * fields and methods in the class we are generating.
         */
        //第四步：为该类中所有属性和方法转配FiledInfo和MethodInfo的结构体
        //这里会解析每一个代理方法生成的ProxyMethods对象，最后生成两个集合分别存放方法和参数
        try {
            methods.add(generateConstructor());

            for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
                for (ProxyMethod pm : sigmethods) {

                    // add static field for method's Method object
                    fields.add(new FieldInfo(pm.methodFieldName,
                            "Ljava/lang/reflect/Method;",
                            ACC_PRIVATE | ACC_STATIC));

                    // generate code for proxy method and add it
                    methods.add(pm.generateMethod());
                }
            }

            methods.add(generateStaticInitializer());

        } catch (IOException e) {
            throw new InternalError("unexpected I/O Exception", e);
        }

        if (methods.size() > 65535) {
            throw new IllegalArgumentException("method limit exceeded");
        }
        if (fields.size() > 65535) {
            throw new IllegalArgumentException("field limit exceeded");
        }

        /* ============================================================
         * Step 3: Write the final class file.
         */

        /*
         * Make sure that constant pool indexes are reserved for the
         * following items before starting to write the final class file.
         */
        //第五步：确保在开始往final类型的Class文件中写之前，className、父类className和接口等有足够的常量池
        cp.getClass(dotToSlash(className));
        cp.getClass(superclassName);
        for (Class<?> intf : interfaces) {
            cp.getClass(dotToSlash(intf.getName()));
        }

        /*
         * Disallow new constant pool additions beyond this point, since
         * we are about to write the final constant pool table.
         */
        cp.setReadOnly();

        //第五步：开始写入DataOutputStream，即构建一个class对象
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        DataOutputStream dout = new DataOutputStream(bout);

        try {
            /*
             * Write all the items of the "ClassFile" structure.
             * See JVMS section 4.1.
             * 核心：0xCAFEBABE是不是很熟？没错，这就是动态生成一个class对象
             */
            // u4 magic;
            dout.writeInt(0xCAFEBABE);
            // u2 minor_version;
            dout.writeShort(CLASSFILE_MINOR_VERSION);
            // u2 major_version;
            dout.writeShort(CLASSFILE_MAJOR_VERSION);

            cp.write(dout);             // (write constant pool)

            // u2 access_flags;
            dout.writeShort(accessFlags);
            // u2 this_class;
            dout.writeShort(cp.getClass(dotToSlash(className)));
            // u2 super_class;
            dout.writeShort(cp.getClass(superclassName));

            // u2 interfaces_count;
            dout.writeShort(interfaces.length);
            // u2 interfaces[interfaces_count];
            for (Class<?> intf : interfaces) {
                dout.writeShort(cp.getClass(
                        dotToSlash(intf.getName())));
            }

            // u2 fields_count;
            dout.writeShort(fields.size());
            // field_info fields[fields_count];
            for (FieldInfo f : fields) {
                f.write(dout);
            }

            // u2 methods_count;
            dout.writeShort(methods.size());
            // method_info methods[methods_count];
            for (MethodInfo m : methods) {
                m.write(dout);
            }

            // u2 attributes_count;
            dout.writeShort(0); // (no ClassFile attributes for proxy classes)

        } catch (IOException e) {
            throw new InternalError("unexpected I/O Exception", e);
        }
        //第六步：返回字节数组
        return bout.toByteArray();
    }

上面的第26、27、28、39行的addProxyMethod方方法就是将一个方法封装成一个ProxyMethod的对象，这就体现了Java中一切皆对象的宗旨，这些还不够，再看第65~74行，由将ProxyMethod中的方法定义和方法参数定义封装成MthodInfo和FidleInfo对象，看到这里才能领悟到什么叫“一切皆对象”了。再来看119~157行代码，看到这里是不是满脸震惊，没错我也是！这是啥？这是在动态地生成字节码呀！看到魔数0xCAFEBABE就真相大白了，jdk动态代理的灵魂就是动态地生成一个class文件，该文件中包含了对被代理对象中方法的调用，这才是java的精髓所在啊！！！

至此，jdk动态代理的源码就跟完了，下面总结一下吧：

1、jdk动态代理是基于接口的代理，被代理的必须是个接口或实现了某个接口，因为底层会判断目标对象是否是接口类型

2、通过克隆的方式得到目标接口的class对象

3、通过动态生成字节码文件的方式生成代理对象的Class对象

4、通过反射获取代理对象的构造器，并通过构造器生成代理对象的实例

二、CGLIB动态代理

CGLIB是为一个类进行代理的，那么先看下它是如何生成一个代理类的，下面代码是创建一个代理类：

 public T getProxy(Class<T> targetClass) {
        Enhancer enhancer = new Enhancer();
        return (T) enhancer.create(targetClass, this);
    }

下面照例一步一步跟进，先跟new Enhancer()方法：

/**
     * Create a new <code>Enhancer</code>. A new <code>Enhancer</code>
     * object should be used for each generated object, and should not
     * be shared across threads. To create additional instances of a
     * generated class, use the <code>Factory</code> interface.
     * 该方法用来创建一个Enhancer。必须保证每次生成对象时都会创建一个新的Enhancer，而且它不能被多个线程共享
     * 如果要创建一个额外的生成实例，需要使用Factory接口
     * @see Factory
     */
    public Enhancer() {
        super(SOURCE);
    }

这个构造函数中调用了父类AbstractClassGenerator的构造函数，创建了一个Source对象，AbstractClassGenerator顾名思义就是抽象类生成器。下面再看下一步，enhancer.create(targetClass, this);

/**
     * Generate a new class if necessary and uses the specified
     * callbacks (if any) to create a new object instance.
     * Uses the no-arg constructor of the superclass.
     * 如果必要的话生成一个新的class，并使用指定的回调函数（如果存在）创建一个新的实例，使用父类的无参构造函数
     * @return a new instance
     */
    public Object create() {
        classOnly = false;
        argumentTypes = null;
        return createHelper();
    }

主要来看第11行中的createHelper方法：

private Object createHelper() {
        //预检查：如果没有指定过滤器，且回调对象有多个，就抛异常
        preValidate();
        //生成一个key对象
        Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                ReflectUtils.getNames(interfaces),
                filter == ALL_ZERO ? null : new WeakCacheKey<CallbackFilter>(filter),
                callbackTypes,
                useFactory,
                interceptDuringConstruction,
                serialVersionUID);
        this.currentKey = key;
        //调用父类的创建create方法，根据key创建代理类
        Object result = super.create(key);
        return result;
    }

通过debug发现，上面的测试代码会生成下面这样一串key：

 里面最主要的就是被代理的类和当前代理类的类型，即MethodInterceptor接口

继续追踪super.create(key);这行代码的具体实现：

//定义一个volatile修饰的缓存变量CACHE
    private static volatile Map<ClassLoader, ClassLoaderData> CACHE = new WeakHashMap<ClassLoader, ClassLoaderData>();

    protected Object create(Object key) {
        try {
            //获取类加载器
            ClassLoader loader = getClassLoader();
            Map<ClassLoader, ClassLoaderData> cache = CACHE;
            //从缓存中获取类加载器的数据
            ClassLoaderData data = cache.get(loader);
            //如果类加载器不存在，则新创建
            if (data == null) {
                //看到没？基于双重检查机制的单例模式啊！！！！
                synchronized (AbstractClassGenerator.class) {
                    //注意注意：严谨的是这个地方又重新进行了一次set和get操作，保证CACHE没有被别的线程修改，这大概才是最好的Double Check吧！！！
                    cache = CACHE;
                    data = cache.get(loader);
                    //进行第二次检查
                    if (data == null) {
                        //当第二次检查还不存在的时候才创建新的类加载器
                        Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
                        //该方法中使类加载器指向一个弱引用WeakReference
                        data = new ClassLoaderData(loader);
                        newCache.put(loader, data);
                        CACHE = newCache;
                    }
                }
            }
            this.key = key;
            //判断是否开启缓存配置，即cglib.useCache=true
            //如果开启缓存，就从缓存中获取，如果没有开启，就直接生成并返回
            Object obj = data.get(this, getUseCache());
            //如果返回的是一个Class，则调用firstInstance
            if (obj instanceof Class) {
                //创建第一个实例：如果返回的是一个Class
                return firstInstance((Class) obj);
            }
            //否则调用nextInstance
            return nextInstance(obj);
        } catch (RuntimeException | Error ex) {
            throw ex;
        } catch (Exception ex) {
            throw new CodeGenerationException(ex);
        }
    }

这里12~28行获取类加载器数据的地方使用了一个经典的基于双重检查的单例模式！平复一下心情，继续看两个return后面的方法，第一个是第一次执行，第二个是非第一次执行：

protected Object firstInstance(Class type) throws Exception {
        //如果只是创建一个类，则直接返回
        if (classOnly) {
            return type;
        }
        else {
            //否则通过反射创建
            return createUsingReflection(type);
        }
    }

    //在实例已经存在的情况下创建
    protected Object nextInstance(Object instance) {
        EnhancerFactoryData data = (EnhancerFactoryData) instance;

        //同样，如果只是返回Class对象，则调用实例的generatedClass返回
        if (classOnly) {
            return data.generatedClass;
        }
        //否则创建新的实例
        Class[] argumentTypes = this.argumentTypes;
        Object[] arguments = this.arguments;
        if (argumentTypes == null) {
            argumentTypes = Constants.EMPTY_CLASS_ARRAY;
            arguments = null;
        }
        return data.newInstance(argumentTypes, arguments, callbacks);
    }

其实debug会发现，每次都会执行到nextInstance方法中，因为我们是要获取一个代理对象的实例，firstInstance中是通过反射实现，那么再看nextInstance方法中是怎么实现的呢？

public Object newInstance(Class[] argumentTypes, Object[] arguments, Callback[] callbacks) {
            setThreadCallbacks(callbacks);
            try {
                // Explicit reference equality is added here just in case Arrays.equals does not have one
                if (primaryConstructorArgTypes == argumentTypes ||
                        Arrays.equals(primaryConstructorArgTypes, argumentTypes)) {
                    // If we have relevant Constructor instance at hand, just call it
                    // This skips "get constructors" machinery
                    return ReflectUtils.newInstance(primaryConstructor, arguments);
                }
                // Take a slow path if observing unexpected argument types
                return ReflectUtils.newInstance(generatedClass, argumentTypes, arguments);
            }
            finally {
                // clear thread callbacks to allow them to be gc'd
                setThreadCallbacks(null);
            }

        }

 看到没，底层还是通过反射获取到构造函数，再通过构造函数的newInstance来创建对象的。

至此，两种动态代理的源码分析就差不多了，从JDK源码到Spring源码，总会看到很多有意思的写法和最佳实践，这大概就是看源码不觉得枯燥的地方了吧，哈哈~~下面还是来总结一下本章的内容：

1、JDK动态代理是基于接口的代理，是java语言的特性，代理类需要实现InvocationHandler接口，被代理的是一个接口

2、CGLIB动态代理是基于类的代理，是Spring与第三方整合实现，代理类需要实现MethodInterceptor接口，被代理的是一个类

3、代理对象的生成，底层都使用了反射方式，先获取构造函数，在通过构造函数创建实例

以上就是本章全部内容~~