Cglib源码解析

1. 使用举例

public interface Calculator {
    public int add(int i, int j);
}


public class MyCglib implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        Object o1 = methodProxy.invokeSuper(o, objects);
        return o1;
    }
}


public static void main(String[] args) {
        //动态代理创建的class文件存储到本地
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"d:\\code");
        //通过cglib动态代理获取代理对象的过程，创建调用的对象,在后续创建过程中EnhanceKey的对象，所以在进行enhancer对象创建的时候需要把EnhancerKey（newInstance）对象准备好,不过这个对象也需要动态代理来生成
        Enhancer enhancer = new Enhancer();
        //设置enhancer对象的父类
        enhancer.setSuperclass(MyCalculator.class);
        MyCglib myCglib = new MyCglib();
        //设置enhancer的回调对象
        enhancer.setCallback(myCglib);
        //创建代理对象
        MyCalculator myCalculator = (MyCalculator) enhancer.create();
        //通过代理对象调用目标方法
        int add = myCalculator.add(1, 1);
        System.out.println(myCalculator.getClass());
    }

2. 源码解析

public Object create() {
		classOnly = false;
		argumentTypes = null;
		return createHelper();
	}

private Object createHelper() {
		// 校验callbackTypes、filter是否为空，以及为空时的处理
		preValidate();
		// 通过newInstance方法来创建EnhancerKey对象，正常情况下，只需要new一个对象就可以调用方法了，
		// 但是Key_Factory是一个EnhancerKey类型，是一个内部接口，需要动态代理来实现，最终是为了调用newInstance方法
		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);
		// 设置当前enhancer的代理类的key标识
		this.currentKey = key;
		// 调用父类即AbstractClassGenerator的创建代理类
		Object result = super.create(key);
		return result;
	}

链接到AbstractClassGenerator.java#create(key)方法

protected Object create(Object key) {
		try {
			// 获取到当前生成器的类加载器
			ClassLoader loader = getClassLoader();
			// 当前类加载器对应的缓存  缓存key为类加载器，缓存的value为ClassLoaderData，可以理解为一个缓存对象，只不过此缓存对象中包含的是具体的业务逻辑处理过程，
			// 有两个function的函数式接口，一个是返回gen.key,对应的名称叫GET_KEY,还有一个是为了创建具体的class，名字叫做load
			Map<ClassLoader, ClassLoaderData> cache = CACHE;
			// 先从缓存中获取下当前类加载器所有加载过的类
			ClassLoaderData data = cache.get(loader);
			// 如果为空
			if (data == null) {
				synchronized (AbstractClassGenerator.class) {
					cache = CACHE;
					data = cache.get(loader);
					if (data == null) {
						// 新建一个缓存Cache，并将之前的缓存Cache的数据添加进来，并将已经被gc回收的数据给清除掉
						Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
						// 新建一个当前加载器对应的ClassLoaderData并加到缓存中，但ClassLoaderData中此时还没有数据
						data = new ClassLoaderData(loader);
						newCache.put(loader, data);
						// 刷新全局缓存
						CACHE = newCache;
					}
				}
			}
			// 设置一个全局key
 			this.key = key;
			// 在刚创建的data(ClassLoaderData)中调用get方法 并将当前生成器，
			// 返回的是生成好的代理类的class信息；--》generatedClasses.get(gen);
            //其中generatedClasses包含两个Function；有两个构建好的回调。根据判断调用，最终达到生成字节码的目的。
			Object obj = data.get(this, getUseCache());
			// 如果为class则实例化class并返回我们需要的代理类
			if (obj instanceof Class) {
				return firstInstance((Class) obj);
			}
			// 如果不是则说明是实体，则直接执行另一个方法返回实体
			return nextInstance(obj);
		}
		catch (RuntimeException | Error ex) {
			throw ex;
		}
		catch (Exception ex) {
			throw new CodeGenerationException(ex);
		}
	}

上面代码注意ClassLoaderData类，是一个内部类AbstractClasGenerator$ClassLoaderData，其中比较重要的属性generatedClasses，是一个LoadingCache 类型

public LoadingCache(Function<K, KK> keyMapper, Function<K, V> loader) {
        this.keyMapper = keyMapper;
        this.loader = loader;
        this.map = new ConcurrentHashMap();
    }

包含两个Function 类型的函数。

另外ClassLoaderData 的代码如下：

	protected static class ClassLoaderData {

		private final Set<String> reservedClassNames = new HashSet<String>();

		private final LoadingCache<AbstractClassGenerator, Object, Object> generatedClasses;


		private final WeakReference<ClassLoader> classLoader;

		private final Predicate uniqueNamePredicate = new Predicate() {
			public boolean evaluate(Object name) {
				return reservedClassNames.contains(name);
			}
		};

        //核心代码，回调获取key
		private static final Function<AbstractClassGenerator, Object> GET_KEY = new Function<AbstractClassGenerator, Object>() {
			public Object apply(AbstractClassGenerator gen) {
				return gen.key;
			}
		};

        //注意这个构造方法，里面
		public ClassLoaderData(ClassLoader classLoader) {
			// 判断类加载器不能为空
			if (classLoader == null) {
				throw new IllegalArgumentException("classLoader == null is not yet supported");
			}
			// 设置类加载器，弱引用 即在下次垃圾回收时就会进行回收
			this.classLoader = new WeakReference<ClassLoader>(classLoader);
            
			// 新建一个回调函数，该回调函数的作用在于缓存中没获取到值时，生成字节码文件
			Function<AbstractClassGenerator, Object> load =
					new Function<AbstractClassGenerator, Object>() {
						public Object apply(AbstractClassGenerator gen) {
							//生成字节码文件
							Class klass = gen.generate(ClassLoaderData.this);
							return gen.wrapCachedClass(klass);
						}
					};
			// 为这个ClassLoadData新建一个缓存类
			generatedClasses = new LoadingCache<AbstractClassGenerator, Object, Object>(GET_KEY, load);
		}

	 //...省略若干代码....
		public Object get(AbstractClassGenerator gen, boolean useCache) {
			// 如果不用缓存(默认使用)
			if (!useCache) {
				// 则直接调用生成器的命令
				return gen.generate(ClassLoaderData.this);
			}
			else {
				// 传入代理类生成器 并根据代理类生成器获取值返回
				Object cachedValue = generatedClasses.get(gen);
				// 解包装并返回
				return gen.unwrapCachedValue(cachedValue);
			}
		}
	}

总结

主要是需要生成字节码。LoadingCache中放入了两个Function函数，通过回调的形式，一个获取key，一个根据上面的key获取字节码对象。
部分字节码展示：

  
  public final int add(int paramInt1, int paramInt2) {
    if (this.CGLIB$CALLBACK_0 == null)
      CGLIB$BIND_CALLBACKS(this); 
    if (this.CGLIB$CALLBACK_0 != null) {
      this.CGLIB$CALLBACK_0.intercept(this, CGLIB$add$0$Method, new Object[] { new Integer(paramInt1), new Integer(paramInt2) }, CGLIB$add$0$Proxy);
      return (this.CGLIB$CALLBACK_0.intercept(this, CGLIB$add$0$Method, new Object[] { new Integer(paramInt1), new Integer(paramInt2) }, CGLIB$add$0$Proxy) == null) ? 0 : ((Number)this.CGLIB$CALLBACK_0.intercept(this, CGLIB$add$0$Method, new Object[] { new Integer(paramInt1), new Integer(paramInt2) }, CGLIB$add$0$Proxy)).intValue();
    } 
    return super.add(paramInt1, paramInt2);
  }

可以看到callBack 不为空的话，那么调用intercept。继而调用到FastClass 中的方法。