97-Proxy
- 通过代理Obj访问目标Obj，可以在目标Obj基础上增强额外功能
- eg：添加权限、访问控制、审计等
1. StaticProxy
- 代理类与被代理类需要实现同一个接口。一个静态代理类只能代理一个类，还要事先知道要代理哪个类才能写代理类
- 实际开发中，可能非常多的类需要被代理，并且事先并不知道这些类。静态代理反而会增加工作量，效率低下，代码复用率不好
public class StaticProxy {
@Test
public void proxy() {
Person person = new Person("张三");
Court court = new Lawyer(person);
court.doCourt();
}
}
// ----------------------------------------------------------------- 接口
interface Court {
void doCourt();
}
// ----------------------------------------------------------------- 代理类
class Lawyer implements Court {
private Court c;
public Lawyer(Court c) {
this.c = c;
}
@Override
public void doCourt() {
System.out.println("律师取证：视频证明张三当时正在旅游，不在案发现场");
c.doCourt();
System.out.println("律师总结：张三不可能去杀人");
}
}
// ----------------------------------------------------------------- 被代理类
class Person implements Court {
private String name;
public Person(String name) {
this.name = name;
}
@Override
public void doCourt() {
System.out.println(name + "说：我没有杀人");
}
}
2. DynamicProxy
- 动态生成
.class文件 - 代理类在程序运行时才创建，动态生成的代理类的模式。可以在程序运行时动态的变化代理规则
proxy（包）
1. WeakCache
WeakCache（class_copy）
ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>>包含两级缓存
- 一级：
cacheKey => valuesMapConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>>
- 二级：
ConcurrentMap<Object, Supplier<V>>subKey => Factorysubkey => CacheValue
/**
* 1. 生成的代理类占用内存较大，key(弱引用，GC时会被回收)失效时, 可以被及时处理
* expungeStaleEntries()处理key失效时，清除掉对应的value的方法，在get, containsValue, size被调用时调用
* 2. 简而言之，为了能随取随用，但是不影响GC，毕竟内存很宝贵
*/
public class WeakCache<K, P, V> {
// 弱引用被回收时，被添加队列
private final ReferenceQueue<K> refQueue = new ReferenceQueue<>();
// 1. the key type is Object for supporting null key
private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map = new ConcurrentHashMap<>();
// 保存value，方便获取缓存的size
private final ConcurrentMap<Supplier<V>, Boolean> reverseMap = new ConcurrentHashMap<>();
private final BiFunction<K, P, ?> subKeyFactory;
private final BiFunction<K, P, V> valueFactory;
public WeakCache(BiFunction<K, P, ?> subKeyFactory, BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
this.valueFactory = Objects.requireNonNull(valueFactory);
}
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
// 清理掉被GC的缓存
expungeStaleEntries();
// 1. 一级缓存key（弱引用）
Object cacheKey = CacheKey.valueOf(key, refQueue);
// 1.1. 二级缓存获取及初始化
// lazily install the 2nd level valuesMap for the particular cacheKey
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// 2. 二级缓存key（强引用）
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
// 一个轮询，直到拿到不为null的supplier且supplier.get()不为null为止
while (true) {
if (supplier != null) {
// 1st，supplier == Factory
// 2nd，supplier == CacheValue<V>实例了，从缓存中获取
// supplier might be a Factory or a CacheValue<V> instance
// 2.2. 二级缓存value执行。(Factory, CacheValue)
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) {
// 2.1. 二级缓存value初始化
factory = new Factory(key, parameter, subKey, valuesMap);
}
// other_thread1提前
if (supplier == null) {
// other_thread2提前
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) { // other_thread2
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
} else { // other_thread2提前
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);
}
}
}
}
private void expungeStaleEntries() {
CacheKey<K> cacheKey;
while ((cacheKey = (CacheKey<K>) refQueue.poll()) != null) {
cacheKey.expungeFrom(map, reverseMap);
}
}
// ---------------------------------------------------------------------------------
private static final class CacheKey<K> extends WeakReference<K> {
// a replacement for null keys
private static final Object NULL_KEY = new Object();
static <K> Object valueOf(K key, ReferenceQueue<K> refQueue) {
return key == null
// null key means we can't weakly reference it,
// so we use a NULL_KEY singleton as cache key
? NULL_KEY
// non-null key requires wrapping with a WeakReference
: new CacheKey<>(key, refQueue);
}
private final int hash;
private CacheKey(K key, ReferenceQueue<K> refQueue) {
super(key, refQueue);
this.hash = System.identityHashCode(key); // compare by identity
}
}
private static final class CacheValue<V> extends WeakReference<V> implements Value<V> {
private final int hash;
CacheValue(V value) {
super(value);
this.hash = System.identityHashCode(value); // compare by identity
}
}
// ---------------------------------------------------------------------------------
private final class Factory implements Supplier<V> {
private final K key;
private final P parameter;
private final Object subKey;
private final ConcurrentMap<Object, Supplier<V>> valuesMap;
Factory(K key, P parameter, Object subKey, ConcurrentMap<Object, Supplier<V>> valuesMap) {
this.key = key;
this.parameter = parameter;
this.subKey = subKey;
this.valuesMap = valuesMap;
}
@Override
public synchronized V get() { // serialize access
// re-check
Supplier<V> supplier = valuesMap.get(subKey);
if (supplier != this) {
return null;
}
// create new value
V value = null;
try {
// 1. valueFactory生成value
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
// wrap value with CacheValue (WeakReference)
// 2. value封装为CacheValue
CacheValue<V> cacheValue = new CacheValue<>(value);
// put into reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);
// try replacing us with CacheValue (this should always succeed)
if (!valuesMap.replace(subKey, this, cacheValue)) {
throw new AssertionError("Should not reach here");
}
// successfully replaced us with new CacheValue -> return the value
// wrapped by it
return value;
}
}
}
2. jdk
- 面向接口的动态代理
- 代理类和被代理类实现同一接口
- 代理对象增强的是重写接口的方法
- 代理对象只能转换成接口，不能转换成被代理类
- 代理对象只能读取到接口中方法上的注解，不能读取到实现类方法上的注解
public interface Calculator {
int add(int i, int j);
int sub(int i, int j);
int mult(int i, int j);
int div(int i, int j);
}
public class MyCalc implements Calculator {
public int add(int i, int j) {
System.out.println("i + j = " + i + j);
return i + j;
}
public int sub(int i, int j) {
return i - j;
}
public int mult(int i, int j) {
return i * j;
}
public int div(int i, int j) {
return i / j;
}
}
public class T19_JdkProxy {
/**
* 必须为main()，saveGeneratedFiles才会生效
*/
public static void main(String[] args) {
// .class文件生成到本地`com.listao.spring.proxy`
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", true);
MyCalc myCalc = new MyCalc();
// 1. ClassLoader
ClassLoader loader = myCalc.getClass().getClassLoader();
// 2. interfaces
Class<?>[] interfaces = myCalc.getClass().getInterfaces();
// 3. InvocationHandler
InvocationHandler h = new InvocationHandler() {
/**
* @param proxy 代理对象
* @param method 被代理方法
* @param args 被代理入参
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try {
System.out.println("====>>>>");
result = method.invoke(myCalc, args);
System.out.println("====<<<<");
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
};
// 4. debug => 下面断点停了，再Proxy.newProxyInstance()断点
Calculator proxy = (Calculator) Proxy.newProxyInstance(loader, interfaces, h);
proxy.add(1, 1);
System.out.println(proxy.getClass());
}
}
====>>>>
i + j = 11
====<<<<
class com.sun.proxy.$Proxy0
1. Proxy
getProxyClass0()创建代理类cons.newInstance(new Object[]{h});有参构造创建代理对象，并传入InvocationHandler
public class Proxy implements java.io.Serializable {
// 0. 初始化WeakCache
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
/**
* the invocation handler for this proxy instance.
* @serial
*/
protected InvocationHandler h;
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h;
}
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h) {
final Class<?>[] intfs = interfaces.clone();
// 1..
Class<?> cl = getProxyClass0(loader, intfs); // ...
final Constructor<?> cons = cl.getConstructor(constructorParams); // ...
// 2. InvocationHandler设置
return cons.newInstance(new Object[]{h});
}
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
// 1... 调用WeakCache
return proxyClassCache.get(loader, interfaces);
}
// Key工厂
private static final class KeyFactory implements BiFunction<ClassLoader, Class<?>[], Object> {
@Override
public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
switch (interfaces.length) {
case 1: return new Key1(interfaces[0]); // the most frequent
case 2: return new Key2(interfaces[0], interfaces[1]);
case 0: return key0;
default: return new KeyX(interfaces);
}
}
}
// ProxyClass工厂
private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";
// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
Class<?> interfaceClass = null;
try {
// 1. 反射接口Class
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* Verify that this interface is not a duplicate.
*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
// 2. 代理类包的路径处理，public可以任意路径
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
// 3. 接口处理。public
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
// 4. com.sun.proxy.
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* 5... Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
try {
// 6. 生成的类加载到内存
return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
}
}
2. ProxyGenerator
Source code does not match the bytecode，字节码和idea反编译行不匹配
public class ProxyGenerator {
private ProxyGenerator(String var1, Class<?>[] var2, int var3) {
this.className = var1;
this.interfaces = var2;
this.accessFlags = var3;
}
/**
* @param var0 proxyName
* @param var1 interfaces
* @param var2 accessFlags
*/
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
// 1..
final byte[] var4 = var3.generateClassFile();
// 2. $Proxy0文件输出
if (saveGeneratedFiles) {
// ......
Files.write(var2, var4, new OpenOption[0]);
// ......
}
return var4;
}
private byte[] generateClassFile() {
// 1. Object方法
this.addProxyMethod(hashCodeMethod, Object.class);
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
// 2. 接口方法分离出来
Class[] var1 = this.interfaces;
int var2 = var1.length;
int var3;
Class var4;
for(var3 = 0; var3 < var2; ++var3) {
var4 = var1[var3];
Method[] var5 = var4.getMethods();
int var6 = var5.length;
for(int var7 = 0; var7 < var6; ++var7) {
Method var8 = var5[var7];
this.addProxyMethod(var8, var4);
}
}
Iterator var11 = this.proxyMethods.values().iterator();
// 3. 返回值处理
List var12;
while(var11.hasNext()) {
var12 = (List)var11.next();
checkReturnTypes(var12);
}
Iterator var15;
try {
// 4. 代理对象构造器处理。有参，参数为InvocationHandler
this.methods.add(this.generateConstructor());
var11 = this.proxyMethods.values().iterator();
while(var11.hasNext()) {
var12 = (List)var11.next();
var15 = var12.iterator();
while(var15.hasNext()) {
ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
this.methods.add(var16.generateMethod());
}
}
// 5. static{}处理
this.methods.add(this.generateStaticInitializer());
} catch (IOException var10) {
throw new InternalError("unexpected I/O Exception", var10);
}
// ......
return var13.toByteArray();
}
}
3. $Proxy0
// 先debug到这里
Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
// 增加debug，进入到方法里
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
}
InvocationHandler h = new InvocationHandler() {
/**
* @param proxy 代理对象
* @param method 被代理方法
* @param args 被代理入参
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try {
System.out.println("====>>>>");
result = method.invoke(myCalc, args);
System.out.println("====<<<<");
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
};
public final class $Proxy0 extends Proxy implements Calculator {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m6;
private static Method m5;
private static Method m4;
private static Method m0;
// 99. InvocationHandler设置
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final int add(int var1, int var2) throws {
try {
return (Integer)super.h.invoke(this, m3, new Object[]{var1, var2});
} catch (RuntimeException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.listao.proxy.jdk.Calculator").getMethod("add", Integer.TYPE, Integer.TYPE);
m6 = Class.forName("com.listao.proxy.jdk.Calculator").getMethod("sub", Integer.TYPE, Integer.TYPE);
m5 = Class.forName("com.listao.proxy.jdk.Calculator").getMethod("mult", Integer.TYPE, Integer.TYPE);
m4 = Class.forName("com.listao.proxy.jdk.Calculator").getMethod("div", Integer.TYPE, Integer.TYPE);
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
3. cglib
- CGLib（Code Generation Library）是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口
- CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类
- 除了CGLIB包，脚本语言eg：Groovy、BeanShell，也是使用ASM来生成java的字节码。不鼓励直接使用ASM，因为它要求必须对JVM内部结构包括class文件的格式和指令集都很熟悉
- debug到
Enhancer enhancer = new Enhancer();
- 面向父类的动态代理
- 代理类
extents被代理类，为其子类 - ⼯作原理：Cglib会根据设置的Superclass，⽣成代理类作为其⼦类，并且会重写Superclass的⽅法。eg：
eat()，相应的在代理类中会对应两个⽅法- ⼀个是重写的
eat()，⽤来执⾏增强逻辑 - ⼀个是
CGLIB$eat$0()，会直接调⽤super.test()，是让MethodProxy对象来使用的
- ⼀个是重写的
1. Callback
- 详解Java的回调机制
- 同步调用、异步调用、回调
/**
* 1. caller（调用者）实现ICallback（回调接口）
* 2. 调用callee（被调者）时将caller_ref传入
* 3. callee处理完逻辑，通过caller_ref回调caller
*/
public class Callback {
public static void main(String[] args) {
Callee callee = new Callee();
new Caller().ooxx(callee);
}
}
// ------------------------------------------------------------
class Caller implements ICallback {
public void ooxx(Callee callee) {
// 1.
callee.go(this);
}
@Override
public void callback() {
// 3.
System.out.println("Caller.callback() ===>>> 业务处理完毕");
}
}
// ------------------------------------------------------------
interface ICallback {
void callback();
}
// ------------------------------------------------------------
class Callee {
void go(ICallback callback) {
System.out.println("Callee.go() ===>>> 处理业务逻辑...");
// 2.
callback.callback();
}
}
2. KeyFactory
- 父类静态初始化 => 构造方法
- 子类静态初始化 => 构造方法
public class DefaultGeneratorStrategy implements GeneratorStrategy {
public byte[] generate(ClassGenerator cg) throws Exception {
DebuggingClassWriter cw = this.getClassVisitor();
// 1. 生成.class文件
this.transform(cg).generateClass(cw);
// 2. class文件本地输出
return this.transform(cw.toByteArray());
}
}
1. 生成class文件
KeyFactory$Generator#generateClass()
2. class文件本地输出
DebuggingClassWriter#toByteArray()
3. enhancer.create()
Enhancer#generateClass()
4. 生成.class
- 2. createProxyClassAndInstance
- 无法debug进入源码，进入.class文件时。删除build
public class T19_CglibProxy {
public static void main(String[] args) {
// 动态代理class文件存储到本地
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/listao/mca/spring/proxy_cglib");
// 1. debug，EnhancerKey对象提前创建，动态代理生成
Enhancer enhancer = new Enhancer();
// 代理对象父类
enhancer.setSuperclass(MyCalc.class);
// 2. 获取MethodInterceptor对象，用于定义增强规则
MethodInterceptor myInterceptor = new MethodInterceptor() {
/*
* @param o 代理对象
* @param method 被代理方法对象
* @param objects 实参数组
* @param methodProxy 被代理方法的代理对象
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("==>> MyCglib.intercept() ---- before()");
// 2.1. invokeSuper(代理对象, 实参)
Object obj = methodProxy.invokeSuper(o, objects);
// 2.2. invoke(被代理对象, 实参)
MyCalc myCalc = new MyCalc();
obj = methodProxy.invoke(myCalc, objects);
// 2.3. method.invoke(被代理对象, 实参)
obj = method.invoke(myCalc, objects);
// 报错，只能传代理对象（ClassCastException）
// com.listao.spring.proxy.CglibProxy$Person cannot be cast to com.listao.spring.proxy.CglibProxy$Person$$EnhancerByCGLIB$$62149e73
// obj = methodProxy.invokeSuper(myCalc, objects);
// 代理对象，eat()。循环调用栈溢出（StackOverflowError）
// obj = methodProxy.invoke(o, objects);
System.out.println("==>> MyCglib.intercept() ---- after()");
return obj;
}
};
// 代理对象回调对象
enhancer.setCallback(myInterceptor);
// 3. debug，创建代理对象
MyCalc myCalc = (MyCalc) enhancer.create();
// 通过代理对象调用目标方法
myCalc.add(1, 1);
System.out.println(myCalc.getClass());
}
}
1. ACG.create()
1. Enhancer
public class Enhancer extends AbstractClassGenerator {
private Class superclass;
private Callback[] callbacks;
// KeyFactory创建出对应Class代理类
// KeyFactory_HASH_ASM_TYPE => 代理类中创建HashCode()的策略
private static final EnhancerKey KEY_FACTORY =
(EnhancerKey) KeyFactory.create(EnhancerKey.class, KeyFactory.HASH_ASM_TYPE, null);
/**
* Internal interface, only public due to ClassLoader issues.
*/
public interface EnhancerKey {
public Object newInstance(String type,
String[] interfaces,
WeakCacheKey<CallbackFilter> filter,
Type[] callbackTypes,
boolean useFactory,
boolean interceptDuringConstruction,
Long serialVersionUID);
}
// ------------------------------------------------------------------
public Object create() {
classOnly = false;
argumentTypes = null;
return createHelper();
}
public Class createClass() {
classOnly = true;
return (Class) createHelper();
}
private Object createHelper() {
// 1.. 处理callbackTypes, filter
preValidate();
// 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;
// 2... AbstractClassGenerator ACG核心创建
Object result = super.create(key);
return result;
}
private void preValidate() {
if (callbackTypes == null) {
// 1. 确定传入的callback类型
callbackTypes = CallbackInfo.determineTypes(callbacks, false);
validateCallbackTypes = true;
}
if (filter == null) {
if (callbackTypes.length > 1) {
throw new IllegalStateException("Multiple callback types possible but no filter specified");
}
filter = ALL_ZERO;
}
}
// **核心生成bytecode**
public void generateClass(ClassVisitor v) throws Exception {
// 声明被代理的类或者接口
Class sc = (superclass == null) ? Object.class : superclass;
// 检查final类无法被继承
if (TypeUtils.isFinal(sc.getModifiers()))
throw new IllegalArgumentException("Cannot subclass final class " + sc.getName());
// 找到该类所有声明了的构造函数
List constructors = new ArrayList(Arrays.asList(sc.getDeclaredConstructors()));
// 去掉private之类的不能被继承的构造函数
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();
// 声明所有必须为public的方法集合，主要是代理接口接口的方法
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);
}
});
// 1. 创建类写入器。开始创建类，并写入基本信息 eg：java版本、类修饰符、类名
ClassEmitter e = new ClassEmitter(v);
if (currentData == null) {
e.begin_class(Constants.V1_8,
Constants.ACC_PUBLIC,
getClassName(),
Type.getType(sc),
(useFactory ?
TypeUtils.add(TypeUtils.getTypes(interfaces), FACTORY) :
TypeUtils.getTypes(interfaces)),
Constants.SOURCE_FILE);
} else {
e.begin_class(Constants.V1_8,
Constants.ACC_PUBLIC,
getClassName(),
null,
new Type[]{FACTORY},
Constants.SOURCE_FILE);
}
List constructorInfo = CollectionUtils.transform(constructors, MethodInfoTransformer.getInstance());
// 2. 声明一个private boolean 类型的属性：CGLIB$BOUND
e.declare_field(Constants.ACC_PRIVATE, BOUND_FIELD, Type.BOOLEAN_TYPE, null);
// 3. 声明一个public static Object 类型的属性：CGLIB$FACTORY_DATA
e.declare_field(Constants.ACC_PUBLIC | Constants.ACC_STATIC, FACTORY_DATA_FIELD, OBJECT_TYPE, null);
// 默认为true，false则会声明一个private boolean 类型的属性：CGLIB$CONSTRUCTED
if (!interceptDuringConstruction) {
e.declare_field(Constants.ACC_PRIVATE, CONSTRUCTED_FIELD, Type.BOOLEAN_TYPE, null);
}
// 4. 声明一个public static final 的ThreadLocal：ThreadLocal
e.declare_field(Constants.PRIVATE_FINAL_STATIC, THREAD_CALLBACKS_FIELD, THREAD_LOCAL, null);
// 5. 声明一个public static final 的CallBack类型的数组：CGLIB$STATIC_CALLBACKS
e.declare_field(Constants.PRIVATE_FINAL_STATIC, STATIC_CALLBACKS_FIELD, CALLBACK_ARRAY, null);
// serialVersionUID不为null，则设置一个public static final 的Long类型 serialVersionUID
if (serialVersionUID != null) {
e.declare_field(Constants.PRIVATE_FINAL_STATIC, Constants.SUID_FIELD_NAME, Type.LONG_TYPE, serialVersionUID);
}
// 遍历CallBackTypes，即构建Enhancer是setCallBack的所有类的类型
for (int i = 0; i < callbackTypes.length; i++) {
// 6. 声明一个private的传入的CallBack类型的属性：CGLIB$CALLBACK_0（从0开始编号）
e.declare_field(Constants.ACC_PRIVATE, getCallbackField(i), callbackTypes[i], null);
}
// This is declared private to avoid "public field" pollution
// 7. 声明一个private static 的传入的Object类型的属性：CGLIB$CALLBACK_FILTER
e.declare_field(Constants.ACC_PRIVATE | Constants.ACC_STATIC, CALLBACK_FILTER_FIELD, OBJECT_TYPE, null);
if (currentData == null) {
// 8. 为null声明所有的代理类方法的变量，以及其具体的重写实现方法，还有static初始化执行代码块
emitMethods(e, methods, actualMethods);
// 9. 声明构造函数
emitConstructors(e, constructorInfo);
} else {
// 声明默认构造函数
emitDefaultConstructor(e);
}
emitSetThreadCallbacks(e);
emitSetStaticCallbacks(e);
emitBindCallbacks(e);
if (useFactory || currentData != null) {
int[] keys = getCallbackKeys();
// 10. 声明三个newInstance方法，只有一个callback参数
emitNewInstanceCallbacks(e);
// 参数为callback数组
emitNewInstanceCallback(e);
// 参数为callback数组，以及附带的一些参数
emitNewInstanceMultiarg(e, constructorInfo);
// 11. 声明getCallBack方法
emitGetCallback(e, keys);
// 12.1. 声明setCallBack方法
emitSetCallback(e, keys);
// 12.2. 声明setCallBack方法
emitGetCallbacks(e);
// 12.3. 声明setCallBack方法
emitSetCallbacks(e);
}
e.end_class();
}
public void setCallback(Callback callback) {
this.setCallbacks(new Callback[]{callback});
}
public void setCallbacks(Callback[] callbacks) {
if (callbacks != null && callbacks.length == 0) {
throw new IllegalArgumentException("Array cannot be empty");
} else {
this.callbacks = callbacks;
}
}
public void setSuperclass(Class superclass) {
if (superclass != null && superclass.isInterface()) {
setInterfaces(new Class[]{superclass});
// SPRING PATCH BEGIN
setContextClass(superclass);
// SPRING PATCH END
} else if (superclass != null && superclass.equals(Object.class)) {
// affects choice of ClassLoader
this.superclass = null;
} else {
this.superclass = superclass;
// SPRING PATCH BEGIN
setContextClass(superclass);
// SPRING PATCH END
}
}
// ----------------------------------------------------------------------------
@Override
protected Object wrapCachedClass(Class klass) {
Class[] argumentTypes = this.argumentTypes;
if (argumentTypes == null) {
argumentTypes = Constants.EMPTY_CLASS_ARRAY;
}
// 1... EnhancerFactoryData
EnhancerFactoryData factoryData = new EnhancerFactoryData(klass, argumentTypes, classOnly);
Field factoryDataField = null;
try {
// The subsequent dance is performed just once for each class,
// so it does not matter much how fast it goes
factoryDataField = klass.getField(FACTORY_DATA_FIELD);
factoryDataField.set(null, factoryData);
Field callbackFilterField = klass.getDeclaredField(CALLBACK_FILTER_FIELD);
callbackFilterField.setAccessible(true);
callbackFilterField.set(null, this.filter);
} catch (NoSuchFieldException e) {
throw new CodeGenerationException(e);
} catch (IllegalAccessException e) {
throw new CodeGenerationException(e);
}
// 2.
return new WeakReference<EnhancerFactoryData>(factoryData);
}
@Override
protected Object unwrapCachedValue(Object cached) {
if (currentKey instanceof EnhancerKey) {
EnhancerFactoryData data = ((WeakReference<EnhancerFactoryData>) cached).get();
return data;
}
// 1... ACG
return super.unwrapCachedValue(cached);
}
// ----------------------------------------------------------------------------
protected Object firstInstance(Class type) throws Exception {
if (classOnly) {
return type;
} else {
// 1..
return createUsingReflection(type);
}
}
private Object createUsingReflection(Class type) {
setThreadCallbacks(type, callbacks);
try {
if (argumentTypes != null) {
return ReflectUtils.newInstance(type, argumentTypes, arguments);
} else {
// 1.
return ReflectUtils.newInstance(type);
}
} finally {
// clear thread callbacks to allow them to be gc'd
setThreadCallbacks(type, null);
}
}
// ------------------------------------------------------------------
static class EnhancerFactoryData {
public final Class generatedClass;
private final Method setThreadCallbacks;
private final Class[] primaryConstructorArgTypes;
private final Constructor primaryConstructor;
// proxy信息存储
public EnhancerFactoryData(Class generatedClass, Class[] primaryConstructorArgTypes, boolean classOnly) {
// 1. clazz信息
this.generatedClass = generatedClass;
try {
setThreadCallbacks = getCallbacksSetter(generatedClass, SET_THREAD_CALLBACKS_NAME);
if (classOnly) {
this.primaryConstructorArgTypes = null;
this.primaryConstructor = null;
}
// 2. proxy构造方法
else {
this.primaryConstructorArgTypes = primaryConstructorArgTypes;
this.primaryConstructor = ReflectUtils.getConstructor(generatedClass, primaryConstructorArgTypes);
}
} catch (NoSuchMethodException e) {
throw new CodeGenerationException(e);
}
}
public Object newInstance(Class[] argumentTypes, Object[] arguments, Callback[] callbacks) {
// 1. 设置Callbacks
setThreadCallbacks(callbacks);
try {
// Explicit reference equality is added here just in case Arrays.equals does not have one
if (primaryConstructorArgTypes == argumentTypes ||
Arrays.equals(primaryConstructorArgTypes, argumentTypes)) {
// If we have relevant Constructor instance at hand, just call it
// This skips "get constructors" machinery
// 2. 反射proxy创建
return ReflectUtils.newInstance(primaryConstructor, arguments);
}
// 3. Take a slow path if observing unexpected argument types
return ReflectUtils.newInstance(generatedClass, argumentTypes, arguments);
} finally {
// clear thread callbacks to allow them to be gc'd
setThreadCallbacks(null);
}
}
private void setThreadCallbacks(Callback[] callbacks) {
try {
// 1.
setThreadCallbacks.invoke(generatedClass, (Object) callbacks);
} catch (IllegalAccessException e) {
throw new CodeGenerationException(e);
} catch (InvocationTargetException e) {
throw new CodeGenerationException(e.getTargetException());
}
}
}
}
2. KeyFactory
- 这个代理类主要用来作为被代理类的标识，在进行缓存时作为判断相等的依据
abstract public class KeyFactory {
public static KeyFactory create(Class keyInterface, KeyFactoryCustomizer first, List<KeyFactoryCustomizer> next) {
return create(keyInterface.getClassLoader(), keyInterface, first, next);
}
// keyInterface.getClassLoader(), EnhancerKey.class, KeyFactory.HASH_ASM_TYPE, null
public static KeyFactory create(ClassLoader loader, Class keyInterface, KeyFactoryCustomizer customizer,
List<KeyFactoryCustomizer> next) {
// 1. 代理类生成器，即只会生成HashCode(), equals(), toString(), newInstance()
Generator gen = new Generator();
// 设置接口为enhancerKey类型
gen.setInterface(keyInterface);
// SPRING PATCH BEGIN
gen.setContextClass(keyInterface);
// SPRING PATCH END
if (customizer != null) {
// 添加定制器
gen.addCustomizer(customizer);
}
if (next != null && !next.isEmpty()) {
for (KeyFactoryCustomizer keyFactoryCustomizer : next) {
// 添加定制器
gen.addCustomizer(keyFactoryCustomizer);
}
}
// 设置生成器的类加载器
gen.setClassLoader(loader);
// 2... KeyFactory$Generator 核心创建
return gen.create();
}
public static class Generator extends AbstractClassGenerator {
public KeyFactory create() {
// org.springframework.cglib.proxy.Enhancer$EnhancerKey
// 设置了该生成器生成代理类的名字前缀
setNamePrefix(keyInterface.getName());
// 1... ACG
return (KeyFactory) super.create(keyInterface.getName());
}
// **核心生成bytecode**
public void generateClass(ClassVisitor v) {
// 创建类写入聚合对象
ClassEmitter ce = new ClassEmitter(v);
// 找到被代理类的newInstance()，如果没有会报异常。用Generator代理类生成器，必须要有newInstance()
Method newInstance = ReflectUtils.findNewInstance(keyInterface);
// 被代理类的newInstance()不为Object则报异常，此处代理的Enhancer.EnhancerKey的newInstance()返回值为Object
if (!newInstance.getReturnType().equals(Object.class)) {
throw new IllegalArgumentException("newInstance method must return Object");
}
// 找到newInstance方法的所有参数类型并当做成员变量
Type[] parameterTypes = TypeUtils.getTypes(newInstance.getParameterTypes());
// 1. 创建类开始写入类头、版本号、访问权限、类名等通用信息
ce.begin_class(Constants.V1_8,
Constants.ACC_PUBLIC,
getClassName(),
KEY_FACTORY,
new Type[]{Type.getType(keyInterface)},
Constants.SOURCE_FILE);
// 2. 写入无参构造
EmitUtils.null_constructor(ce);
// 3. 写入newInstance()
EmitUtils.factory_method(ce, ReflectUtils.getSignature(newInstance));
int seed = 0;
// 4. 开始构造有参构造
CodeEmitter e = ce.begin_method(Constants.ACC_PUBLIC,
TypeUtils.parseConstructor(parameterTypes),
null);
e.load_this();
// 4.1. 有参构造中调用父类构造方法。即super()
e.super_invoke_constructor();
e.load_this();
// 4.2. 找到传入的定制器，例如一开始传入的hashCode方法定制器
List<FieldTypeCustomizer> fieldTypeCustomizers = getCustomizers(FieldTypeCustomizer.class);
// 4.3. 遍历成员变量即newInstance方法的所有参数
for (int i = 0; i < parameterTypes.length; i++) {
Type parameterType = parameterTypes[i];
Type fieldType = parameterType;
for (FieldTypeCustomizer customizer : fieldTypeCustomizers) {
fieldType = customizer.getOutType(i, fieldType);
}
seed += fieldType.hashCode();
// 4.4. 将这些参数全部声明到写入类中
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);
}
// 4.5. 设置每个成员变量的值，即我们常见的有参构造中的this.xx = xx
e.putfield(getFieldName(i));
}
// 设置返回值
e.return_value();
e.end_method();
// hash code
// 5. 写入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
// 6. 写入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
// 7.写入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();
}
// -----------------------------------------------------------------
protected Object firstInstance(Class type) {
return ReflectUtils.newInstance(type);
}
protected Object nextInstance(Object instance) {
return instance;
}
}
}
- 实现的
Enhancer.EnhancerKey代理，即实现newInstance()，重写HashCode(), toSting(), equals()，并将newInstance的所有参数作为了成员变量 - 具体实现
newInstance()的逻辑，即代码EmitUtils.factory_method(ce, ReflectUtils.getSignature(newInstance));。可以去研究asm字节码写入操作
public class EmitUtils {
private static final Signature CSTRUCT_NULL = TypeUtils.parseConstructor("");
private static final Signature CSTRUCT_THROWABLE = TypeUtils.parseConstructor("Throwable");
private static final Signature GET_NAME = TypeUtils.parseSignature("String getName()");
private static final Signature HASH_CODE = TypeUtils.parseSignature("int hashCode()");
private static final Signature EQUALS = TypeUtils.parseSignature("boolean equals(Object)");
private static final Signature STRING_LENGTH = TypeUtils.parseSignature("int length()");
private static final Signature STRING_CHAR_AT = TypeUtils.parseSignature("char charAt(int)");
private static final Signature FOR_NAME = TypeUtils.parseSignature("Class forName(String)");
private static final Signature DOUBLE_TO_LONG_BITS = TypeUtils.parseSignature("long doubleToLongBits(double)");
private static final Signature FLOAT_TO_INT_BITS = TypeUtils.parseSignature("int floatToIntBits(float)");
private static final Signature TO_STRING = TypeUtils.parseSignature("String toString()");
private static final Signature APPEND_STRING = TypeUtils.parseSignature("StringBuffer append(String)");
private static final Signature APPEND_INT = TypeUtils.parseSignature("StringBuffer append(int)");
private static final Signature APPEND_DOUBLE = TypeUtils.parseSignature("StringBuffer append(double)");
private static final Signature APPEND_FLOAT = TypeUtils.parseSignature("StringBuffer append(float)");
private static final Signature APPEND_CHAR = TypeUtils.parseSignature("StringBuffer append(char)");
private static final Signature APPEND_LONG = TypeUtils.parseSignature("StringBuffer append(long)");
private static final Signature APPEND_BOOLEAN = TypeUtils.parseSignature("StringBuffer append(boolean)");
private static final Signature LENGTH = TypeUtils.parseSignature("int length()");
private static final Signature SET_LENGTH = TypeUtils.parseSignature("void setLength(int)");
private static final Signature GET_DECLARED_METHOD = TypeUtils.parseSignature("java.lang.reflect.Method getDeclaredMethod(String, Class[])");
public static final ArrayDelimiters DEFAULT_DELIMITERS = new ArrayDelimiters("{", ", ", "}");
public static void factory_method(ClassEmitter ce, Signature sig) {
CodeEmitter e = ce.begin_method(1, sig, (Type[])null);
// 写入一个创建对象命令，即new命令
e.new_instance_this();
e.dup();
// 加载参数命令
e.load_args();
// 执行该类的有参构造命令
e.invoke_constructor_this(TypeUtils.parseConstructor(sig.getArgumentTypes()));
// 将上面指令执行的值返回
e.return_value();
e.end_method();
}
}
2. ACG
create() => ClassLoaderData.get() => ACG.generate() => DefaultGeneratorStrategy.generate() => <? extends ACG>generateClass()
abstract public class AbstractClassGenerator<T> implements ClassGenerator {
private Object key;
private ClassLoader classLoader;
// new DefaultGeneratorStrategy();
private GeneratorStrategy strategy = DefaultGeneratorStrategy.INSTANCE;
// 核心缓存
private static volatile Map<ClassLoader, ClassLoaderData> CACHE = new WeakHashMap<>();
protected Object create(Object key) {
try {
// AppClassLoader
ClassLoader loader = getClassLoader();
// 1. cache处理
Map<ClassLoader, ClassLoaderData> cache = CACHE;
// 当前classLoader所加载过的类
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<>(cache);
// 2...
data = new ClassLoaderData(loader);
newCache.put(loader, data);
CACHE = newCache;
}
}
}
// 设置一个全局key
this.key = key;
// 3... AbstractClassGenerator$ClassLoaderData 核心处理
// 是否使用缓存的标识穿进去，系统参数`System.getProperty("cglib.useCache", "true")`
Object obj = data.get(this, getUseCache());
if (obj instanceof Class) {
// 4... Enhancer 反射创建
return firstInstance((Class) obj);
}
// 5.. => Enhancer$EnhancerFactoryData反射创建
return nextInstance(obj);
} catch (RuntimeException | Error ex) {
throw ex;
} catch (Exception ex) {
throw new CodeGenerationException(ex);
}
}
protected Object unwrapCachedValue(T cached) {
// 1.
return ((WeakReference) cached).get();
}
protected Object nextInstance(Object instance) {
EnhancerFactoryData data = (EnhancerFactoryData) instance;
if (classOnly) {
return data.generatedClass;
}
Class[] argumentTypes = this.argumentTypes;
Object[] arguments = this.arguments;
if (argumentTypes == null) {
argumentTypes = Constants.EMPTY_CLASS_ARRAY;
arguments = null;
}
// 1... Enhancer$EnhancerFactoryData
return data.newInstance(argumentTypes, arguments, callbacks);
}
// ----------------------------------------------------------------------------------------
protected static class ClassLoaderData {
private final WeakReference<ClassLoader> classLoader;
private final LoadingCache<AbstractClassGenerator, Object, Object> generatedClasses;
// 生成key的Function
private static final Function<AbstractClassGenerator, Object> GET_KEY =
new Function<AbstractClassGenerator, Object>() {
public Object apply(AbstractClassGenerator gen) {
return gen.key;
}
};
public ClassLoaderData(ClassLoader classLoader) {
// 类加载器（弱引用）
this.classLoader = new WeakReference<ClassLoader>(classLoader);
// 生成代理类Function
Function<AbstractClassGenerator, Object> load =
new Function<AbstractClassGenerator, Object>() {
public Object apply(AbstractClassGenerator gen) {
// 1.. 和不用缓存一样的逻辑
Class klass = gen.generate(ClassLoaderData.this);
// 2... Enhancer
return gen.wrapCachedClass(klass);
}
};
// LoadingCache<ACG, K, V>
generatedClasses = new LoadingCache<AbstractClassGenerator, Object, Object>(GET_KEY, load);
}
public Object get(AbstractClassGenerator gen, boolean useCache) {
// 1. 不用缓存
if (!useCache) {
// 2.. 直接调用ACG（父类）
return gen.generate(ClassLoaderData.this);
}
// 3. 缓存（默认）
else {
// 4... LoadingCache
Object cachedValue = generatedClasses.get(gen);
return gen.unwrapCachedValue(cachedValue);
}
}
}
// ----------------------------------------------------------------------------------------
protected Class generate(ClassLoaderData data) {
Class gen;
Object save = CURRENT.get();
// 当前的代理类生成器存入ThreadLocal中
CURRENT.set(this);
try {
// 1. 获取到ClassLoader
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) {
// 2. 代理类名字，org.springframework.cglib.proxy.Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f
String name = generateClassName(data.getUniqueNamePredicate());
// 缓存中存入这个名字
data.reserveName(name);
// 当前代理类生成器设置类名
this.setClassName(name);
}
// 尝试从缓存中获取类
if (attemptLoad) {
try {
// 要是能获取到就直接返回了
gen = classLoader.loadClass(getClassName());
return gen;
} catch (ClassNotFoundException e) {
// ignore
}
}
// 3... DefaultGeneratorStrategy 生成字节码
byte[] b = strategy.generate(this);
// 4. 字节码的className
String className = ClassNameReader.getClassName(new ClassReader(b));
ProtectionDomain protectionDomain = getProtectionDomain();
synchronized (classLoader) { // just in case
// SPRING PATCH BEGIN
// 5. 反射创建代理类的Class对象
gen = ReflectUtils.defineClass(className, b, classLoader, protectionDomain, contextClass);
// SPRING PATCH END
}
return gen;
} catch (RuntimeException | Error ex) {
throw ex;
} catch (Exception ex) {
throw new CodeGenerationException(ex);
} finally {
CURRENT.set(save);
}
}
}
3. DefaultGeneratorStrategy
public class DefaultGeneratorStrategy implements GeneratorStrategy {
public static final DefaultGeneratorStrategy INSTANCE = new DefaultGeneratorStrategy();
protected DebuggingClassWriter getClassVisitor() throws Exception {
return new DebuggingClassWriter(2);
}
public byte[] generate(ClassGenerator cg) throws Exception {
DebuggingClassWriter cw = this.getClassVisitor();
// 1... Enhancer 生成.class文件 => Enhancer.generateClass(), KeyFactory.generateClass()
this.transform(cg).generateClass(cw);
// 2. class文件本地输出
return this.transform(cw.toByteArray());
}
protected ClassGenerator transform(ClassGenerator cg) throws Exception {
return cg;
}
}
5. LoadingCache
- Cglib中LoadingCache源码分析
- 这个类不能放到idea，类型转换异常
- 主要作用是传入代理类生成器，根据代理类生成器以及代理类生成器的key来获取缓存
- 如果没有获取到，则构建一个
FutureTask来回调之前初始化时传入的回调函数，并调用apply()，而具体调用的则是传入的代理类生成器的generate(LoadClassData)，将返回值覆盖FutureTask成为真正的缓存
- 如果没有获取到，则构建一个
/*
* 防止缓存击穿
* 并发下。同一个key同一时间只有一个FutureTask去调用loader.apply(key)，其他thread等待结果
*/
public class LoadingCache<K, KK, V> {
protected final ConcurrentMap<KK, Object> map;
protected final Function<K, KK> keyMapper;
protected final Function<K, V> loader;
// 1.
public LoadingCache(Function<K, KK> keyMapper, Function<K, V> loader) {
this.keyMapper = keyMapper;
this.loader = loader;
this.map = new ConcurrentHashMap<>();
}
// 2.
public V get(K key) throws ExecutionException, InterruptedException {
KK cacheKey = this.keyMapper.apply(key);
Object v = this.map.get(cacheKey);
return v != null && !(v instanceof FutureTask) ? v : this.createEntry(key, cacheKey, v);
}
protected V createEntry(final K key, KK cacheKey, Object v) throws ExecutionException, InterruptedException {
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 {
// 3.1. 调用Function
return LoadingCache.this.loader.apply(key);
}
});
result = this.map.putIfAbsent(cacheKey, task);
if (result == null) {
creator = true;
// 3.2. thread启动
task.run();
} else {
if (!(result instanceof FutureTask)) {
return result;
}
task = (FutureTask) result;
}
}
// 3.3. 阻塞thread，等待结果
result = task.get();
if (creator) {
this.map.put(cacheKey, result);
}
return result;
}
}
6. MyCalc$$EnhancerByCGLIB
- 构造方法
static{}- 重写Superclass中的
add()，进行增强 CGLIB$add$0()调用父类super.add()
public class MyCalc$$EnhancerByCGLIB$$f736e7ee extends MyCalc implements Factory {
private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
private static final Callback[] CGLIB$STATIC_CALLBACKS;
private MethodInterceptor CGLIB$CALLBACK_0; // MyInterceptor
private static final Method CGLIB$add$0$Method;
private static final MethodProxy CGLIB$add$0$Proxy;
static {
CGLIB$STATICHOOK1();
}
static void CGLIB$STATICHOOK1() {
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$emptyArgs = new Object[0];
// 1. 代理类
Class var0 = Class.forName("com.listao.proxy.cglib.MyCalc$$EnhancerByCGLIB$$f736e7ee");
// 2. 被代理类
Class var1;
Method[] var10000 = ReflectUtils.findMethods(new String[]{
"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[]{
"add", "(II)I",
"div", "(II)I",
"mult", "(II)I",
"sub", "(II)I"},
(var1 = Class.forName("com.listao.proxy.cglib.MyCalc")).getDeclaredMethods());
// 3. 被代理方法
CGLIB$add$3$Method = var10000[0];
// 4... MethodProxy **代理方法**
CGLIB$add$3$Proxy = MethodProxy.create(var1, var0, "(II)I", "add", "CGLIB$add$3");
CGLIB$sub$0$Method = var10000[0];
CGLIB$sub$0$Proxy = MethodProxy.create(var1, var0, "(II)I", "sub", "CGLIB$sub$0");
CGLIB$mult$1$Method = var10000[1];
CGLIB$mult$1$Proxy = MethodProxy.create(var1, var0, "(II)I", "mult", "CGLIB$mult$1");
CGLIB$div$2$Method = var10000[2];
CGLIB$div$2$Proxy = MethodProxy.create(var1, var0, "(II)I", "div", "CGLIB$div$2");
}
public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
// 1. MyInterceptor
CGLIB$THREAD_CALLBACKS.set(var0);
}
public MyCalc$$EnhancerByCGLIB$$f736e7ee() {
// 1.. 初始化代理对象
CGLIB$BIND_CALLBACKS(this);
}
private static final void CGLIB$BIND_CALLBACKS(Object var0) {
MyCalc$$EnhancerByCGLIB$$f736e7ee var1 = (MyCalc$$EnhancerByCGLIB$$f736e7ee)var0;
if (!var1.CGLIB$BOUND) {
var1.CGLIB$BOUND = true;
// 1. ThreadLocal => MyInterceptor
Object var10000 = CGLIB$THREAD_CALLBACKS.get();
if (var10000 == null) {
var10000 = CGLIB$STATIC_CALLBACKS;
if (var10000 == null) {
return;
}
}
// 2. Callback设置 => MyInterceptor（var1 == this）
var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
}
}
final int CGLIB$add$3(int var1, int var2) {
return super.add(var1, var2);
}
public final int add(int var1, int var2) {
// 1.
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
// 2... MyInterceptor
Object var3 = var10000.intercept(
this, // 2.1. 代理对象
CGLIB$add$3$Method, // 2.2. 被代理方法
new Object[]{new Integer(var1), new Integer(var2)}, // 2.3. 实参
CGLIB$add$3$Proxy); // 2.4. methodProxy
return var3 == null ? 0 : ((Number)var3).intValue();
} else {
return super.add(var1, var2);
}
}
}
1. MethodProxy
public class Signature {
private String name;
private String desc;
}
public class MethodProxy {
private Signature sig1;
private Signature sig2;
private CreateInfo createInfo;
private volatile FastClassInfo fastClassInfo;
/**
* 代理方法
* @param c1 被代理类 => MyCalc
* @param c2 代理类 => MyCalc$$EnhancerByCGLIB$$f736e7ee
* @param desc desc => (II)I
* @param name1 被代理methodName => "add"
* @param name2 代理methodName => "CGLIB$add$0"
*/
public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
MethodProxy proxy = new MethodProxy();
proxy.sig1 = new Signature(name1, desc);
proxy.sig2 = new Signature(name2, desc);
// 1.
proxy.createInfo = new CreateInfo(c1, c2);
return proxy;
}
// ------------------------------------------------------------------------------
private static class CreateInfo {
Class c1; // MyCalc
Class c2; // MyCalc$$EnhancerByCGLIB$$f736e7ee
NamingPolicy namingPolicy;
GeneratorStrategy strategy;
boolean attemptLoad;
public CreateInfo(Class c1, Class c2) {
this.c1 = c1;
this.c2 = c2;
AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent();
if (fromEnhancer != null) {
namingPolicy = fromEnhancer.getNamingPolicy();
strategy = fromEnhancer.getStrategy();
attemptLoad = fromEnhancer.getAttemptLoad();
}
}
}
// ------------------------------------------------------------------------------
public Object invoke(Object obj, Object[] args) throws Throwable {
init();
FastClassInfo fci = fastClassInfo;
// fci.f1 => MyCalc$$FastClassByCGLIB$$c1d14bc9
// fci.i1 => add(II)I_index
return fci.f1.invoke(fci.i1, obj, args);
}
/**
* @param obj 代理对象
* @param args 实参
*/
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
// 1..
init();
FastClassInfo fci = fastClassInfo;
// 2... fci.f2 => MyCalc$$EnhancerByCGLIB$$f736e7ee$$FastClassByCGLIB$$3d4f71a3
// fci.i2 => 2
return fci.f2.invoke(fci.i2, obj, args);
}
private void init() {
if (fastClassInfo == null) {
synchronized (initLock) {
if (fastClassInfo == null) {
CreateInfo ci = createInfo;
// 1.
FastClassInfo fci = new FastClassInfo();
// 2.. MyCalc => MyCalc$$FastClassByCGLIB$$c1d14bc9
fci.f1 = helper(ci, ci.c1);
// MyCalc$$FastClassByCGLIB$$c1d14bc9 => MyCalc$$EnhancerByCGLIB$$f736e7ee$$FastClassByCGLIB$$3d4f71a3
fci.f2 = helper(ci, ci.c2);
// 3... FastClass
fci.i1 = fci.f1.getIndex(sig1); // add(II)I => 3
fci.i2 = fci.f2.getIndex(sig2); // CGLIB$add$3(II)I => 14
fastClassInfo = fci;
createInfo = null;
}
}
}
}
// ------------------------------------------------------------------------------
private static class FastClassInfo {
FastClass f1;
FastClass f2;
int i1;
int i2;
}
// ------------------------------------------------------------------------------
// 返回被代理类、代理类的FastClass
private static FastClass helper(CreateInfo ci, Class type) {
// 1... FastClass.Generator
FastClass.Generator g = new FastClass.Generator();
g.setType(type);
// SPRING PATCH BEGIN
g.setContextClass(type);
// SPRING PATCH END
g.setClassLoader(ci.c2.getClassLoader());
g.setNamingPolicy(ci.namingPolicy);
g.setStrategy(ci.strategy);
g.setAttemptLoad(ci.attemptLoad);
// 2... FastClass.Generator
return g.create();
}
}
2. FastClass
- FastClass机制：预先把类中的所有⽅法做⼀个索引。提⾼⽅法的执⾏速度
- 调⽤
MethodProxy对象的invoke()或invokeSuper()，⾸先应该要做到的就是找到对应的Method对象- 执⾏
invoke()，找到eat()对应的Method对象 - 执⾏
invokeSuper()，找到CGLIB$eat$1对应的Method对象，然后利⽤反射来执⾏Method
- 执⾏
public abstract class FastClass {
private Class type;
public static class Generator extends AbstractClassGenerator {
private static final AbstractClassGenerator.Source SOURCE = new AbstractClassGenerator.Source(FastClass.class.getName());
private Class type;
public Generator() {
super(SOURCE);
}
public void setType(Class type) {
this.type = type;
}
public FastClass create() {
this.setNamePrefix(this.type.getName());
return (FastClass)super.create(this.type.getName());
}
protected ClassLoader getDefaultClassLoader() {
return this.type.getClassLoader();
}
protected ProtectionDomain getProtectionDomain() {
return ReflectUtils.getProtectionDomain(this.type);
}
public void generateClass(ClassVisitor v) throws Exception {
new FastClassEmitter(v, this.getClassName(), this.type);
}
protected Object firstInstance(Class type) {
return ReflectUtils.newInstance(type, new Class[]{Class.class}, new Object[]{this.type});
}
protected Object nextInstance(Object instance) {
return instance;
}
}
}
1. 被代理对象
public class MyCalc$$FastClassByCGLIB$$c1d14bc9 extends FastClass {
public MyCalc$$FastClassByCGLIB$$c1d14bc9(Class var1) {
super(var1);
}
public int getIndex(Signature var1) {
String var10000 = var1.toString();
switch (var10000.hashCode()) {
case -2131682232:
if (var10000.equals("sub(II)I")) {
return 0;
}
break;
case -1287932281:
if (var10000.equals("add(II)I")) { // .
return 3;
}
break;
case -1267343528:
if (var10000.equals("mult(II)I")) {
return 1;
}
break;
case 303407255:
if (var10000.equals("div(II)I")) {
return 2;
}
break;
case 1826985398:
if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
return 4;
}
break;
case 1913648695:
if (var10000.equals("toString()Ljava/lang/String;")) {
return 5;
}
break;
case 1984935277:
if (var10000.equals("hashCode()I")) {
return 6;
}
}
return -1;
}
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
MyCalc var10000 = (MyCalc)var2;
int var10001 = var1;
try {
switch (var10001) {
case 0:
return new Integer(var10000.sub(((Number)var3[0]).intValue(), ((Number)var3[1]).intValue()));
case 1:
return new Integer(var10000.mult(((Number)var3[0]).intValue(), ((Number)var3[1]).intValue()));
case 2:
return new Integer(var10000.div(((Number)var3[0]).intValue(), ((Number)var3[1]).intValue()));
case 3: // .
return new Integer(var10000.add(((Number)var3[0]).intValue(), ((Number)var3[1]).intValue()));
case 4:
return new Boolean(var10000.equals(var3[0]));
case 5:
return var10000.toString();
case 6:
return new Integer(var10000.hashCode());
}
} catch (Throwable var4) {
throw new InvocationTargetException(var4);
}
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
}
2. 代理对象
public class MyCalc$$EnhancerByCGLIB$$f736e7ee$$FastClassByCGLIB$$3d4f71a3 extends FastClass {
public MyCalc$$EnhancerByCGLIB$$f736e7ee$$FastClassByCGLIB$$3d4f71a3(Class var1) {
super(var1);
}
public int getIndex(Signature var1) {
String var10000 = var1.toString();
switch(var10000.hashCode()) {
// ...
case -1287932281:
if (var10000.equals("add(II)I")) {
return 19;
}
break;
// ...
case -898354021:
if (var10000.equals("CGLIB$add$3(II)I")) {
return 14;
}
break;
// ...
return -1;
}
/**
* @param var1: index
* @param var2: 代理对象
* @param var3: 实参
*/
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
f736e7ee var10000 = (f736e7ee)var2;
int var10001 = var1;
switch(var10001) {
case 19:
return new Integer(var10000.add(((Number)var3[0]).intValue(), ((Number)var3[1]).intValue()));
// ...
// MyCalc$$EnhancerByCGLIB$$f736e7ee$$FastClassByCGLIB$$3d4f71a3.CGLIB$add$0( ... )
case 14:
return new Integer(var10000.CGLIB$add$3(((Number)var3[0]).intValue(), ((Number)var3[1]).intValue()));
// ...
}
}
}