Spring代理

2018-01-03

spring代理问题

问题还是起于老掉牙的spring @Transactional 同类调用不生效的问题。
以下的场景都基于method1调用method2，@Transactional 是加载method2上，外部调用调用的是method1接口。
大致结构如下


public void method1() {
    System.out.println("do in method 1");
    method2();
}
@Transactional
public void method2() {
    System.out.println("do in method 2");
}

以前一直对于这个问题懵懵懂懂，现在彻底的来搞明白这个事情。

疑问

对于jdk动态代理，其实问题一直很明白，因为jdk动态代理生成的proxy是继承自java.lang.reflect.Proxy，反射到目标类去执行，而在目标类的内部调用中是无法再回到代理类的，所以 @Transactional 在同类调用之间无效。

但是cglib生成的是目标类的子类，猜想的结构大概是这样的。

//猜想的cglib生成类简易写法
public class GuessedCglibProxy extends SimpleCglibService {
    @Override
    public void method1() {
        System.out.println("GuessedCglibProxy in method1");
        super.method1();
    }
    @Override
    public void method2() {
        System.out.println("GuessedCglibProxy in method2");
        super.method2();
    }
}
public class SimpleCglibService {
    public void method1() {
        System.out.println("SimpleCglibService in method1");
        method2();
    }
    public void method2() {
        System.out.println("SimpleCglibService in method2");
    }
    public static void main(String[] args) {
        GuessedCglibProxy guessedCglibProxy = new GuessedCglibProxy();
        guessedCglibProxy.method1();
    }
}

猜想cglib代理的调用栈
这样理论上应该是能够调用到代理类的。
但是事实是并不能调用成功。
找了一下Spring文档也发现了相关的结论。

Note: In proxy mode (which is the default), only ‘external’ method calls coming in through the proxy will be intercepted. This means that ‘self-invocation’, i.e. a method within the target object calling some other method of the target object, won’t lead to an actual transaction at runtime even if the invoked method is marked with @Transactional!

Consider the use of AspectJ mode (see below) if you expect self-invocations to be wrapped with transactions as well. In this case, there won’t be a proxy in the first place; instead, the target class will be ‘weaved’ (i.e. its byte code will be modified) in order to turn @Transactional into runtime behavior on any kind of method.

重新梳理一下知识点。那么究竟问题在哪。

jdk动态代理

jdk动态代理调用栈

jdk动态代理的调用栈

jdk动态代理demo代码

测试代码地址

先看下简易的动态代理的代码

public interface SimpleService {
    void method1();
    void method2();
}
public class SimpleServiceImpl implements SimpleService {
    @Override
    public void method1() {
        System.out.println("do in method 1");
        method2();
    }
    @Override
    public void method2() {
        System.out.println("do in method 2");
    }
    public static void main(String[] args) {
        //生成jdk动态代理的方法
        ProxyUtils.generateClassFile(SimpleService.class, "SimpleServiceJavaDynamicProxy");
        SimpleService simpleService = new SimpleServiceImpl();
        SimpleService simpleServiceImpl = SimpleServiceProxy.proxy(SimpleService.class, simpleService);
        simpleServiceImpl.method1();
    }
}
public class SimpleServiceProxyHandler implements InvocationHandler {
    //invoke 方法并不提供impl的实例，因为proxy在生成的时候是与impl无关的，所以这里需要自己塞进去
    private Object target;
    public SimpleServiceProxyHandler(Object target) {
        this.target = target;
    }
    // 方法需要自定义
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("in proxy, class : " + target.getClass().getName() + " ,method : " + method.getName());
        return method.invoke(target, args);
    }
}
public class SimpleServiceProxy {
    //构建代理类，详细分析下面会有
    public static <T> T proxy(final Class<T> interfaceClass, T target) {
        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[]{interfaceClass},
                new SimpleServiceProxyHandler(target));
    }
}
public class ProxyUtils {
    // 动态代理类落地的方法。
    // 一般都是在target同类的目录下
    public static void generateClassFile(Class clazz,String proxyName){
        byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
        String paths = clazz.getResource(".").getPath();
        System.out.println(paths);
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(paths+proxyName+".class");
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Jdk动态代理的生成类

public final class SimpleServiceJavaDynamicProxy extends Proxy implements SimpleService {
    private static Method m1;
    private static Method m2;
    private static Method m4;
    private static Method m3;
    private static Method m0;
    public SimpleServiceJavaDynamicProxy(InvocationHandler var1) throws  {
        super(var1);
    }
    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } 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 method2() 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 method1() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("com.bobby.peng.learning.java.proxy.javadynamicproxy.SimpleService").getMethod("method2", new Class[0]);
            m3 = Class.forName("com.bobby.peng.learning.java.proxy.javadynamicproxy.SimpleService").getMethod("method1", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

由于动态代理的class继承了proxy，所以jdk动态代理必须要有接口。
super.h.invoke 其实调用的是InvocationHandler的方法，自己实现，一般是method.invoke(target,args)，所以在target内部调用，target.method1 直接调用 target.method2,调用栈在之前有显示，并不会经过proxy.method2,故@Transactional如果处于method2上会失效。

更加深入的了解一下jdk动态代理

先看下newProxyInstance方法
整个逻辑其实很简单，获得proxy的class，然后构造proxy实例。

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        // 校验部分
        Objects.requireNonNull(h);
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        // 获取proxy的class（包括构造）
        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);
        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            // 构造对象
            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;
                    }
                });
            }
            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);
        }
    }

其中关键节点是getProxyClass0方法，下面是一整条调用链。
通过接口可以发现，proxy class 仅仅与 classloader 和 interface 有关
所以在继承InvocationHandler的时候，impl的实例是不存在的。仅仅只有proxy的实例。

/*
 * Look up or generate the designated proxy class.
 */
Class<?> cl = getProxyClass0(loader, intfs);
/**
 * Generate a proxy class.  Must call the checkProxyAccess method
 * to perform permission checks before calling this.
 */
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
    return proxyClassCache.get(loader, interfaces);
}
/**
 * Look-up the value through the cache. This always evaluates the
 * {@code subKeyFactory} function and optionally evaluates
 * {@code valueFactory} function if there is no entry in the cache for given
 * pair of (key, subKey) or the entry has already been cleared.
 *
 * @param key       possibly null key
 * @param parameter parameter used together with key to create sub-key and
 *                  value (should not be null)
 * @return the cached value (never null)
 * @throws NullPointerException if {@code parameter} passed in or
 *                              {@code sub-key} calculated by
 *                              {@code subKeyFactory} or {@code value}
 *     
 */
// weak cache 源代码
// 在proxy中 key : classloader ,parameter : interfaces
public V get(K key, P parameter) {
        Objects.requireNonNull(parameter);
        // 清除已经被回收的weak reference map中的value值，在weak reference部分会有源码
        expungeStaleEntries();
        // 这里的cache key是一个weak reference 的 key
        // 关于weak reference 下文会有论述
        // refQueue 的作用同样也在weak reference中阐述
        Object cacheKey = CacheKey.valueOf(key, refQueue);
        // lazily install the 2nd level valuesMap for the particular cacheKey
        // map的第一层仅仅与classloader有关
        // 我感觉这一层map的区分度不是很高，不如直接就采用一层map，直接用里面一层的，classloader和interface直接组成一个key
        // 外层是weak reference的key，意味着一旦被回收，该classloader所有的proxy就会被回收，感觉不太合理（todo 仔细想想）
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            // 参考 putIfAbsent 方法 return 说明
            // return null的时候说明put的时候是absent的，如果不为null，说明有并发场景存在
            // 外层判定是保证效率，内层判空是防止并发
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }
        // create subKey and retrieve the possible Supplier<V> stored by that
        // subKey from valuesMap
        // subKeyFactory.apply 构建的时候是通过parameter 也就是 接口来实现的
        // key 也就是 classloader 并没有用到
        // 也就是说 subkey 仅仅是接口相关而与实现类无关
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;
        while (true) {
            if (supplier != null) {
                // supplier might be a Factory or a CacheValue<V> instance
                // 下文会有分析
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            // else no supplier in cache
            // or a supplier that returned null (could be a cleared CacheValue
            // or a Factory that wasn't successful in installing the CacheValue)
            // lazily construct a Factory
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }
            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // successfully installed Factory
                    supplier = factory;
                }
                // else retry with winning supplier
            } else {
                if (valuesMap.replace(subKey, supplier, factory)) {
                    // successfully replaced
                    // cleared CacheEntry / unsuccessful Factory
                    // with our Factory
                    supplier = factory;
                } else {
                    // retry with current supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

supplier might be a Factory or a CacheValue instance
关于这句注释，当时看代码的时候有点奇怪，当时以为是简单的get，现在看来get都不是简单的get。 TAT

Factory相关

@Override
public synchronized V get() { // serialize access
    // re-check
    Supplier<V> supplier = valuesMap.get(subKey);
    if (supplier != this) {
        // something changed while we were waiting:
        // might be that we were replaced by a CacheValue
        // or were removed because of failure ->
        // return null to signal WeakCache.get() to retry
        // the loop
        // 防止多线程发生，因为在get外部不是同步的
        return null;
    }
    // else still us (supplier == this)
    // create new value
    V value = null;
    try {
        // 这里的apply生成真正的proxy.class 文件
        value = Objects.requireNonNull(valueFactory.apply(key, parameter));
    } finally {
        if (value == null) { // remove us on failure
            valuesMap.remove(subKey, this);
        }
    }
    // the only path to reach here is with non-null value
    assert value != null;
    // wrap value with CacheValue (WeakReference)
    // 构造valuemaps的新对象
    CacheValue<V> cacheValue = new CacheValue<>(value);
    // try replacing us with CacheValue (this should always succeed)
    // replace牛逼啊！还是default的有木有啊！还是cas的卧槽！
    if (valuesMap.replace(subKey, this, cacheValue)) {
        // put also in reverseMap
        // reverse Map 感觉用Set会更好，因为塞入的值都是true
        // 而且只有在size和containsValue才有用
        reverseMap.put(cacheValue, Boolean.TRUE);
    } else {
        throw new AssertionError("Should not reach here");
    }
    // successfully replaced us with new CacheValue -> return the value
    // wrapped by it
    return value;
}

这里同步get的理由应该是要防止并发，并降低锁的粒度，否则锁的粒度应该构建整个map的时候就开始了。
proxy生成的代码比较复杂就不看了

在构建类发现一行这个代码，也就是说只要将saveGeneratedFiles设为true就会生成proxy.class在硬盘上。

private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();
if(saveGeneratedFiles) {
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            try {
                int var1 = var0.lastIndexOf(46);
                Path var2;
                if(var1 > 0) {
                    Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), new String[0]);
                    Files.createDirectories(var3, new FileAttribute[0]);
                    var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                } else {
                    var2 = Paths.get(var0 + ".class", new String[0]);
                }
                Files.write(var2, var4, new OpenOption[0]);
                return null;
            } catch (IOException var4x) {
                throw new InternalError("I/O exception saving generated file: " + var4x);
            }
        }
    });
}

默认在项目根目录下有个com.sun.xxx下就会出现proxy.class文件。不用单独的去写utils类了，以下是开启方法。

1	System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

关于 weak reference 简单的理解 //todo 详细了解weak reference

对象被创建之后，如果没有任何引用指向他，且发生gc，则对象则会被消失。
如果引用的该对象的是一个集合，我们经常会在代码中看到 node = null;//help gc 这样的代码来帮助gc。
但是cache是例外的，因为cache不知道他的生命周期是怎么样的，比如我们在使用redis的时候我们并不知道这个key应该存在多久，什么时候会被停止使用，是否够热。
那么cache的普通做法是lru或者lfu，来保证cache中的数据是最有效的。而内存中的cache一般不会那么做（redis有内存大小的限制），因为我们无法估算大小，且在系统允许的情况下存的越多越好。
而在上述proxy的使用场景下，一个interface下大概率也只用proxy.class一次（比如单例的service），而我们项目假设有1000个需要动态代理的class，那么在cache中的也有1000个对象，可能大部分是无效的，占用了大部分内存。
因为我们无法知晓cache的生命周期，所以 node = null; //help gc 这样的代码显然不适合我们。
所以weak reference的意义就在这里，当且仅当一个对象被weak reference指向时，gc时就被回收。
因为weak reference 是随着gc被回收，所以他的回收是具有不确定性的，一般用于易构建但是占用内存较大的对象。
代码中会看到清空ReferenceQueue，这里保存的是已经被回收的weak reference，因为weak reference本身是没有用的。
下面代码是关于weak reference的回收

private void expungeStaleEntries() {
    CacheKey<K> cacheKey;
    while ((cacheKey = (CacheKey<K>)refQueue.poll()) != null) {
        //在weak reference的对象被回收之后，weak reference本身和map中的数据需要一并的清空
        cacheKey.expungeFrom(map, reverseMap);
    }
}
void expungeFrom(ConcurrentMap<?, ? extends ConcurrentMap<?, ?>> map,
                 ConcurrentMap<?, Boolean> reverseMap) {
    // removing just by key is always safe here because after a CacheKey
    // is cleared and enqueue-ed it is only equal to itself
    // (see equals method)...
    ConcurrentMap<?, ?> valuesMap = map.remove(this);
    // remove also from reverseMap if needed
    if (valuesMap != null) {
        for (Object cacheValue : valuesMap.values()) {
            reverseMap.remove(cacheValue);
        }
    }
}

cglib动态代理

cglib调用栈

cglib调用栈
以前虽然用的多但是从来没有思考过相关的实现（主要是懒）。
图中红圈所示的两个地方是cglib两个不同的生成类。分别是enhanceClass 和 fastClass。

enhanceClass是调用了method1方法，可以认为是重写了父类接口。
fastClass调用的是invoke接口反射到了目标类的method1，和之前jdk动态代理是一模一样的，所以一旦用fastClass进入了目标类的方法，@Transactional也依旧会失效。
enhanceClass的理解大概和之前猜测的增强类实现应该一致，而fastClass是干嘛用的呢。

cglib demo代码

public class SimpleCglibService {
    public void method1() {
        System.out.println("SimpleCglibService in method1");
        method2();
    }
    public void method2() {
        System.out.println("SimpleCglibService in method2");
    }
    public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/peng2035/git/learning/learning-java/target/classes/com/bobby/peng/learning/java/proxy/cglib/");
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(SimpleCglibService.class);
        enhancer.setCallback(new CglibProxy());
        SimpleCglibService simpleCglibService = (SimpleCglibService) enhancer.create();
        simpleCglibService.method1();
    }
}
public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("begin");
        Object invoke = methodProxy.invoke(new SimpleCglibService(),objects);
        System.out.println("end");
        return invoke;
    }
}

其实代码和java动态代理差不多，就是InvocationHandler和cglib callback接口的差别还有构建的差别。
分为以下几点

之前看到jdk动态代理的时候classloader是个绕不开的东西，invocationHandler创建的时候需要传入来做WeakCache的缓存的key，而enhancer只需要setCallback,new Enhancer中并没有要求传入classloader，代码里会自己去找上下文的ClassLoader。

// 和jdk动态代理的keyFactory类似
public static KeyFactory create(Class keyInterface, KeyFactoryCustomizer first, List<KeyFactoryCustomizer> next) {
    return create(keyInterface.getClassLoader(), keyInterface, first, next);
}
public static KeyFactory create(ClassLoader loader, Class keyInterface, KeyFactoryCustomizer customizer,
                                List<KeyFactoryCustomizer> next) {
    Generator gen = new Generator();
    gen.setInterface(keyInterface);
    if (customizer != null) {
        gen.addCustomizer(customizer);
    }
    if (next != null && !next.isEmpty()) {
        for (KeyFactoryCustomizer keyFactoryCustomizer : next) {
            gen.addCustomizer(keyFactoryCustomizer);
        }
    }
    gen.setClassLoader(loader);
    return gen.create();
}
protected Object create(Object key) {
        try {
            ClassLoader loader = getClassLoader();
            Map<ClassLoader, ClassLoaderData> cache = CACHE;
            // 同样是通过classloader来进行一级缓存
            ClassLoaderData data = cache.get(loader);
            if (data == null) {
                // jdk动态代理1.8的情况下用putIfAbsent来解决了并发的效率问题
                // cglib更加直观直接用同步锁来解决
                synchronized (AbstractClassGenerator.class) {
                    cache = CACHE;
                    data = cache.get(loader);
                    if (data == null) {
                        Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
                        data = new ClassLoaderData(loader);
                        newCache.put(loader, data);
                        CACHE = newCache;
                    }
                }
            }
            this.key = key;
            Object obj = data.get(this, getUseCache());
            if (obj instanceof Class) {
                return firstInstance((Class) obj);
            }
            return nextInstance(obj);
        } catch (RuntimeException e) {
            throw e;
        } catch (Error e) {
            throw e;
        } catch (Exception e) {
            throw new CodeGenerationException(e);
        }
    }

cglib intercept 方法中参数多了一个methodProxy

如果在代码中把interceptor的methodPrxoy替换成method，和jdk动态代理没有区别，代码调用栈如下
1
Object invoke = method.invoke(new SimpleCglibService(),objects);

不用methodproxy

cglib的method proxy 中有两个方法，invoke 和 invokeSuper

/**
   * Invoke the original method, on a different object of the same type.
   * @param obj the compatible object; recursion will result if you use the object passed as the first
   * argument to the MethodInterceptor (usually not what you want)
   * @param args the arguments passed to the intercepted method; you may substitute a different
   * argument array as long as the types are compatible
   * @see MethodInterceptor#intercept
   * @throws Throwable the bare exceptions thrown by the called method are passed through
   * without wrapping in an <code>InvocationTargetException</code>
   */
  public Object invoke(Object obj, Object[] args) throws Throwable {
      try {
          init();
          FastClassInfo fci = fastClassInfo;
          //代码差异点
          return fci.f1.invoke(fci.i1, obj, args);
      } catch (InvocationTargetException e) {
          throw e.getTargetException();
      } catch (IllegalArgumentException e) {
          if (fastClassInfo.i1 < 0)
              throw new IllegalArgumentException("Protected method: " + sig1);
          throw e;
      }
  }
  /**
   * Invoke the original (super) method on the specified object.
   * @param obj the enhanced object, must be the object passed as the first
   * argument to the MethodInterceptor
   * @param args the arguments passed to the intercepted method; you may substitute a different
   * argument array as long as the types are compatible
   * @see MethodInterceptor#intercept
   * @throws Throwable the bare exceptions thrown by the called method are passed through
   * without wrapping in an <code>InvocationTargetException</code>
   */
  public Object invokeSuper(Object obj, Object[] args) throws Throwable {
      try {
          init();
          FastClassInfo fci = fastClassInfo;
          //代码差异点
          return fci.f2.invoke(fci.i2, obj, args);
      } catch (InvocationTargetException e) {
          throw e.getTargetException();
      }
  }

代码差异主要在fci.f1 fci.f2，这两个是不同的两个fastClassInfo。
f1主要是原始类的子类很好理解
f2则是一个fastClass

public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
      //原始类
      SimpleCglibService var10000 = (SimpleCglibService)var2;
      int var10001 = var1;
      try {
          switch(var10001) {
          case 0:
              SimpleCglibService.main((String[])var3[0]);
              return null;
          case 1:
              var10000.method1();
              return null;
          case 2:
              var10000.method2();
              return null;
          case 3:
              return new Boolean(var10000.equals(var3[0]));
          case 4:
              return var10000.toString();
          case 5:
              return new Integer(var10000.hashCode());
          }
      } catch (Throwable var4) {
          throw new InvocationTargetException(var4);
      }
      throw new IllegalArgumentException("Cannot find matching method/constructor");
  }

逻辑其实很简单，通过index来确定调用哪个方法。

关于fastclass

Jdk动态代理的拦截对象是通过反射的机制来调用被拦截方法的，反射的效率比较低，所以cglib采用了FastClass的机制来实现对被拦截方法的调用。FastClass机制就是对一个类的方法建立索引，通过索引来直接调用相应的方法。