package com.coderap.proxy.cglib;

import java.util.Random;

public class Bugatti {

    private String info;

    public Bugatti(String info) {
        this.info = info;
    }

    public void run() {
        System.out.println(this.info + " car running");
        try {
            Thread.sleep(new Random().nextInt(3000));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String getInfo() {
        return this.info;
    }
}

package com.coderap.proxy.cglib;

import java.util.Random;

public class Ferrari {

    private String info;

    public Ferrari(String info) {
        this.info = info;
    }

    public void run() {
        System.out.println(this.info + " car running");
        try {
            Thread.sleep(new Random().nextInt(3000));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String getInfo() {
        return this.info;
    }
}

package com.coderap.proxy.cglib;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class SpeedTestMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if (object != null) {
            if ("run".equals(method.getName())) {
                // 获取车型号
                String carInfo = "";
                if (object instanceof Bugatti) {
                    carInfo = ((Bugatti)object).getInfo();
                } else if (object instanceof Ferrari) {
                    carInfo = ((Ferrari)object).getInfo();
                }
                // 开始测速
                System.out.println("动态测速代理开始执行：" + carInfo + " " + method.getName());
                SpeedTestUtil.start();
                // 主要的执行方法
                Object result = methodProxy.invokeSuper(object, objects);
                SpeedTestUtil.finish(carInfo, method.getName());
                return result;
            } else {
                return methodProxy.invokeSuper(object, objects);
            }
        } else {
            throw new Throwable("Target Error, You need provide a Car to test");
        }
    }
}

package com.coderap.proxy.cglib;

public class SpeedTestUtil {

    // 存储启动时间
    private static ThreadLocal<Long> startTime = new ThreadLocal<Long>();

    public static void start() {
        // 记录启动时间
        startTime.set(System.currentTimeMillis());
    }

    public static void finish(String carName, String methodName) {
        // 获取结束时间
        long finishTime = System.currentTimeMillis();
        // 打印时间信息
        System.out.println(carName + " 执行" + methodName + "，耗时：" + (finishTime - startTime.get()) + " ms.\n");
    }
}

package com.coderap.proxy.cglib;

import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;

public class SpeedTest {

    public static void main(String[] args) {
        // 设置CGLib调试输出目录
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/LennonChin/Downloads/Google Driver/Blog/Test/CGLib/");

        // 测试Bugatti
        Enhancer bugattiEnhancer = new Enhancer();
        bugattiEnhancer.setSuperclass(Bugatti.class);
        bugattiEnhancer.setCallback(new SpeedTestMethodInterceptor());
        Bugatti bugatti = (Bugatti) bugattiEnhancer.create(new Class[]{String.class}, new Object[]{"Bugatti Chiron"});
        bugatti.run();

        // 测试Ferrari
        Enhancer ferrariEnhancer = new Enhancer();
        ferrariEnhancer.setSuperclass(Ferrari.class);
        ferrariEnhancer.setCallback(new SpeedTestMethodInterceptor());
        Ferrari ferrari = (Ferrari) ferrariEnhancer.create(new Class[]{String.class}, new Object[]{"Ferrari California T"});
        ferrari.run();

    }
}

CGLIB debugging enabled, writing to '/Users/LennonChin/Downloads/Google Driver/Blog/Test/CGLib/'
动态测速代理开始执行：Bugatti Chiron run
Bugatti Chiron car running
Bugatti Chiron 执行run，耗时：797 ms.

动态测速代理开始执行：Ferrari California T run
Ferrari California T car running
Ferrari California T 执行run，耗时：2347 ms.

public Object create(Class[] argumentTypes, Object[] arguments) {
    classOnly = false;
    // 检查传入的参数
    if (argumentTypes == null || arguments == null || argumentTypes.length != arguments.length) {
        throw new IllegalArgumentException("Arguments must be non-null and of equal length");
    }
    // 记录构造方法需要的参数类型
    this.argumentTypes = argumentTypes;
    // 记录传入的构造方法参数
    this.arguments = arguments;
    // 调用createHelper()方法进行创建
    return createHelper();
}

private Object createHelper() {
    validate();
    // 检查superClass和interfaces，并记录前缀，用于生成字节码文件
    if (superclass != null) {
        setNamePrefix(superclass.getName());
    } else if (interfaces != null) {
        setNamePrefix(interfaces[ReflectUtils.findPackageProtected(interfaces)].getName());
    }
    // 创建代理对象
    return super.create(KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                                                ReflectUtils.getNames(interfaces),
                                                filter,
                                                callbackTypes,
                                                useFactory,
                                                interceptDuringConstruction,
                                                serialVersionUID));

private static final EnhancerKey KEY_FACTORY = (EnhancerKey)KeyFactory.create(EnhancerKey.class);

public static KeyFactory create(Class keyInterface) {
    return create(keyInterface, null);
}

public static KeyFactory create(Class keyInterface, Customizer customizer) {
    return create(keyInterface.getClassLoader(), keyInterface,  customizer);
}

public static KeyFactory create(ClassLoader loader, Class keyInterface, Customizer customizer) {
    // KeyFactory生成器
    Generator gen = new Generator();
    gen.setInterface(keyInterface);
    gen.setCustomizer(customizer);
    gen.setClassLoader(loader);
    return gen.create();
}

public KeyFactory create() {
    // 设置名称前缀
    setNamePrefix(keyInterface.getName());
    // 使用父类方法创建KeyFactory
    return (KeyFactory)super.create(keyInterface.getName());
}

protected Object create(Object key) {
    try {
        Class gen = null;
        // 同步操作
        synchronized (source) {
            ClassLoader loader = getClassLoader();
            // 缓存
            Map cache2 = null;
            cache2 = (Map)source.cache.get(loader);
            if (cache2 == null) {
                // 如果缓存为空，就新创建一个HashMap对象
                cache2 = new HashMap();
                cache2.put(NAME_KEY, new HashSet());
                source.cache.put(loader, cache2);
            } else if (useCache) {
                /**
                 * 如果缓存不为空，且是使用缓存的，就从缓存中根据传入的参数key获取对应的Class对象
                 * 拿到的是引用WeakReference，调用ref.get()拿到类本身
                 * 并将其赋值给gen
                 */
                Reference ref = (Reference)cache2.get(key);
                gen = (Class) (( ref == null ) ? null : ref.get()); 
            }
            // 如果不能从缓存中查找到生成类
            if (gen == null) {
                Object save = CURRENT.get();
                CURRENT.set(this);
                try {
                    this.key = key;

                    if (attemptLoad) {
                        try {
                            /**
                             * 尝试使用类加载器通过全限定名进行加载
                             * 这里我们需要注意getClassName()方法的实现，该方法最终会根据namePrefix来返回
                             * 而namePrefix在前面Generator的create()方法中设置为EnhancerKey类的全限定名
                             */
                            gen = loader.loadClass(getClassName());
                        } catch (ClassNotFoundException e) {
                            // ignore
                        }
                    }
                    // 如果还是没有加载到
                    if (gen == null) {
                        /**
                         * 就使用strategy进行生成，strategy默认是一个DefaultGeneratorStrategy对象
                         * strategy的generate(ClassGenerator)方法调用了子类里的generateClass(ClassVisitor)方法
                         * 用于生成字节码，这部分代码会在后面讲解
                         * 这里需要记住的是，this此时是Generator实例
                         */
                        byte[] b = strategy.generate(this);
                        String className = ClassNameReader.getClassName(new ClassReader(b));
                        // 将className放入NAME_KEY对应的Set中
                        getClassNameCache(loader).add(className);
                        // 根据返回的字节码生成类
                        gen = ReflectUtils.defineClass(className, b, loader);
                    }
                    // 如果使用缓存，就将刚刚获取的类对象gen进行缓存
                    if (useCache) {
                        cache2.put(key, new WeakReference(gen));
                    }
                    // 调用firstInstance()方法，通过类对象创建实例
                    return firstInstance(gen);
                } finally {
                    CURRENT.set(save);
                }
            }
        }
        // 调用firstInstance()方法，通过类对象创建实例
        return firstInstance(gen);
    } catch (RuntimeException e) {
        throw e;
    } catch (Error e) {
        throw e;
    } catch (Exception e) {
        throw new CodeGenerationException(e);
    }
}

protected static class Source {
    String name;
    Map cache = new WeakHashMap();
    public Source(String name) {
        this.name = name;
    }
}

// Generator类中的代码
private static final Source SOURCE = new Source(KeyFactory.class.getName());

public Generator() {
    super(SOURCE);
}

// AbstractClassGenerator类中的代码
protected AbstractClassGenerator(Source source) {
    this.source = source;
}

final protected String getClassName() {
    if (className == null)
        className = getClassName(getClassLoader());
    return className;
}

private String getClassName(final ClassLoader loader) {
    // 先使用ClassLoader尝试从缓存中获取已生成的类的类名集合
    final Set nameCache = getClassNameCache(loader);
    /* 
     * 通过命名策略的getClassName()方法尝试从类名集合中查找存在的类名
     * 注意，此时namePrefix已被设置为了EnhancerKey类的全限定名，可以翻阅前面的代码
     * source.name也是EnhancerKey类的全限定名
     * key即是上面create(Object key)方法传入的参数key，也是EnhancerKey类的全限定名
     */
    return namingPolicy.getClassName(namePrefix, source.name, key, new Predicate() {
        public boolean evaluate(Object arg) {
            return nameCache.contains(arg);
        }
    });
}

// 从缓存中获取类名集合
private Set getClassNameCache(ClassLoader loader) {
    return (Set)((Map)source.cache.get(loader)).get(NAME_KEY);
}

public String getClassName(String prefix, String source, Object key, Predicate names) {
    if (prefix == null) {
        prefix = "net.sf.cglib.empty.Object";
    } else if (prefix.startsWith("java")) {
        prefix = "$" + prefix;
    }
    String base =
        prefix + "$$" + 
        source.substring(source.lastIndexOf('.') + 1) +
        getTag() + "$$" +
        Integer.toHexString(key.hashCode());
    String attempt = base;
    int index = 2;
    while (names.evaluate(attempt))
        attempt = base + "_" + index++;
    return attempt;
}

/**
 * Returns a string which is incorporated into every generated class name.
 * By default returns "ByCGLIB"
 */
protected String getTag() {
    return "ByCGLIB";
}

public byte[] generate(ClassGenerator cg) throws Exception {
    // 获取生产的类字节码文件输出器
    ClassWriter cw = getClassWriter();
    /**
     * 生产字节码文件并输出
     * 由于此处cg其实是传入的Generator实例，
     * 因此这里调用的是Generator的generateClass()方法
     */
    transform(cg).generateClass(cw);
    // 以byte数组的形式返回字节码文件内容
    return transform(cw.toByteArray());
}

protected ClassWriter getClassWriter() throws Exception {
    return new DebuggingClassWriter(ClassWriter.COMPUTE_MAXS);
}

protected byte[] transform(byte[] b) throws Exception {
    return b;
}

public void generateClass(ClassVisitor v) {
    ClassEmitter ce = new ClassEmitter(v);
    // 对定义key工厂类结构的接口进行判断，判断该接口是否只有newInstance一个方法，newInstance的返回值是否为Object
    Method newInstance = ReflectUtils.findNewInstance(keyInterface);
    if (!newInstance.getReturnType().equals(Object.class)) {
        throw new IllegalArgumentException("newInstance method must return Object");
    }

    // 获取newInstance的入参类型，此处使用ASM的Type来定义
    Type[] parameterTypes = TypeUtils.getTypes(newInstance.getParameterTypes());
    ce.begin_class(Constants.V1_2,
                   Constants.ACC_PUBLIC,
                   getClassName(),
                   KEY_FACTORY,
                   new Type[]{ Type.getType(keyInterface) },
                   Constants.SOURCE_FILE);
    // 生成默认构造函数
    EmitUtils.null_constructor(ce);

    // 生成newInstance工厂方法
    EmitUtils.factory_method(ce, ReflectUtils.getSignature(newInstance));

    // 生成有参构造方法
    int seed = 0;
    CodeEmitter e = ce.begin_method(Constants.ACC_PUBLIC,
                                    TypeUtils.parseConstructor(parameterTypes),
                                    null);
    e.load_this();
    e.super_invoke_constructor();
    e.load_this();
    for (int i = 0; i < parameterTypes.length; i++) {
        seed += parameterTypes[i].hashCode();
        // 为每一个入参生成一个相同类型的类字段
        ce.declare_field(Constants.ACC_PRIVATE | Constants.ACC_FINAL,
                         getFieldName(i),
                         parameterTypes[i],
                         null);
        e.dup();
        e.load_arg(i);
        e.putfield(getFieldName(i));
    }
    e.return_value();
    e.end_method();

    // 生成hashCode()方法
    e = ce.begin_method(Constants.ACC_PUBLIC, HASH_CODE, null);
    int hc = (constant != 0) ? constant : PRIMES[(int)(Math.abs(seed) % PRIMES.length)];
    int hm = (multiplier != 0) ? multiplier : PRIMES[(int)(Math.abs(seed * 13) % PRIMES.length)];
    e.push(hc);
    for (int i = 0; i < parameterTypes.length; i++) {
        e.load_this();
        e.getfield(getFieldName(i));
        EmitUtils.hash_code(e, parameterTypes[i], hm, customizer);
    }
    e.return_value();
    e.end_method();

    // 生成equals()方法，在equals()方法中对每个入参都进行判断
    e = ce.begin_method(Constants.ACC_PUBLIC, EQUALS, null);
    Label fail = e.make_label();
    e.load_arg(0);
    e.instance_of_this();
    e.if_jump(e.EQ, fail);
    for (int i = 0; i < parameterTypes.length; i++) {
        e.load_this();
        e.getfield(getFieldName(i));
        e.load_arg(0);
        e.checkcast_this();
        e.getfield(getFieldName(i));
        EmitUtils.not_equals(e, parameterTypes[i], fail, customizer);
    }
    e.push(1);
    e.return_value();
    e.mark(fail);
    e.push(0);
    e.return_value();
    e.end_method();

    // 生成toString()方法
    e = ce.begin_method(Constants.ACC_PUBLIC, TO_STRING, null);
    e.new_instance(Constants.TYPE_STRING_BUFFER);
    e.dup();
    e.invoke_constructor(Constants.TYPE_STRING_BUFFER);
    for (int i = 0; i < parameterTypes.length; i++) {
        if (i > 0) {
            e.push(", ");
            e.invoke_virtual(Constants.TYPE_STRING_BUFFER, APPEND_STRING);
        }
        e.load_this();
        e.getfield(getFieldName(i));
        EmitUtils.append_string(e, parameterTypes[i], EmitUtils.DEFAULT_DELIMITERS, customizer);
    }
    e.invoke_virtual(Constants.TYPE_STRING_BUFFER, TO_STRING);
    e.return_value();
    e.end_method();

    ce.end_class();
}

$> tree .
.
├── com
│   └── coderap
│       └── proxy
│           └── cglib
│               ├── Bugatti$$EnhancerByCGLIB$$4ddb6f26$$FastClassByCGLIB$$48029d80.class
│               ├── Bugatti$$EnhancerByCGLIB$$4ddb6f26.class
│               ├── Bugatti$$FastClassByCGLIB$$e6a580a8.class
│               ├── Ferrari$$EnhancerByCGLIB$$76b91705$$FastClassByCGLIB$$edb3e882.class
│               ├── Ferrari$$EnhancerByCGLIB$$76b91705.class
│               └── Ferrari$$FastClassByCGLIB$$9f935905.class
└── net
    └── sf
        └── cglib
            ├── core
            │   └── MethodWrapper$MethodWrapperKey$$KeyFactoryByCGLIB$$d45e49f7.class
            └── proxy
                └── Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72.class

9 directories, 8 files

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package net.sf.cglib.proxy;

import net.sf.cglib.core.KeyFactory;
import net.sf.cglib.proxy.Enhancer.EnhancerKey;
import org.objectweb.asm.Type;

public class Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72 extends KeyFactory implements EnhancerKey {
    private final String FIELD_0;
    private final String[] FIELD_1;
    private final CallbackFilter FIELD_2;
    private final Type[] FIELD_3;
    private final boolean FIELD_4;
    private final boolean FIELD_5;
    private final Long FIELD_6;

    public Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72() {
    }

    public Object newInstance(String var1, String[] var2, CallbackFilter var3, Type[] var4, boolean var5, boolean var6, Long var7) {
        return new Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72(var1, var2, var3, var4, var5, var6, var7);
    }

    public Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72(String var1, String[] var2, CallbackFilter var3, Type[] var4, boolean var5, boolean var6, Long var7) {
        this.FIELD_0 = var1;
        this.FIELD_1 = var2;
        this.FIELD_2 = var3;
        this.FIELD_3 = var4;
        this.FIELD_4 = var5;
        this.FIELD_5 = var6;
        this.FIELD_6 = var7;
    }

    public int hashCode() {
        int var10000 = 8095873 * 69403 + (this.FIELD_0 != null ? this.FIELD_0.hashCode() : 0);
        String[] var10001 = this.FIELD_1;
        if (this.FIELD_1 != null) {
            String[] var1 = var10001;

            for(int var2 = 0; var2 < var1.length; ++var2) {
                var10000 = var10000 * 69403 + (var1[var2] != null ? var1[var2].hashCode() : 0);
            }
        }

        var10000 = var10000 * 69403 + (this.FIELD_2 != null ? this.FIELD_2.hashCode() : 0);
        Type[] var5 = this.FIELD_3;
        if (this.FIELD_3 != null) {
            Type[] var3 = var5;

            for(int var4 = 0; var4 < var3.length; ++var4) {
                var10000 = var10000 * 69403 + (var3[var4] != null ? var3[var4].hashCode() : 0);
            }
        }

        return ((var10000 * 69403 + (this.FIELD_4 ^ 1)) * 69403 + (this.FIELD_5 ^ 1)) * 69403 + (this.FIELD_6 != null ? this.FIELD_6.hashCode() : 0);
    }

    public boolean equals(Object var1) {
        if (var1 instanceof Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72) {
            String var10000 = this.FIELD_0;
            String var10001 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_0;
            String var10002 = this.FIELD_0;
            if (((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_0 == null) {
                if (var10002 != null) {
                    return false;
                }
            } else if (var10002 == null || !var10000.equals(var10001)) {
                return false;
            }

            String[] var8 = this.FIELD_1;
            String[] var10 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_1;
            String[] var15 = this.FIELD_1;
            if (((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_1 == null) {
                if (var15 != null) {
                    return false;
                }
            } else {
                label178: {
                    if (var15 != null) {
                        if (var10.length == var8.length) {
                            String[] var2 = var10;
                            String[] var3 = var8;
                            int var4 = 0;

                            while(true) {
                                if (var4 >= var2.length) {
                                    break label178;
                                }

                                var10000 = var2[var4];
                                var10001 = var3[var4];
                                if (var3[var4] == null) {
                                    if (var10000 != null) {
                                        return false;
                                    }
                                } else if (var10000 == null || !var10000.equals(var10001)) {
                                    return false;
                                }

                                ++var4;
                            }
                        }
                    }

                    return false;
                }
            }

            CallbackFilter var9 = this.FIELD_2;
            CallbackFilter var13 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_2;
            CallbackFilter var17 = this.FIELD_2;
            if (((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_2 == null) {
                if (var17 != null) {
                    return false;
                }
            } else if (var17 == null || !var9.equals(var13)) {
                return false;
            }

            Type[] var11 = this.FIELD_3;
            Type[] var16 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_3;
            Type[] var19 = this.FIELD_3;
            if (((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_3 == null) {
                if (var19 != null) {
                    return false;
                }
            } else {
                if (var19 == null) {
                    return false;
                }

                if (var16.length != var11.length) {
                    return false;
                }

                Type[] var5 = var16;
                Type[] var6 = var11;

                for(int var7 = 0; var7 < var5.length; ++var7) {
                    Type var12 = var5[var7];
                    Type var18 = var6[var7];
                    if (var6[var7] == null) {
                        if (var12 != null) {
                            return false;
                        }
                    } else if (var12 == null || !var12.equals(var18)) {
                        return false;
                    }
                }
            }

            if (this.FIELD_4 == ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_4 && this.FIELD_5 == ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_5) {
                Long var14 = this.FIELD_6;
                Long var20 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_6;
                Long var21 = this.FIELD_6;
                if (((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_6 == null) {
                    if (var21 == null) {
                        return true;
                    }
                } else if (var21 != null && var14.equals(var20)) {
                    return true;
                }
            }
        }

        return false;
    }

    public String toString() {
        StringBuffer var10000 = new StringBuffer();
        var10000 = (this.FIELD_0 != null ? var10000.append(this.FIELD_0.toString()) : var10000.append("null")).append(", ");
        String[] var10001 = this.FIELD_1;
        if (this.FIELD_1 != null) {
            var10000 = var10000.append("{");
            String[] var1 = var10001;

            for(int var2 = 0; var2 < var1.length; ++var2) {
                var10000 = (var1[var2] != null ? var10000.append(var1[var2].toString()) : var10000.append("null")).append(", ");
            }

            var10000.setLength(var10000.length() - 2);
            var10000 = var10000.append("}");
        } else {
            var10000 = var10000.append("null");
        }

        var10000 = var10000.append(", ");
        var10000 = (this.FIELD_2 != null ? var10000.append(this.FIELD_2.toString()) : var10000.append("null")).append(", ");
        Type[] var7 = this.FIELD_3;
        if (this.FIELD_3 != null) {
            var10000 = var10000.append("{");
            Type[] var3 = var7;

            for(int var4 = 0; var4 < var3.length; ++var4) {
                var10000 = (var3[var4] != null ? var10000.append(var3[var4].toString()) : var10000.append("null")).append(", ");
            }

            var10000.setLength(var10000.length() - 2);
            var10000 = var10000.append("}");
        } else {
            var10000 = var10000.append("null");
        }

        var10000 = var10000.append(", ").append(this.FIELD_4).append(", ").append(this.FIELD_5).append(", ");
        return (this.FIELD_6 != null ? var10000.append(this.FIELD_6.toString()) : var10000.append("null")).toString();
    }
}

public Object newInstance(String var1, String[] var2, CallbackFilter var3, Type[] var4, boolean var5, boolean var6, Long var7) {
    return new Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72(var1, var2, var3, var4, var5, var6, var7);
}

byte[] b = strategy.generate(this);
String className = ClassNameReader.getClassName(new ClassReader(b));
// 将className放入NAME_KEY对应的Set中
getClassNameCache(loader).add(className);
// 根据返回的字节码生成类
gen = ReflectUtils.defineClass(className, b, loader);

public static Class defineClass(String className, byte[] b, ClassLoader loader) throws Exception {
    Object[] args = new Object[]{className, b, new Integer(0), new Integer(b.length), PROTECTION_DOMAIN };
    Class c = (Class)DEFINE_CLASS.invoke(loader, args);
    // Force static initializers to run.
    Class.forName(className, true, loader);
    return c;
}

// Generator类的firstInstance(Class)，调用了ReflectUtils类的newInstance(Class)方法
protected Object firstInstance(Class type) {
    return ReflectUtils.newInstance(type);
}

// ReflectUtils类newInstance(Class)的相关方法
public static Object newInstance(Class type) {
    return newInstance(type, Constants.EMPTY_CLASS_ARRAY, null);
}

public static Object newInstance(Class type, Class[] parameterTypes, Object[] args) {
    return newInstance(getConstructor(type, parameterTypes), args);
}

public static Object newInstance(final Constructor cstruct, final Object[] args) {

    boolean flag = cstruct.isAccessible();
    try {
        // 设置构造方法的可见性
        cstruct.setAccessible(true);
        // 根据构造方法创建对象
        Object result = cstruct.newInstance(args);
        return result;
    } catch (InstantiationException e) {
        throw new CodeGenerationException(e);
    } catch (IllegalAccessException e) {
        throw new CodeGenerationException(e);
    } catch (InvocationTargetException e) {
        throw new CodeGenerationException(e.getTargetException());
    } finally {
        cstruct.setAccessible(flag);
    }

}

private Object createHelper() {
    validate();
    if (superclass != null) {
        setNamePrefix(superclass.getName());
    } else if (interfaces != null) {
        setNamePrefix(interfaces[ReflectUtils.findPackageProtected(interfaces)].getName());
    }
    // 注意，此时superClass是我们想要得到的目标类
    return super.create(KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                                                ReflectUtils.getNames(interfaces),
                                                filter,
                                                callbackTypes,
                                                useFactory,
                                                interceptDuringConstruction,
                                                serialVersionUID));
}

public void generateClass(ClassVisitor v) throws Exception {
    // 获取superClass类，也即是我们指定的目标类，如果没有就使用Object作为superClass类
    Class sc = (superclass == null) ? Object.class : superclass;

    if (TypeUtils.isFinal(sc.getModifiers()))
        throw new IllegalArgumentException("Cannot subclass final class " + sc);

    // 构造方法相关
    List constructors = new ArrayList(Arrays.asList(sc.getDeclaredConstructors()));
    filterConstructors(sc, constructors);

    // Order is very important: must add superclass, then
    // its superclass chain, then each interface and
    // its superinterfaces.
    // 普通方法相关
    List actualMethods = new ArrayList();
    List interfaceMethods = new ArrayList();
    final Set forcePublic = new HashSet();
    getMethods(sc, interfaces, actualMethods, interfaceMethods, forcePublic);

    List methods = CollectionUtils.transform(actualMethods, new Transformer() {
        public Object transform(Object value) {
            Method method = (Method)value;
            int modifiers = Constants.ACC_FINAL
                | (method.getModifiers()
                    & ~Constants.ACC_ABSTRACT
                    & ~Constants.ACC_NATIVE
                    & ~Constants.ACC_SYNCHRONIZED);
            if (forcePublic.contains(MethodWrapper.create(method))) {
                modifiers = (modifiers & ~Constants.ACC_PROTECTED) | Constants.ACC_PUBLIC;
            }
            return ReflectUtils.getMethodInfo(method, modifiers);
        }
    });

    ClassEmitter e = new ClassEmitter(v);
    e.begin_class(Constants.V1_2,
                    Constants.ACC_PUBLIC,
                    getClassName(),
                    Type.getType(sc),
                    (useFactory ?
                    TypeUtils.add(TypeUtils.getTypes(interfaces), FACTORY) :
                    TypeUtils.getTypes(interfaces)),
                    Constants.SOURCE_FILE);
    List constructorInfo = CollectionUtils.transform(constructors, MethodInfoTransformer.getInstance());

    e.declare_field(Constants.ACC_PRIVATE, BOUND_FIELD, Type.BOOLEAN_TYPE, null);
    if (!interceptDuringConstruction) {
        e.declare_field(Constants.ACC_PRIVATE, CONSTRUCTED_FIELD, Type.BOOLEAN_TYPE, null);
    }
    e.declare_field(Constants.PRIVATE_FINAL_STATIC, THREAD_CALLBACKS_FIELD, THREAD_LOCAL, null);
    e.declare_field(Constants.PRIVATE_FINAL_STATIC, STATIC_CALLBACKS_FIELD, CALLBACK_ARRAY, null);
    if (serialVersionUID != null) {
        e.declare_field(Constants.PRIVATE_FINAL_STATIC, Constants.SUID_FIELD_NAME, Type.LONG_TYPE, serialVersionUID);
    }

    for (int i = 0; i < callbackTypes.length; i++) {
        e.declare_field(Constants.ACC_PRIVATE, getCallbackField(i), callbackTypes[i], null);
    }

    // 生成方法
    emitMethods(e, methods, actualMethods);
    // 生成构造方法
    emitConstructors(e, constructorInfo);
    emitSetThreadCallbacks(e);
    // 绑定静态callback
    emitSetStaticCallbacks(e);
    // 绑定callback
    emitBindCallbacks(e);

    if (useFactory) {
        int[] keys = getCallbackKeys();
        emitNewInstanceCallbacks(e);
        emitNewInstanceCallback(e);
        emitNewInstanceMultiarg(e, constructorInfo);
        emitGetCallback(e, keys);
        emitSetCallback(e, keys);
        emitGetCallbacks(e);
        emitSetCallbacks(e);
    }

    e.end_class();
}

public void setSuperclass(Class superclass) {
    if (superclass != null && superclass.isInterface()) {
        // 如果superClass不为空且是接口，就用Class数组来装载它
        setInterfaces(new Class[]{ superclass });
    } else if (superclass != null && superclass.equals(Object.class)) {
        // 如果superClass是Object类，则将superClass置为null
        // affects choice of ClassLoader
        this.superclass = null;
    } else {
        // 否则记录superClass
        this.superclass = superclass;
    }
}

private Object createHelper() {
    validate();
    if (superclass != null) {
        // 如果superClass不为空，则设置namePrefix为superClass的全限定类名
        setNamePrefix(superclass.getName());
    } else if (interfaces != null) {
        setNamePrefix(interfaces[ReflectUtils.findPackageProtected(interfaces)].getName());
    }
    return super.create(KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                                                ReflectUtils.getNames(interfaces),
                                                filter,
                                                callbackTypes,
                                                useFactory,
                                                interceptDuringConstruction,
                                                serialVersionUID));
}

protected Object firstInstance(Class type) throws Exception {
    // 是否仅生产类对象
    if (classOnly) {
        return type;
    } else {
        // 如果要生成实例对象，使用反射实现
        return createUsingReflection(type);
    }
}

private Object createUsingReflection(Class type) {
    setThreadCallbacks(type, callbacks);
    try {
        if (argumentTypes != null) {
            // 有指定参数和参数类型
            return ReflectUtils.newInstance(type, argumentTypes, arguments);    
        } else {
            // 没有参数和参数类型
            return ReflectUtils.newInstance(type);
        }
    }finally{
        // clear thread callbacks to allow them to be gc'd
        setThreadCallbacks(type, null);
    }
}

$> tree .
.
├── com
│   └── coderap
│       └── proxy
│           └── cglib
│               ├── Bugatti$$EnhancerByCGLIB$$4ddb6f26$$FastClassByCGLIB$$48029d80.class
│               ├── Bugatti$$EnhancerByCGLIB$$4ddb6f26.class
│               ├── Bugatti$$FastClassByCGLIB$$e6a580a8.class
│               ├── Ferrari$$EnhancerByCGLIB$$76b91705$$FastClassByCGLIB$$edb3e882.class
│               ├── Ferrari$$EnhancerByCGLIB$$76b91705.class
│               └── Ferrari$$FastClassByCGLIB$$9f935905.class
└── net
    └── sf
        └── cglib
            ├── core
            │   └── MethodWrapper$MethodWrapperKey$$KeyFactoryByCGLIB$$d45e49f7.class
            └── proxy
                └── Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72.class

9 directories, 8 files

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.coderap.proxy.cglib;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class Bugatti$$EnhancerByCGLIB$$4ddb6f26 extends Bugatti implements Factory {
    private boolean CGLIB$BOUND;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0; // 拦截器
    private static final Method CGLIB$run$0$Method; // 被代理的方法
    private static final MethodProxy CGLIB$run$0$Proxy; // 代理方法
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$getInfo$1$Method; // 被代理的方法
    private static final MethodProxy CGLIB$getInfo$1$Proxy; // 代理方法
    private static final Method CGLIB$finalize$2$Method; // 被代理的方法
    private static final MethodProxy CGLIB$finalize$2$Proxy; // 代理方法
    private static final Method CGLIB$equals$3$Method; // 被代理的方法
    private static final MethodProxy CGLIB$equals$3$Proxy; // 代理方法
    private static final Method CGLIB$toString$4$Method; // 被代理的方法
    private static final MethodProxy CGLIB$toString$4$Proxy; // 代理方法
    private static final Method CGLIB$hashCode$5$Method; // 被代理的方法
    private static final MethodProxy CGLIB$hashCode$5$Proxy; // 代理方法
    private static final Method CGLIB$clone$6$Method; // 被代理的方法
    private static final MethodProxy CGLIB$clone$6$Proxy; // 代理方法

    static {
        CGLIB$STATICHOOK1();
    }

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.coderap.proxy.cglib.Bugatti$$EnhancerByCGLIB$$4ddb6f26"); // 代理类
        Class var1; // 目标类
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$finalize$2$Method = var10000[0];
        CGLIB$finalize$2$Proxy = MethodProxy.create(var1, var0, "()V", "finalize", "CGLIB$finalize$2");
        CGLIB$equals$3$Method = var10000[1];
        CGLIB$equals$3$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$3");
        CGLIB$toString$4$Method = var10000[2];
        CGLIB$toString$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$4");
        CGLIB$hashCode$5$Method = var10000[3];
        CGLIB$hashCode$5$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$5");
        CGLIB$clone$6$Method = var10000[4];
        CGLIB$clone$6$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$6");
        // 获取被代理类的方法
        var10000 = ReflectUtils.findMethods(new String[]{"run", "()V", "getInfo", "()Ljava/lang/String;"}, (var1 = Class.forName("com.coderap.proxy.cglib.Bugatti")).getDeclaredMethods());
        CGLIB$run$0$Method = var10000[0];
        // 初始化代理类的run方法
        CGLIB$run$0$Proxy = MethodProxy.create(var1, var0, "()V", "run", "CGLIB$run$0");
        CGLIB$getInfo$1$Method = var10000[1];
        // 代理类的getInfo方法
        CGLIB$getInfo$1$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "getInfo", "CGLIB$getInfo$1");
    }

    // 代理方法，在使用methodProxy.invokeSuper(...)时会调用该方法
    final void CGLIB$run$0() {
        super.run();
    }

    /**
     * 目标类的被代理方法，如果直接使用methodProxy.invoke()时会调用该方法
     * 如果在拦截器中调用methodProxy.invoke()会陷入死循环，
     * 因为在该方法中会一直调用拦截器
     */
    public final void run() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            // 调用拦截器
            var10000.intercept(this, CGLIB$run$0$Method, CGLIB$emptyArgs, CGLIB$run$0$Proxy);
        } else {
            super.run();
        }
    }

    // 代理方法，在使用methodProxy.invokeSuper时会调用该方法
    final String CGLIB$getInfo$1() {
        return super.getInfo();
    }

    // 目标类的被代理方法
    public final String getInfo() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$getInfo$1$Method, CGLIB$emptyArgs, CGLIB$getInfo$1$Proxy) : super.getInfo();
    }

    final void CGLIB$finalize$2() throws Throwable {
        super.finalize();
    }

    protected final void finalize() throws Throwable {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$finalize$2$Method, CGLIB$emptyArgs, CGLIB$finalize$2$Proxy);
        } else {
            super.finalize();
        }
    }

    final boolean CGLIB$equals$3(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$3$Method, new Object[]{var1}, CGLIB$equals$3$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$4() {
        return super.toString();
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$4$Method, CGLIB$emptyArgs, CGLIB$toString$4$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$5() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$5$Method, CGLIB$emptyArgs, CGLIB$hashCode$5$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$6() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$6$Method, CGLIB$emptyArgs, CGLIB$clone$6$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -1574182249:
            if (var10000.equals("finalize()V")) {
                return CGLIB$finalize$2$Proxy;
            }
            break;
        case -919875318:
            if (var10000.equals("run()V")) {
                return CGLIB$run$0$Proxy;
            }
            break;
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$6$Proxy;
            }
            break;
        case -244718353:
            if (var10000.equals("getInfo()Ljava/lang/String;")) {
                return CGLIB$getInfo$1$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$3$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$4$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$5$Proxy;
            }
        }

        return null;
    }

    public Bugatti$$EnhancerByCGLIB$$4ddb6f26(String var1) {
        super(var1);
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        Bugatti$$EnhancerByCGLIB$$4ddb6f26 var1 = (Bugatti$$EnhancerByCGLIB$$4ddb6f26)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        // $FF: Couldn't be decompiled
    }

    public Object newInstance(Callback var1) {
        // $FF: Couldn't be decompiled
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        Bugatti$$EnhancerByCGLIB$$4ddb6f26 var10000 = new Bugatti$$EnhancerByCGLIB$$4ddb6f26;
        switch(var1.length) {
        case 1:
            if (var1[0].getName().equals("java.lang.String")) {
                var10000.<init>((String)var2[0]);
                CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
                return var10000;
            }
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }
}

private MethodInterceptor CGLIB$CALLBACK_0; // 拦截器
private static final Method CGLIB$run$0$Method; // 被代理的方法
private static final MethodProxy CGLIB$run$0$Proxy; // 代理方法
...
private static final Method CGLIB$getInfo$1$Method; // 被代理的方法
private static final MethodProxy CGLIB$getInfo$1$Proxy; // 代理方法
private static final Method CGLIB$finalize$2$Method; // 被代理的方法
private static final MethodProxy CGLIB$finalize$2$Proxy; // 代理方法
private static final Method CGLIB$equals$3$Method; // 被代理的方法
private static final MethodProxy CGLIB$equals$3$Proxy; // 代理方法
private static final Method CGLIB$toString$4$Method; // 被代理的方法
private static final MethodProxy CGLIB$toString$4$Proxy; // 代理方法
private static final Method CGLIB$hashCode$5$Method; // 被代理的方法
private static final MethodProxy CGLIB$hashCode$5$Proxy; // 代理方法
private static final Method CGLIB$clone$6$Method; // 被代理的方法
private static final MethodProxy CGLIB$clone$6$Proxy; // 代理方法

Class var0 = Class.forName("com.coderap.proxy.cglib.Bugatti$$EnhancerByCGLIB$$4ddb6f26"); // 代理类
Class var1; // 目标类
Method[] var10000 = ReflectUtils.findMethods(new String[]{"finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());// 获取被代理类的方法
var10000 = ReflectUtils.findMethods(new String[]{"run", "()V", "getInfo", "()Ljava/lang/String;"}, (var1 = Class.forName("com.coderap.proxy.cglib.Bugatti")).getDeclaredMethods());
CGLIB$run$0$Method = var10000[0];
// 初始化代理类的run方法
CGLIB$run$0$Proxy = MethodProxy.create(var1, var0, "()V", "run", "CGLIB$run$0");
CGLIB$getInfo$1$Method = var10000[1];
// 代理类的getInfo方法
CGLIB$getInfo$1$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "getInfo", "CGLIB$getInfo$1");

public static Method[] findMethods(String[] namesAndDescriptors, Method[] methods) {
    Map map = new HashMap();

    // 将传入的所有method对象装入字典map，使用ASM框架获取的method描述作为键，method对象作为值
    for(int i = 0; i < methods.length; ++i) {
        Method method = methods[i];
        map.put(method.getName() + Type.getMethodDescriptor(method), method);
    }

    // 定义一个Method数组，用于放置筛选出的Method方法
    Method[] result = new Method[namesAndDescriptors.length / 2];

    for(int i = 0; i < result.length; ++i) {
        result[i] = (Method)map.get(namesAndDescriptors[i * 2] + namesAndDescriptors[i * 2 + 1]);
        if (result[i] == null) {
            ;
        }
    }

    return result;
}