当前位置： 首页 > article >正文

5.CGLIB动态代理源码之Enhancer的创建

article 2025/8/28 22:50:14

Cglib动态代理源码

在cglib动态代理中生成代理对象核心代码是下面2句。

java //创建Enhancer Enhancer enhancer = new Enhancer(); //使用Enhancer创建代理类对象 Calculator calculator = (Calculator) enhancer.create();

调用代理对象的代码是下面1句。

java //调用代理类对象的方法 calculator.add(1, 1);

首先先看Enhancer的创建。

Enhancer的创建

Enhancer的类结构

Enhancer 继承自 AbstractClassGenerator

java Enhancer extends AbstractClassGenerator

AbstractClassGenerator实现了ClassGenerator接口

java abstract public class AbstractClassGenerator<T> implements ClassGenerator

ClassGenerator只有1个方法,就是generateClass。

java public interface ClassGenerator { void generateClass(ClassVisitor var1) throws Exception; }

因为我们下面会调用enhancer#create

java Calculator calculator = (Calculator) enhancer.create();

因此可以大胆猜想这个Enhancer就是用来生成代理类的。

Enhancer属性:EnhancerKey

Enhancer初始化的时候会创建一个final的静态变量KEY_FACTORY,类型是EnhancerKey。

EnhancerKey是创建代理类的核心。

java private static final EnhancerKey KEY_FACTORY = (EnhancerKey) KeyFactory.create(EnhancerKey.class, KeyFactory.HASH_ASM_TYPE, null);

KEY_FACTORY的类型是EnhancerKey,EnhanceKey是1个接口,接口中只有1个方法newInstance。

java 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.HASHASMTYPE,KeyFactory.HASHASMTYPE是1个HashCodeCustomizer。

java 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

java //参数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); }

java //参数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方法。

java //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

```java //参数key = keyInterface.getName() = net.sf.cglib.proxy.Enhancer$EnhancerKey protected Object create(Object key) { try { //获取到生成器中的类加载器即EnhancerKey.class的类加载器 ClassLoader loader = getClassLoader(); //CACHE= new WeakHashMap (); //CACHE是当前类加载器对应的缓存,缓存key为类加载器，缓存value为ClassLoaderData
//可以将cache理解为1级缓存,ClassLoaderData是二级缓存。 Map 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 newCache = new WeakHashMap (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的构造方法如下：

```java public ClassLoaderData(ClassLoader classLoader) { //校验类加载器 if (classLoader == null) { throw new IllegalArgumentException("classLoader == null is not yet supported"); }

this.classLoader = new WeakReference<ClassLoader>(classLoader);//声明1个Function,名称是loadFunction<AbstractClassGenerator, Object> load =new Function<AbstractClassGenerator, Object>() {public Object apply(AbstractClassGenerator gen) {Class klass = gen.generate(ClassLoaderData.this);return gen.wrapCachedClass(klass);}};//创建LoadingCachegeneratedClasses = 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。

java private static final Function<AbstractClassGenerator, Object> GET_KEY = new Function<AbstractClassGenerator, Object>() { public Object apply(AbstractClassGenerator gen) { return gen.key; } };

LoadingCache构造方法如下:

java 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

java //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

java //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

```java 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 () { //重写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。

java 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

```java 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$$4ce19e8fgen = 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

java //参数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); }

```java 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 就是 FastClassString 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$$4ce19e8fString attempt = base;for(int var7 = 2; names.evaluate(attempt); attempt = base + "_" + var7++) {}//返回 //org.springframework.cglib.proxy.Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8freturn attempt;
}

```

下面开始生成字节码。

DefaultGeneratorStrategy.generate(ClassGenerator)

顺带一提DefaultGeneratorStrategy用到了饥渴加载的静态成员方式实现了单例模式。 这个单例模式不是很纯粹。因为它的构造方法使用了public修饰。 使用了public修饰主要还是为了子类的构造和初始化。 ```java 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方法,典型的模板模式。

java 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

```java 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.beginclass(Constants.V18, Constants.ACCPUBLIC, getClassName(), KEYFACTORY, new Type[]{Type.getType(keyInterface)}, Constants.SOURCEFILE); // 写入无参构造方法 EmitUtils.nullconstructor(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

```java 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 () { 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

java 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$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f

java protected Object firstInstance(Class type) { return ReflectUtils.newInstance(type); }

最后返回了1个代理类对象,对象的类型是EnhancerKey,至此EnhancerKey创建完成。

创建Enhancer

java private static final Source SOURCE = new Source(Enhancer.class.getName());

java 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$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f

9.创建Enhancer,它的source属性是Enhancer。

花了大力气创建的Enhancer,主要还是为了创建EnhancerKey的代理类,EnhancerKey只是1个接口。

主要是通过Keyfactory、Keyfactory.Generator、ClassLoaderData、LoadingCache创建了Enhancer$EnhancerKey$$KeyFactoryByCGLIB。

java 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抽象方法的话生成代理类会报错。

```java 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 filter, Type[] callbackTypes, boolean useFactory, boolean interceptDuringConstruction, Long serialVersionUID); }

```

```java 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来实现对该类或者接口的代理。

java 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。 image.png

那么cglib对EnhanceKey接口创建了1个代理实现类,那么这个接口的代理类的代码是什么呢？

下面的代码是从网上找的:https://www.jianshu.com/p/d59754b6bf24

```java 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 FIELD0; private final String[] FIELD1; private final WeakCacheKey FIELD2; private final Type[] FIELD3; private final boolean FIELD4; private final boolean FIELD5; 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的作用是什么呢？

http://www.lryc.cn/news/2417008.html

相关文章：

  • Cluster概念详解
  • XSD 初学 (三)
  • 电脑技巧：盘点10个非常实用且有趣的网站
  • 盘点世界上著名的游戏公司
  • 重复文件清理绿色工具——DoubleKiller
  • 图的应用【最短路径】 —— Floyd 算法
  • System类中setProperty()和getProperty()方法
  • 在 Ubuntu 20.04 上安装 GCC
  • VS的调试技巧（非常重要哦！！）
  • 【UAA】从部署到接口调用
  • Android上使用tombstone定位问题的示例
  • Longhorn，企业级云原生容器分布式存储 - 定制默认设置
  • 关于Https中的headers的理解
  • 数据备份与数据容灾全解析
  • C# 读写ini文件
  • SSH服务远程访问及控制
  • ij工具的基础操作
  • DecimalFormat用法
  • GCC下载地址(linux/windows\安装)或从minGW中取得gcc
  • JSF 原理简要介绍
  • 802.11ac/ax (wifi6)中的Beamforming技术介绍
  • ERP系统之sap入门操作--sap的基本的了解入门
  • 港片怀旧：《鹰爪铁布衫》(1)
  • Linux环境如何下载文件
  • VRP基础
  • DNS是什么，有什么用（详细介绍版）
  • 【数模】多元线性回归分析
  • 单片机和sbit和sfr
  • 常用软件过程——RUP
  • TreeSet的使用方法总结、实现原理、使用示例