入口是java.lang.reflect.Proxy#newProxyInstance
简化一下就三步:
//从缓存查找代理类,或者生成指定的代理类
Class<?> cl = getProxyClass0(loader, intfs);
//获取public构造器,如果不是public 设置为可访问
final Constructor<?> cons = cl.getConstructor(constructorParams)
//调用有参构造器创建实例
cons.newInstance(new Object[]{h})
再来看看java.lang.reflect.Proxy#getProxyClass0()这个方法,注释的意思是,如果当前classLoader已经创建了代理类,就copy一份,如果没有就创建一个。里面实际是调用了
proxyClassCache.get(loader, interfaces)
我们再来看WeakCache.get(loader, interfaces)这个方法。
//1.包装key为CacheKey
Object cacheKey = CacheKey.valueOf(key, refQueue);
// 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;
}
}
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
//2.通过SubKeyFactory创建key对象
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
//4.实际调用了内部类Factory的get()方法,创建了一个代理类
V value = supplier.get();
if (value != null) {
return value;
}
}
//.........省略了一部分
// lazily construct a Factory
//3.实例化内部类Factory
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
//..........省略...........
}
这个内部类java.lang.reflect.WeakCache.Factory#get的源码如下
// create new value
//1.关键代码:创建Value即代理类
V value = null;
try {
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
// the only path to reach here is with non-null value
assert value != null;
// wrap value with CacheValue (WeakReference)
// 2.包装value成CacheValue
CacheValue<V> cacheValue = new CacheValue<>(value);
//3. 放到reverseMap,以及替换掉旧的valuesMap中的value
reverseMap.put(cacheValue, Boolean.TRUE);
第二步valueFactory.apply(key, parameter)很重要。
在Proxy中有个方法分别创建了KeyFactory(这个就是keyFactory对象)和ProxyClassFactory(这个就是valueFactory对象)
/**
* a cache of proxy classes
*/
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
那我们就来看Proxy的内部类ProxyClassFactory.apply(key, parameter)这个方法。
//上面代码略过,是选择包名,以接口包作为包名
/*
* Choose a name for the proxy class to generate.
*/
//1.给代理类命名。包名+类名+自增数
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class.
*/
//2.生成特定的代理类字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//3.将字节码转换为对象
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
}
这三部走完就算是完成创建代理类的细节了。