1. Java中的引用类型
在介绍JDK动态代理之前，先对Java中的4种引用类型和WeakCache类进行介绍。JDK1.2之后，定义了4种强度的引用，分别是强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)、虚引用(Phantom Reference)：
- 强引用
强引用是最普遍的引用，我们用new关键字创建的对象都是被强引用，即使内存不足时，GC(垃圾收集器)也不会回收该对象，而会抛出OutOfMemoryError异常。 - 软引用
软引用的强度仅次于强引用，对应Java中的SoftReference类。当JVM内存不足时，GC会回收那些被软引用的对象，若回收后内存仍然不足，才会抛出OutOfMemoryError异常。 - 引用队列
假设在创建SoftReference对象时，为其关联了一个引用队列，当SoftReference中所引用的对象被GC回收时，JVM会将该SoftReference对象添加到与之关联的引用队列中。程序中可从该引用队列中取出被GC回收的对象，并做后续的操作。软引用、弱引用、虚引用都可以关联引用队列。引用队列对应Java中的ReferenceQueue类。 - 弱引用
弱引用强度低于软引用，对应Java中的WeakReference类。被弱引用的对象的生命周期是两次GC之间这段时间。 - 虚引用
虚引用是最弱的一种类型，对应Java中的PhantomReference类。在创建虚引用时，必须为其关联一个引用队列。虚引用用于替代finilize()方法，该方法的作用是在一个对象真正被回收前，执行一些清理工作，但该方法存在很多问题，因此已经废弃。
Java提供了get()方法来判断对象是否被回收。在引用的对象还未被GC回收之前，调用SoftReference或WeakReference的get()方法会返回被引用的对象，否则返回null，而PhantomReference始终返回null。
2. WeakCache
WeakCache是生成的代理类的缓存。该缓存中有key、sub-key两种键来唯一确定一个缓存项，JDK动态代理中key的类型是CacheKey、sub-key的类型有多种 (因此需要动态生成)，这些类型是Proxy类的内部类，根据传进来的接口数不同，分为Proxy.Key1(一个接口)、Proxy.Key2(两个接口)、Proxy.KeyX(超过两个接口)。之所以存在key、sub-key，是因为简单数据类型，如String，无法唯一确定一个缓存项。下面对WeakCache中JDK动态代理相关的部分进行介绍，WeakCache中的字段如下：
/**
* 引用队列，该队列会传入后面介绍的继承了WeakReference的WeakCache.CacheKey类、
* WeakCache.WeakReference类等的构造器，最终会初始化Reference类的queue字段，
* 该队列由JVM维护，将已经被GC的对象加入该队列中
*/
private final ReferenceQueue refQueue = new ReferenceQueue<>();
/**
* 以JDK动态代理为例，该map会形成这样的泛型类型:>
*/
private final ConcurrentMap>> map = new ConcurrentHashMap<>();
/**
* 1.以JDK动态代理为例，该reverseMap会形成这样的泛型类型:
* 2.其中，reverseMap的Proxy.CacheValue对象与map的Proxy.CacheValue对象是同一个，reverseMap的Boolean对象
* 是被public static final修饰的，也就是说reverseMap的每个Proxy.CacheValue对象都指向同一个Boolean对象
* 3. 这个Boolean对象并未使用，这样做的原因可能是需要用ConcurrentHashMap这个并发类
* 4. containsValue(V value)方法中会判断reverseMap中是否有value(即是否有value这个代理类)
*/
private final ConcurrentMap, Boolean> reverseMap = new ConcurrentHashMap<>();
/**
* 以JDK动态代理为例subKeyFactory会被初始化为Proxy.KeyFactory，用于生成subKey的工厂
*/
private final BiFunction subKeyFactory;
/**
* 以JDK动态代理为例subKeyFactory会被初始化为Proxy.ProxyClassFactory，用于生成代理类的工厂
*/
private final BiFunction valueFactory;
/**
* CacheKey是WeakCache的内部类，以该类来了解一下弱引用的使用方法:
* 1. 继承了WeakReference(WeakReference继承了Reference)
* 2. 在构造方法中传入被弱引用的对象(key)、引用队列(即refQueue)
* key和refQueue最终会初始化Reference中对应的字段，此后key
* 的生命周期由JVM维护。
* 举个例子：
* 当不再有强引用指向key时，则key可以被回收。当key被回收后，key所对应的CacheKey对象会被放在引用队列中，供后续使用。
*/
private static final class CacheKey extends WeakReference {
// 每个弱引用对象key对应一个CacheKey对象
private CacheKey(K key, ReferenceQueue refQueue) {
super(key, refQueue); // 指向key的引用是弱引用，且关联了引用队列
this.hash = System.identityHashCode(key); // this.hash是强引用
}
/**
* CacheKey的equals方法中会调用CacheKey.get方法，实际调的是WeakReference.get，若返回null，
* 则表示被弱引用的对象(构造方法中的key)已经被GC，否则返回CacheKey对象
*/
// 其他方法、字段(略)
}
// CacheValue是WeakCache的内部类
// 注意实现了Value，Value实现了Supplier
private static final class CacheValue
extends WeakReference implements Value
{
CacheValue(V value) {
// 指向value的引用是弱引用，未关联了引用队列
// CacheKey中需要关联引用队列是因为需要用被回收的CacheKey删除map中的过期条目
// value被回收后直接删除即可
super(value);
this.hash = System.identityHashCode(value); // compare by identity
}
// equals方法中的CacheValue.get与CacheKey.equals中类似
// 其他方法、字段(略)
}
3. JDK动态代理的具体过程
1. Proxy.newProxyInstance是创建代理对象的入口，下面从该方法开始对过程中的方法链依次进行分析：
public static Object newProxyInstance(ClassLoader loader,
Class[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// h为null则抛异常
Objects.requireNonNull(h);
final Class[] intfs = interfaces.clone();
// 权限检查(略)
// 查找(可能有缓存)或生成指定的代理类
Class cl = getProxyClass0(loader, intfs);
// try/catch(略)
// 权限检查(略)
final Constructor cons = cl.getConstructor(constructorParams);
// 若cons不是public则通过cons.setAccessible(true)跳过权限检查(略)
// 创建对象，h是代理类构造器的参数
return cons.newInstance(new Object[]{h});
}
2. Proxy.getProxyClass0
// 用WeakCache作为代理类的缓存
private static final WeakCache[], Class>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
private static Class getProxyClass0(ClassLoader loader,
Class... interfaces) {
// 接口数不得超过65535个
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 先从缓存中获取代理类，没有则创建
return proxyClassCache.get(loader, interfaces);
}
3. WeakCache.get
// 注意：由于考虑了多线程，因此方法里会做各种看似没有必要的判断
public V get(K key, P parameter) {
// parameter为null则抛异常
Objects.requireNonNull(parameter);
// 删除引用队列中的过期条目
expungeStaleEntries();
// valueOf中会新建一个CacheKey
Object cacheKey = CacheKey.valueOf(key, refQueue);
// 注意：方法里会调用cacheKey.equals进行比较
ConcurrentMap> valuesMap = map.get(cacheKey);
if (valuesMap == null) { // 没缓存时，valueMap为null
// 若不存在，则添加，返回null，否则直接返回已存在的值
ConcurrentMap> oldValuesMap =
map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
// 单线程下oldValuesMap肯定为null，多线程可能不为null
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// 用Proxy.KeyFactory根据parameter(即interfaces)生成相应的subKey(这里key仅是一个占位符)
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {
if (supplier != null) {
// supplier可能为Factory或CacheValue：
// 1. 为Proxy.Factory时，会在其get方法中用ProxyClassFactory生成代理类的Class对象，
// 并将该Class对象封装成CacheValue，形成弱引用，交JVM负责(多线程下，该方法可能返回null)，最后返回代理类的Class对象
// 2. 为CacheValue时，其get方法(实际调用的是Reference.get)可能返回null，表示该缓存值已经被回收，否则返回缓存的代理类的Class对象
V value = supplier.get();
if (value != null) { // 两种情况下都可能返回null，因此这里再进行判断
return value; // 代理类的Class对象
}
}
// 到这里说明上面supplier为null或两种情况都返回null，因此这里新建工厂，用于循环到上面创建代理类的Class对象
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
// 由于多线程，因此再判断
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) { // 多线程，再判断
supplier = factory;
}
} else { // 到这里说明supplier(supplier是共享的)被其他线程赋值
// 若成功将factory替换为supplier(并添加到valuesMap中)则返回true
if (valuesMap.replace(subKey, supplier, factory)) {
supplier = factory; // 用上面创建的工厂
} else {
// 重试
supplier = valuesMap.get(subKey);
}
}
}
}
4. WeakCache.Factory.get
// 注意实现了Supplier
private final class Factory implements Supplier {
@Override
public synchronized V get() { // 同步方法
Supplier supplier = valuesMap.get(subKey);
if (supplier != this) { // 多线程，需再判断
return null;
}
V value = null;
try {
// 用Proxy.ProxyClassFactory创建代理类的Class对象
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) {
valuesMap.remove(subKey, this);
}
}
// 将value封装成CacheValue形成弱引用，由JVM负责回收
CacheValue cacheValue = new CacheValue<>(value);
// 用生成的cacheValue替换this，并添加到valuesMap中(这里replace应该总是返回true)
if (valuesMap.replace(subKey, this, cacheValue)) {
// 添加到reverseMap中
reverseMap.put(cacheValue, Boolean.TRUE);
} else {
throw new AssertionError("Should not reach here");
}
// 返回代理类Class对象
return value;
}
// 其他方法、字段(略)
}
5. Proxy.ProxyClassFactory.apply
private static final class ProxyClassFactory
implements BiFunction[], Class>
{
// 代理类类名的前缀
private static final String proxyClassNamePrefix = "$Proxy";
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class apply(ClassLoader loader, Class[] interfaces) {
// 普通Map集合判断两个键是否相等用：(k1==null ? k2==null : k1.equals(k2))
// IdentityHashMap判断两个键是否相等用：k1==k2
Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
//遍历interfaces，对每个接口进行下面3步验证
for (Class intf : interfaces) {
// 1. 验证loader根据接口名生成的接口的Class对象是否与intf相等
Class interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
// 2. 验证interfaceClass是否是接口
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
// 3. 验证是否存在多个相同的接口
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
// 代理类包名
String proxyPkg = null;
// 初始化代理类的访问标志
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
// 遍历interfaces，只要有接口没有被public修饰，就将代理类的public去掉，
// 并用这个非pulic接口的包名作为代理类的包名
for (Class intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) { // intf是否有public修饰符
accessFlags = Modifier.FINAL; // 去掉代理类的public
// 下面用这个非pulic接口的包名作为代理类的包名
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)) { // 多个非public接口必须在同一个包下
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
// proxyPkg为null说明不存在非public的接口
if (proxyPkg == null) {
// 此时用 "com.sun.proxy." 做代理类的包名
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
// 拼接完整的代理类名称
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
// 生成指定的代理类字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
// 生成代理类的Class对象
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
// ...
throw new IllegalArgumentException(e.toString());
}
}
}
6. ProxyGenerator.generateProxyClass
public static byte[] generateProxyClass(final String name,
Class[] interfaces,
int accessFlags)
{
ProxyGenerator gen = new ProxyGenerator(name, interfaces, accessFlags);
// 生成字节码
final byte[] classFile = gen.generateClassFile();
// 在主函数设置System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
// 这里会在项目根目录下生成该Class文件(即代理类的.class文件)
if (saveGeneratedFiles) {
// 输出Class文件到磁盘(略)
}
return classFile;
}
7. ProxyGenerator.generateClassFile
private byte[] generateClassFile() {
// 添加继承自Object的代理方法
addProxyMethod(hashCodeMethod, Object.class);
addProxyMethod(equalsMethod, Object.class);
addProxyMethod(toStringMethod, Object.class);
// 遍历interfaces，添加所有接口中的方法
for (Class intf : interfaces) {
for (Method m : intf.getMethods()) {
addProxyMethod(m, intf);
}
}
// 验证相同签名的方法的返回值类型是否符合规范
// Java语言层面一个方法签名仅对应一个ProxyMethod
for (List sigmethods : proxyMethods.values()) {
checkReturnTypes(sigmethods);
}
// step 2: 下面会将代理类中所有字段、方法组装成FieldInfo和FieldInfo并添加到methods和fields中
// FieldInfo和FieldInfo分别对应字节码文件中的字段表和方法表
try {
// 为代理类生成构造方法
methods.add(generateConstructor());
// 遍历proxyMethods中的所有ProxyMethod
for (List sigmethods : proxyMethods.values()) {
for (ProxyMethod pm : sigmethods) {
// add static field for method's Method object
// 代理类中会生成名为m0、m1...的字段
// 这里生成这些字段对应的FieldInfo并添加到fields
// 字段访问标志和类型为 private static Method
fields.add(new FieldInfo(pm.methodFieldName,
"Ljava/lang/reflect/Method;",
ACC_PRIVATE | ACC_STATIC));
// generate code for proxy method and add it
// 为代理类生成MethodInfo并添加到methods中
methods.add(pm.generateMethod());
}
}
// 为代理类生成类构造器，用于初始化静态字段，静态代码段等
methods.add(generateStaticInitializer());
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception", e);
}
// 方法数和字段数不能超过65535个
if (methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
}
if (fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
}
// step3 : 将所有数据拼接成完整的字节码文件
// 将代理类、父类、以及实现的所有接口的名称添加到常量池中并建立索引
cp.getClass(dotToSlash(className));
cp.getClass(superclassName);
for (Class intf: interfaces) {
cp.getClass(dotToSlash(intf.getName()));
}
// 下面要将常量池的内容进行输出，这里将常量池设置为只读
cp.setReadOnly();
// ByteArrayOutputStream中有一个字节数组，下面会将所有数据写入该字节数组中
// DataOutputStream对输出Java的基本数据类型进行了封装，字节码的无符号数的大小有 u1(一字节)、u2、u4、u8，正好对应
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
try {
// 将所有数据都写入ByteArrayOutputStream的字节数组中来构建完整的字节码
dout.writeInt(0xCAFEBABE); // 魔数(Class文件的标志)
dout.writeShort(CLASSFILE_MINOR_VERSION); // 次版本号
dout.writeShort(CLASSFILE_MAJOR_VERSION); // 主版本号
cp.write(dout); // 常量池
dout.writeShort(accessFlags); // 代理类的访问标志
dout.writeShort(cp.getClass(dotToSlash(className))); // 代理类类名
dout.writeShort(cp.getClass(superclassName)); // 父类类名
dout.writeShort(interfaces.length); // 接口个数
for (Class intf : interfaces) { // 所有接口的名称
dout.writeShort(cp.getClass(
dotToSlash(intf.getName())));
}
dout.writeShort(fields.size()); // 字段个数
for (FieldInfo f : fields) { // 所有字段
f.write(dout);
}
dout.writeShort(methods.size()); // 方法个数
for (MethodInfo m : methods) { // 所有方法
m.write(dout);
}
dout.writeShort(0); // 属性个数
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception", e);
}
return bout.toByteArray(); // 将输出的整个Class文件转化为字节数组并返回
}
8. ProxyGenerator.addProxyMethod
private void addProxyMethod(Method m, Class fromClass) {
String name = m.getName(); // 获取方法名称
Class[] parameterTypes = m.getParameterTypes(); // 获取参数类型(可能有多个)
Class returnType = m.getReturnType(); // 获取返回值类型
Class[] exceptionTypes = m.getExceptionTypes(); // 获取异常类型
// 获取方法签名(由方法名和参数的类型及顺序确定)
// getParameterDescriptors中会按照指定格式进行参数的拼接
String sig = name + getParameterDescriptors(parameterTypes);
// Java语言中，同一接口中不同方法的方法名和返回值类型必须不同时相同
// 这里考虑方法名和返回值同时相同时，方法的返回值类型、抛出的异常不同的情况
// 因此这里一个方法签名可能对应多个ProxyMethod，这在Java语言层面是不允许的
List sigmethods = proxyMethods.get(sig);
if (sigmethods != null) {
for (ProxyMethod pm : sigmethods) {
if (returnType == pm.returnType) {
/*
* Found a match: reduce exception types to the
* greatest set of exceptions that can thrown
* compatibly with the throws clauses of both
* overridden methods.
*/
// 对异常类型进行处理
List> legalExceptions = new ArrayList<>();
collectCompatibleTypes(
exceptionTypes, pm.exceptionTypes, legalExceptions);
collectCompatibleTypes(
pm.exceptionTypes, exceptionTypes, legalExceptions);
pm.exceptionTypes = new Class[legalExceptions.size()];
pm.exceptionTypes =
legalExceptions.toArray(pm.exceptionTypes);
return;
}
}
} else {
// sigmethods为null，创建并添加
sigmethods = new ArrayList<>(3);
proxyMethods.put(sig, sigmethods);
}
// 用方法相关的属性创建ProxyMethod并加入sigmethods中
sigmethods.add(new ProxyMethod(name, parameterTypes, returnType,
exceptionTypes, fromClass));
}