Cglib动态代理源码
在cglib动态代理中生成代理对象核心代码是下面2句。
//创建Enhancer
Enhancer enhancer = new Enhancer();
//使用Enhancer创建代理类对象
Calculator calculator = (Calculator) enhancer.create();
调用代理对象的代码是下面1句。
//调用代理类对象的方法
calculator.add(1, 1);
首先先看Enhancer的创建。
Enhancer的创建
Enhancer的类结构
Enhancer 继承自 AbstractClassGenerator
Enhancer extends AbstractClassGenerator
AbstractClassGenerator实现了ClassGenerator接口
abstract public class AbstractClassGenerator<T> implements ClassGenerator
ClassGenerator只有1个方法,就是generateClass。
public interface ClassGenerator {
void generateClass(ClassVisitor var1) throws Exception;
}
因为我们下面会调用enhancer#create
Calculator calculator = (Calculator) enhancer.create();
因此可以大胆猜想这个Enhancer就是用来生成代理类的。
Enhancer属性:EnhancerKey
Enhancer初始化的时候会创建一个final的静态变量KEY_FACTORY,类型是EnhancerKey。
EnhancerKey是创建代理类的核心。
private static final EnhancerKey KEY_FACTORY =
(EnhancerKey) KeyFactory.create(EnhancerKey.class,
KeyFactory.HASH_ASM_TYPE, null);
KEY_FACTORY的类型是EnhancerKey,EnhanceKey是1个接口,接口中只有1个方法newInstance。
public interface EnhancerKey {
public Object newInstance(
String type,
String[] interfaces,
WeakCacheKey<CallbackFilter> filter,
Type[] callbackTypes,
boolean useFactory,
boolean interceptDuringConstruction,
Long serialVersionUID);
}
创建KEY_FACTORY的时候使用的是KeyFactory#create方法,参数有3个。
参数1:EnhancerKey.class。
参数2:KeyFactory.HASH_ASM_TYPE,KeyFactory.HASH_ASM_TYPE是1个HashCodeCustomizer。
public static final HashCodeCustomizer HASH_ASM_TYPE = new HashCodeCustomizer() {
public boolean customize(CodeEmitter e, Type type) {
if (Constants.TYPE_TYPE.equals(type)) {
e.invoke_virtual(type, GET_SORT);
return true;
}
return false;
}
};
参数3:null。
EnhancerKey的创建
Keyfactory#create
//参数1:EnhancerKey.class。
//参数2:KeyFactory.HASH_ASM_TYPE,KeyFactory.HASH_ASM_TYPE是1个HashCodeCustomizer。
//参数3:null。
public static KeyFactory create(Class keyInterface, KeyFactoryCustomizer first, List<KeyFactoryCustomizer> next) {
//EnhancerKey.class对应的ClassLoader
return create(keyInterface.getClassLoader(), keyInterface, first, next);
}
//参数1:EnhancerKey.class的类加载器。
//参数2:EnhancerKey.class。
//参数3:KeyFactory.HASH_ASM_TYPE,KeyFactory.HASH_ASM_TYPE是1个HashCodeCustomizer。
//参数4:null。
public static KeyFactory create(ClassLoader loader, Class keyInterface, KeyFactoryCustomizer customizer, List<KeyFactoryCustomizer> next) {
//创建一个最简易的代理类生成器 即只会生成HashCode equals toString newInstance方法
Generator gen = new Generator();
//设置接口为enhancerKey类型
gen.setInterface(keyInterface);
if (customizer != null) {
//添加定制器即1个HashCodeCustomizer
gen.addCustomizer(customizer);
}
//next是null
if (next != null && !next.isEmpty()) {
for (KeyFactoryCustomizer keyFactoryCustomizer : next) {
gen.addCustomizer(keyFactoryCustomizer);
}
}
//设置生成器的类加载器为EnhancerKey.class的类加载器
gen.setClassLoader(loader);
//生成enhancerKey的代理类
return gen.create();
}
KeyFactory.Generator#create
这儿创建了一个简易的代理类生成器:KeyFactory的内部类Generator 。
Generator 与Enhancer一样继承自抽象类AbstractClassGenerator。
使用Generator来生成我们需要的标识代理类，我们接着看KeyFactory.Generator#create方法。
//keyInterface.getName() = net.sf.cglib.proxy.Enhancer$EnhancerKey
public KeyFactory create() {
//设置了代理类名字前缀即net.sf.cglib.proxy.Enhancer$EnhancerKey
//这个前缀是被代理类的类限定名
setNamePrefix(keyInterface.getName());
//super是AbstractClassGenerator
return (KeyFactory)super.create(keyInterface.getName());
}
AbstractClassGenerator#create
//参数key = keyInterface.getName() = net.sf.cglib.proxy.Enhancer$EnhancerKey
protected Object create(Object key) {
try {
//获取到生成器中的类加载器即EnhancerKey.class的类加载器
ClassLoader loader = getClassLoader();
//CACHE= new WeakHashMap<ClassLoader, ClassLoaderData>();
//CACHE是当前类加载器对应的缓存,缓存key为类加载器，缓存value为ClassLoaderData
//可以将cache理解为1级缓存,ClassLoaderData是二级缓存。
Map<ClassLoader, ClassLoaderData> cache = CACHE;
//先从缓存中获取 当前类加载器 对应的ClassLoaderData
ClassLoaderData data = cache.get(loader);
//如果缓存中的data为空
if (data == null) {
synchronized (AbstractClassGenerator.class) {
cache = CACHE;
data = cache.get(loader);
//经典的防止并发修改 二次判断 double check
if (data == null) {
//新建一个缓存Cache 并把原来的缓存加入新建的缓存中
Map<ClassLoader, ClassLoaderData> newCache
= new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
//新建一个当前加载器对应的ClassLoaderData 并加到缓存中
//ClassLoaderData#ClassLoaderData
data = new ClassLoaderData(loader);
//放入新缓存
newCache.put(loader, data);
//刷新全局缓存
CACHE = newCache;
}
}
}
//参数key = keyInterface.getName() = net.sf.cglib.proxy.Enhancer$EnhancerKey
this.key = key;
//data:ClassLoaderData
//this:KeyFactory$Generator
//getUseCache():可以通过Enhancer.setUseCache()设置
//data是AbstractClassGenerator$ClassLoaderData
//返回的是生成好的代理类的class信息
Object obj = data.get(this, getUseCache());
//如果返回的为class则实例化class并返回 就是我们需要的代理类
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);
}
}
上面创建1个ClassLoaderData,ClassLoaderData的构造方法如下：
public ClassLoaderData(ClassLoader classLoader) {
//校验类加载器
if (classLoader == null) {
throw new IllegalArgumentException("classLoader == null is not yet supported");
}
this.classLoader = new WeakReference<ClassLoader>(classLoader);
//声明1个Function,名称是load
Function<AbstractClassGenerator, Object> load =
new Function<AbstractClassGenerator, Object>() {
public Object apply(AbstractClassGenerator gen) {
Class klass = gen.generate(ClassLoaderData.this);
return gen.wrapCachedClass(klass);
}
};
//创建LoadingCache
generatedClasses = new LoadingCache<AbstractClassGenerator, Object, Object>(GET_KEY, load);
}
ClassLoaderData的load是1个Function，后面会用到。
在ClassLoaderData中创建了1个LoadingCache,入参是GET_KEY和load。
GET_KEY也是1个Function。它的作用是返回AbstractClassGenerator#create方法中创建的key,也就是net.sf.cglib.proxy.Enhancer$EnhancerKey。
private static final Function<AbstractClassGenerator, Object> GET_KEY = new Function<AbstractClassGenerator, Object>() {
public Object apply(AbstractClassGenerator gen) {
return gen.key;
}
};
LoadingCache构造方法如下:
public LoadingCache(Function<K, KK> keyMapper, Function<K, V> loader) {
this.keyMapper = keyMapper;
this.loader = loader;
//缓存
this.map = new ConcurrentHashMap();
}
继续往下看ClassLoaderData#get方法
AbstractClassGenerator.ClassLoaderData#get
//gen是KeyFactory$Generator对象
public Object get(AbstractClassGenerator gen, boolean useCache) {
//默认useCache=true
if (!useCache) {
return gen.generate(ClassLoaderData.this);
}else {
//private final LoadingCache<AbstractClassGenerator, Object, Object> generatedClasses;
//generatedClasses就是上面在ClassLoaderData构造方法中创建的LoadingCache
//LoadingCache--->get---->ClassloaderData#load返回的是1个WeakReference(klass);
//因此下面需要解压
Object cachedValue = generatedClasses.get(gen);
//解压cachedValue
// return ((WeakReference)cached).get();
return gen.unwrapCachedValue(cachedValue);
}
}
LoadingCache#get
//key是Keyfactory#create方法中创建KeyFactory$Generator对象
public V get(K key) {
//先使用第一个Function即GET_KEY 获取缓存key
//cacheKey = org.springframework.cglib.proxy.Enhancer$EnhancerKey
KK cacheKey = this.keyMapper.apply(key);
//从根据key加载缓存对象
Object v = this.map.get(cacheKey);
//如果缓存对象不为空 且 缓存的类型不是FutureTask 直接返回 缓存对象
//否则调用LoadingCache#createEntry
//意思是缓存里可能是直接创建好的对象或者是1个FutureTask?
return v != null && !(v instanceof FutureTask) ? v : this.createEntry(key, cacheKey, v);
}
LoadingCache#createEntry
protected V createEntry(final K key, KK cacheKey, Object v) {
boolean creator = false;
FutureTask task;
Object result;
if (v != null) {
task = (FutureTask)v;
} else {
//创建1个FutureTask
task = new FutureTask(new Callable<V>() {
//重写call方法
public V call() throws Exception {
//调用的是LoadingCache中的loader。
//即ClassLoaderData中的Function即load。
return LoadingCache.this.loader.apply(key);
}
});
//放入FutureTask 并返回缓存对象
result = this.map.putIfAbsent(cacheKey, task);
//如果返回的缓存对象为空 说明没有其他线程并发创建 直接执行task即可。
//注意调用的run方法,不是start方法,也就是这里会阻塞。
if (result == null) {
creator = true;
task.run();
} else {
//如果缓存对象不为空 && 不是FutureTask
//说明其他线程已经创建好了缓存对象
//直接返回缓存对象即可
if (!(result instanceof FutureTask)) {
return result;
}
//否则强转为FutureTask
task = (FutureTask)result;
}
}
try {
//获取FutureTask的执行结果
result = task.get();
} catch (InterruptedException var9) {
throw new IllegalStateException("Interrupted while loading cache item", var9);
} catch (ExecutionException var10) {
Throwable cause = var10.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException)cause;
}
throw new IllegalStateException("Unable to load cache item", cause);
}
//将FutureTask执行的结果结果放入 map
//这里解释了为什么获取到的对象可能是FutureTask也可能是已经创建好的缓存对象
if (creator) {
this.map.put(cacheKey, result);
}
return result;
}
在FutureTask#call方法中调用了ClassLoaderData#load获取到了缓存对象,所以下面重点看的就是ClassLoaderData#load。
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) {
//主要看这里
//gen是Keyfactory#create方法中创建KeyFactory$Generator对象
Class klass = gen.generate(ClassLoaderData.this);
//new WeakReference(klass);
//包装缓存Class
return gen.wrapCachedClass(klass);
}
};
generatedClasses = new LoadingCache<AbstractClassGenerator, Object, Object>(GET_KEY, load);
}
KeyFactory.Generator#generate
protected Class generate(ClassLoaderData data) {
Class gen;
Object save = CURRENT.get();
CURRENT.set(this);
try {
ClassLoader classLoader = data.getClassLoader();
if (classLoader == null) {
throw new IllegalStateException("ClassLoader is null while trying to define class " +
getClassName() + ". It seems that the loader has been expired from a weak reference somehow. " +
"Please file an issue at cglib's issue tracker.");
}
synchronized (classLoader) {
//生成代理类的className
String name = generateClassName(data.getUniqueNamePredicate());
data.reserveName(name);
this.setClassName(name);
}
if (attemptLoad) {
try {
gen = classLoader.loadClass(getClassName());
return gen;
}
catch (ClassNotFoundException e) {
// ignore
}
}
//生成字节码 strategy 一看就是策略模式 默认的策略是DefaultGeneratorStrategy
byte[] b = strategy.generate(this);
//获取到字节码代表的class名字
String className = ClassNameReader.getClassName(new ClassReader(b));
ProtectionDomain protectionDomain = getProtectionDomain();
synchronized (classLoader) {
//往内存中加载代理类class org.springframework.cglib.proxy.Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f
gen = ReflectUtils.defineClass(className, b, classLoader, protectionDomain, contextClass);
}
return gen;
}
catch (RuntimeException | Error ex) {
throw ex;
}
catch (Exception ex) {
throw new CodeGenerationException(ex);
}
finally {
CURRENT.set(save);
}
}
生成代理类的className
//参数1:org.springframework.cglib.proxy.Enhancer$EnhancerKey
//参数2:org.springframework.cglib.core.KeyFactory
//参数3:org.springframework.cglib.proxy.Enhancer$EnhancerKey
private String generateClassName(Predicate nameTestPredicate) {
return namingPolicy.getClassName(namePrefix, source.name, key, nameTestPredicate);
}
public String getClassName(String prefix, String source, Object key, Predicate names) {
if (prefix == null) {
prefix = "org.springframework.cglib.empty.Object";
} else if (prefix.startsWith("java")) {
prefix = "$" + prefix;
}
//生成规则:类前缀 + $$ + source + ByCGLIB + $$ + hashCode
//source是被哪个类创建的
//因为我们是在KeyFactory中创建的EnhanceKey 所以source 就是 KeyFactory
//后面生成的FastClass 都是在FastClass创建 所以source 就是 FastClass
String base = prefix + "$$"
+ source.substring(source.lastIndexOf(46) + 1)
+ this.getTag()
+ "$$"
+ Integer.toHexString(STRESS_HASH_CODE ? 0 : key.hashCode());
//org.springframework.cglib.proxy.Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f
String attempt = base;
for(int var7 = 2; names.evaluate(attempt); attempt = base + "_" + var7++) {
}
//返回 //org.springframework.cglib.proxy.Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f
return attempt;
}
下面开始生成字节码。
DefaultGeneratorStrategy.generate(ClassGenerator)
顺带一提DefaultGeneratorStrategy用到了饥渴加载的静态成员方式实现了单例模式。 这个单例模式不是很纯粹。因为它的构造方法使用了public修饰。 使用了public修饰主要还是为了子类的构造和初始化。
public class DefaultGeneratorStrategy implements GeneratorStrategy {
public static final DefaultGeneratorStrategy INSTANCE = new DefaultGeneratorStrategy();
public DefaultGeneratorStrategy() {
}
}
默认的策略是DefaultGeneratorStrategy,其余的策略有:
org.springframework.context.annotation.ConfigurationClassEnhancer.BeanFactoryAwareGeneratorStrategy
org.springframework.cglib.transform.impl.UndeclaredThrowableStrategy
他们都继承自DefaultGeneratorStrategy,并重写了transform方法,典型的模板模式。
public byte[] generate(ClassGenerator cg) throws Exception {
//创建一个写入器
DebuggingClassWriter cw = getClassVisitor();
//transform方法是1个模板方法
//子类可以对ClassGenerator加入自己的转换逻辑后
//再执行ClassGenerator的generateClass方法
//DefaultGeneratorStrategy#transform是直接返回ClassGenerator
transform(cg).generateClass(cw);
//将cw写入的东西转换为byte数组返回
return transform(cw.toByteArray());
}
这里面主要是新建一个写入器，然后执行我们代理类生成器的generateClass方法将class信息写入这个ClassWriter 最后将里面的东西转换为byte数组返回，所以又回到了我们的代理类生成器的generateClass方法，这儿进入的是Enhancer的generateClass方法
KeyFactory.Generator#generateClass
public void generateClass(ClassVisitor v) {
ClassEmitter ce = new ClassEmitter(v);
//获取NewInstance方法
Method newInstance = ReflectUtils.findNewInstance(keyInterface);
if (!newInstance.getReturnType().equals(Object.class)) {
throw new IllegalArgumentException("newInstance method must return Object");
}
//获取NewInstance方法的参数类型
Type[] parameterTypes = TypeUtils.getTypes(newInstance.getParameterTypes());
//创建类开始写入类头、版本号、访问权限、类名等
ce.begin_class(Constants.V1_8,
Constants.ACC_PUBLIC,
getClassName(),
KEY_FACTORY,
new Type[]{Type.getType(keyInterface)},
Constants.SOURCE_FILE);
// 写入无参构造方法
EmitUtils.null_constructor(ce);
// 写入有参构造方法
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();
// 有参构造方法中调用父类构造方法，super.xxx
e.super_invoke_constructor();
e.load_this();
// 找到传入的方法定制器，比如：hashCode方法定制器等
List<FieldTypeCustomizer> fieldTypeCustomizers = getCustomizers(FieldTypeCustomizer.class);
//遍历NewInstance方法的参数类型
for (int i = 0; i < parameterTypes.length; i++) {
Type parameterType = parameterTypes[i];
Type fieldType = parameterType;
// 遍历成员变量，也就是newInstance方法的所有参数
for (FieldTypeCustomizer customizer : fieldTypeCustomizers) {
fieldType = customizer.getOutType(i, fieldType);
}
seed += fieldType.hashCode();
// 将这些参数全部声明到写入类中
ce.declare_field(Constants.ACC_PRIVATE | Constants.ACC_FINAL,
getFieldName(i),
fieldType,
null);
e.dup();
e.load_arg(i);
for (FieldTypeCustomizer customizer : fieldTypeCustomizers) {
customizer.customize(e, i, parameterType);
}
// 设置每个成员变量的值
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[(Math.abs(seed) % PRIMES.length)];
int hm = (multiplier != 0) ? multiplier : PRIMES[(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, customizers);
}
e.return_value();
e.end_method();
// 写入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(CodeEmitter.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, customizers);
}
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, customizers);
}
e.invoke_virtual(Constants.TYPE_STRING_BUFFER, TO_STRING);
e.return_value();
e.end_method();
// 类信息已经全部写入ClassVisitor中
ce.end_class();
}
执行futureTask--->ClassloaderData#load--->KeyFactory$Generator#generate
动态生成了代理类的className以及代理类的class字节码文件,将生成的class字节码文件加载到内存中。
ClassloaderData#load最后返回的是1个WeakReference(klass);
最后代码又回到了LoadingCache#createEntry
回到LoadingCache#createEntry
protected V createEntry(final K key, KK cacheKey, Object v) {
boolean creator = false;
FutureTask task;
Object result;
if (v != null) {
task = (FutureTask)v;
} else {
task = new FutureTask(new Callable<V>() {
public V call() throws Exception {
return LoadingCache.this.loader.apply(key);
}
});
result = this.map.putIfAbsent(cacheKey, task);
if (result == null) {
creator = true;
task.run();
} else {
if (!(result instanceof FutureTask)) {
return result;
}
task = (FutureTask)result;
}
}
try {
//返回的缓存对象是WeakReference(klass)
result = task.get();
} catch (InterruptedException var9) {
throw new IllegalStateException("Interrupted while loading cache item", var9);
} catch (ExecutionException var10) {
Throwable cause = var10.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException)cause;
}
throw new IllegalStateException("Unable to load cache item", cause);
}
if (creator) {
this.map.put(cacheKey, result);
}
return result;
}
回到AbstractClassGenerator#create
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) {
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 | Error ex) {
throw ex;
}
catch (Exception ex) {
throw new CodeGenerationException(ex);
}
}
调用反射创建实例:class org.springframework.cglib.proxy.Enhancer$EnhancerKey4ce19e8f
protected Object firstInstance(Class type) {
return ReflectUtils.newInstance(type);
}
最后返回了1个代理类对象,对象的类型是EnhancerKey,至此EnhancerKey创建完成。
创建Enhancer
private static final Source SOURCE = new Source(Enhancer.class.getName());
public Enhancer() {
//还记得上面创建EnhancerKey的时候生成EnhanceKey代理类对象的className时
//用到了source
//这里就是我们生成代理类对象的source 是 Enhancer
//现在知道为什么生成的代理类对象的名称中都有$$Enhancer了吧
super(SOURCE);
}
创建Enhance总结
1.调用Keyfactory#create创建EnhancerKey
2.创建Keyfactory.Generator
3.查找缓存:ClassLoaderData#get
4.LoadingCache#get
5.LoadingCache#createEntry
6.创建并执行FutureTask
7.生成字节码,并返回对应的Class,加载至jvm内存。
8.创建实例Enhancer$EnhancerKey4ce19e8f
9.创建Enhancer,它的source属性是Enhancer。
花了大力气创建的Enhancer,主要还是为了创建EnhancerKey的代理类,EnhancerKey只是1个接口。
主要是通过Keyfactory、Keyfactory.Generator、ClassLoaderData、LoadingCache创建了Enhancer$EnhancerKey$$KeyFactoryByCGLIB。
public interface EnhancerKey {
public Object newInstance(String type,
String[] interfaces,
WeakCacheKey<CallbackFilter> filter,
Type[] callbackTypes,
boolean useFactory,
boolean interceptDuringConstruction,
Long serialVersionUID);
}
}
其实自定义一个接口类,声明一个newInstance抽象方法，cglib也是会帮我们创建1个account的代理类。但是没有newInstance抽象方法的话生成代理类会报错。
import org.springframework.asm.Type;
import org.springframework.cglib.core.WeakCacheKey;
import org.springframework.cglib.proxy.CallbackFilter;
/**
* @author: claude
* @package: cglib.Account
* @date: 2023/3/8 7:49
* @description: TODO
* @version: 1.0
*/
public interface Account {
public Object newInstance(String type,
String[] interfaces,
WeakCacheKey<CallbackFilter> filter,
Type[] callbackTypes,
boolean useFactory,
boolean interceptDuringConstruction,
Long serialVersionUID);
}
import org.springframework.cglib.core.DebuggingClassWriter;
import org.springframework.cglib.core.KeyFactory;
import org.springframework.cglib.proxy.Enhancer;
/***
* @author: claude
* @date: 2023/3/3
* @description:
*/
public class CalculatorProxyFactory {
public static void main(String[] args) {
//动态代理创建的class文件存储到本地
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "e:\\proxy");
Account account = (Account) KeyFactory.create(Account.class, KeyFactory.HASH_ASM_TYPE, null);
System.out.println(account);
}
}
也就是KeyFactory.Generator只能针对带有的newInstance抽象方法的接口做代理。
也就是说针对不同的类或者接口,cglib框架制定了对应的Generator来实现对该类或者接口的代理。
public byte[] generate(ClassGenerator cg) throws Exception {
DebuggingClassWriter cw = this.getClassVisitor();
//这里的ClassGenerator的实现类有很多。
this.transform(cg).generateClass(cw);
return this.transform(cw.toByteArray());
}
常见的ClassGenerator如下:Ehancer和FastClass.Generator都是ClassGenerator,包括KeyFactory.Generator也是ClassGenerator。
那么cglib对EnhanceKey接口创建了1个代理实现类,那么这个接口的代理类的代码是什么呢？
下面的代码是从网上找的:www.jianshu.com/p/d59754b6b…
package net.sf.cglib.proxy;
import net.sf.cglib.core.KeyFactory;
import net.sf.cglib.core.WeakCacheKey;
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 WeakCacheKey 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, WeakCacheKey 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, WeakCacheKey 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 var10002 = 19289 * 641371;
String var10001 = this.FIELD_0;
int var10000 = var10002 + (var10001 != null ? var10001.hashCode() : 0);
String[] var5 = this.FIELD_1;
if (var5 != null) {
String[] var1 = var5;
for(int var2 = 0; var2 < var1.length; ++var2) {
var10000 = var10000 * 641371 + (var1[var2] != null ? var1[var2].hashCode() : 0);
}
}
var10002 = var10000 * 641371;
WeakCacheKey var6 = this.FIELD_2;
var10000 = var10002 + (var6 != null ? var6.hashCode() : 0);
Type[] var7 = this.FIELD_3;
if (var7 != null) {
Type[] var3 = var7;
for(int var4 = 0; var4 < var3.length; ++var4) {
var10000 = var10000 * 641371 + (var3[var4] != null ? var3[var4].hashCode() : 0);
}
}
var10002 = ((var10000 * 641371 + (this.FIELD_4 ^ 1)) * 641371 + (this.FIELD_5 ^ 1)) * 641371;
Long var8 = this.FIELD_6;
return var10002 + (var8 != null ? var8.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;
if (var10001 == null) {
if (var10000 != null) {
return false;
}
} else if (var10000 == null || !var10000.equals(var10001)) {
return false;
}
String[] var8 = this.FIELD_1;
String[] var10 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_1;
if (var10 == null) {
if (var8 != null) {
return false;
}
} else {
label178: {
if (var8 != 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;
}
}
WeakCacheKey var9 = this.FIELD_2;
WeakCacheKey var13 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_2;
if (var13 == null) {
if (var9 != null) {
return false;
}
} else if (var9 == null || !var9.equals(var13)) {
return false;
}
Type[] var11 = this.FIELD_3;
Type[] var15 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_3;
if (var15 == null) {
if (var11 != null) {
return false;
}
} else {
if (var11 == null) {
return false;
}
if (var15.length != var11.length) {
return false;
}
Type[] var5 = var15;
Type[] var6 = var11;
for(int var7 = 0; var7 < var5.length; ++var7) {
Type var12 = var5[var7];
Type var16 = var6[var7];
if (var6[var7] == null) {
if (var12 != null) {
return false;
}
} else if (var12 == null || !var12.equals(var16)) {
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 var17 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$7fb24d72)var1).FIELD_6;
if (var17 == null) {
if (var14 == null) {
return true;
}
} else if (var14 != null && var14.equals(var17)) {
return true;
}
}
}
return false;
}
public String toString() {
StringBuffer var10000 = new StringBuffer();
String var10001 = this.FIELD_0;
var10000 = (var10001 != null ? var10000.append(var10001.toString()) : var10000.append("null")).append(", ");
String[] var6 = this.FIELD_1;
if (var6 != null) {
var10000 = var10000.append("{");
String[] var1 = var6;
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(", ");
WeakCacheKey var9 = this.FIELD_2;
var10000 = (var9 != null ? var10000.append(var9.toString()) : var10000.append("null")).append(", ");
Type[] var10 = this.FIELD_3;
if (var10 != null) {
var10000 = var10000.append("{");
Type[] var3 = var10;
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(", ");
Long var13 = this.FIELD_6;
return (var13 != null ? var10000.append(var13.toString()) : var10000.append("null")).toString();
}
}
思考
虽然EnhancerKey的代理创建的整个流程都走完了。
但是为什么要为EnhancerKey创建1个代理,而不是直接创建1个EnhancerKey的实现类呢？
EnhanceKey的作用是什么呢？
