写在前面
本篇博客是基于对动态代理，java的重写，多态特性了解的基础上对于源码的阅读，先提出几个问题
1.从静态代理变成动态代理需要解决两个问题，如何动态实现被代理类的接口并摘取接口中的方法，如果动态的为被代理方法添加附加逻辑
2.给出一个例子：
interface a {
String get() throws Exception;
}
interface b {
Object get() throws NullPointerException;
}
}
如果我要代理即实现了a又实现了b的类的get方法，那么在代理类$Proxy0中基于a和b的get方法动态生成的get方法的描述是什么？怎么实现？
3.能否举出代理失败的例子？（两种？）
阅读建议：涉及的方法以及域比较多，前后是连贯的，抓住关联
重要的域
先从proxy类开始
//一个静态常量,后面会用到
private static final Class<?>[] constructorParams = { InvocationHandler.class };
//代理类的缓存
private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
//InvocationHandler类型变量，注意它的访问权限为protected，也就是说子类可以为它赋值
protected InvocationHandler h;
newProxyInstance
/**
*loader:常常将被代理类的classloader传入
*interfaces：被代理类的接口集合
*h:代理辅助类，被代理方法的实际调用者
**/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
//检查h是否为空，如果为空则抛出NullPointerException
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//生成代理类
Class<?> cl = getProxyClass0(loader, intfs);
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//反射获得代理类的构造函数，其中传入参数constructorParams是前面定义的静态常量，这也间接说明代理类的共同特点：g构造函数传入参数为InvocationHandler类型
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//反射会的代理类的实例
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
getProxyClass0
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//官方解释：如果在缓存中找到匹配loader和interfaces的代理类则直接返回，否则通过ProxyClassFactory新建一个
return proxyClassCache.get(loader, interfaces);
}
proxyClassCache在上述域中已经说明，它是属于WeakCache类型，传入了KeyFactory和ProxyClassFactory的实例作为参数进行了实例化，下面我们来看下get方法
get
public V get(K key, P parameter) {
//确保interfaces不为空
Objects.requireNonNull(parameter);
//在这个方法中有很多缓存的操作，不懂，省略处理，以后填坑
expungeStaleEntries();
//省略
while (true) {
if (supplier != null) {
//这句和代理类的生成有关
V value = supplier.get();
//省略
}
上述注释的supplier.get()实现另一个方法的调用，在weakCache中有一个Factory静态内部类，它实现了supplier接口，因此supplier调用get实际是调用其子类Factory对象的get方法
get
public synchronized V get() {
//缓存操作不懂省略
Supplier<V> supplier = valuesMap.get(subKey);
if (supplier != this) {
return null;
}
V value = null;
try {
//很明显可以发现下面的valueFactory.apply是用来生成代理类的
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
}
//省略
}
}
valueFactory是上述在实例化weakCache时传入的ProxyClassFactory的对象的引用，下面查看它的apply方法
apply
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
//用来判断interfaces中是否重复的set
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
Class<?> interfaceClass = null;
try {
//用我们传入的classloader加载interface
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
//如果上述加载的interfaceclass和我们直接传入的intf不同，则说明传入的loader和interface不匹配，抛出异常
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
//判断是否为接口
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
//判断interfaces是否有重复
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
//代理类的package值
String proxyPkg = null;
//代理类的访问权限
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
//遍历判断interfaces中是否有非public访问权限的interface，如果有的话，代理类所在的包必须和它一致
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
//如果不是公有权限
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
//下面三行代码用来获得intf所在包，例如若intf = InvacationHandler.class，pkg将等于java.lang.reflect.
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
//如果有多个非public的interface并且它们不在同一个包中，将抛出异常
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
//如果所有的interfaces都为public，那么代理类所在的包为com.sun.proxy.
if (proxyPkg == null) {
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/**下面两行代码用到两个ProxyClassFactory中的域，分别是 ：
/*1.private static final String proxyClassNamePrefix = "$Proxy";
/*2.private static final AtomicLong nextUniqueNumber = new AtomicLong();
**/
long num = nextUniqueNumber.getAndIncrement();
//例如proxyName为com.sun.proxy.$proxy0
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//核心逻辑的调用出现了
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//defineClass0为本地方法，用来动态加载class文件
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
经过数次跳转，终于来到了核心代码地，即ProxyGenerator的generateProxyClass方法，sun的jdk中该部分代码不是开源，可以参考openJdk,接下来仅贴出主要代码
generateProxyClass
public static byte[] generateProxyClass(final String name, Class[] interfaces)
{
ProxyGenerator gen = new ProxyGenerator(name, interfaces);
final byte[] classFile = gen.generateClassFile();
//中间省略
return classFile;
}
在介绍ProxyGenerator的其他方法之前先来看一下其中的一些域
/**一个用来过渡处理(怎么处理？)所有method对象的hashmap，String的组成是Method对象的name加上参数列表（为什么这样标识),对于代理类而言每一个String标识对应的List中必须只有一个元素，否则方法就重复了**/
private Map<String, List<ProxyMethod>> proxyMethods = new HashMap<String,List<ProxyMethod>>();
//包含代理类所有method信息的集合
private List<MethodInfo> methods = new ArrayList<>();
//包含代理类所有field信息的集合
private List<FieldInfo> fields = new ArrayList<>();
generateClassFile
private byte[] generateClassFile() {
//step1:针对所有接口中的方法生成Method对象
//首先向proxyMethods中添加Object的hashcode，equals，toString三个method对象
addProxyMethod(hashCodeMethod, Object.class);
addProxyMethod(equalsMethod, Object.class);
addProxyMethod(toStringMethod, Object.class);
//然后添加接口中的method对象
for (int i = 0; i < interfaces.length; i++) {
Method[] methods = interfaces[i].getMethods();
for (int j = 0; j < methods.length; j++) {
addProxyMethod(methods[j], interfaces[i]);
}
}
//对每一个String标识的List中的所有ProxyMethod的返回值类型进行兼容性处理（涉及到重写特性)(为什么要处理？怎么处理)
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
checkReturnTypes(sigmethods);
}
//step2:向methods和fields中分别添加methodInfo和FieldInfo
try {
//添加构造函数
methods.add(generateConstructor());
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
for (ProxyMethod pm : sigmethods) {
//对于每个method对象添加静态引用
fields.add(new FieldInfo(pm.methodFieldName,
"Ljava/lang/reflect/Method;",
ACC_PRIVATE | ACC_STATIC));
//添加在proxyMethods这个hashMap中走过一遭的的ProxyMethod的methodInfo
methods.add(pm.generateMethod());
}
}
//添加静态初始化方法，例如：<clinit>,类在被加载的时候，为所有静态初始化的变量生成一个clinit方法，然后在里面执行赋值
methods.add(generateStaticInitializer());
//step3:漫长的拼class文件系列，不再展示
接下来是解释前面提出的过渡处理以及开头提出的问题2
addProxyMethod
//该方法一方面是向proxyMethods这个hashmap中添加不同标识的method对象，另一方面是针对相同的标识进行兼容性处理
private void addProxyMethod(Method m, Class fromClass) {
//反射获得method的name,parameterTypes,returnType,exceptionTypes
String name = m.getName();
Class[] parameterTypes = m.getParameterTypes();
Class returnType = m.getReturnType();
Class[] exceptionTypes = m.getExceptionTypes();
//形成该m的sig（标识）即name+参数列表
String sig = name + getParameterDescriptors(parameterTypes);
//proxyMethods是上述提到的hashMap（key为sig）
List<ProxyMethod> sigmethods = proxyMethods.get(sig);
//如果在proxyMethods中能找到和m标识一样的ProxyMethod，例如：开头问题2中a和b的标识就是一样的
if (sigmethods != null) {
for (ProxyMethod pm : sigmethods) {
//并且返回类型相同
if (returnType == pm.returnType) {
//兼容性处理：将pm的异常大小要小于等于pm和m中的最小值（重写特性），不需要向proxyMethods中添加m了
List<Class> legalExceptions = new ArrayList<Class>();
collectCompatibleTypes(
exceptionTypes, pm.exceptionTypes, legalExceptions);
collectCompatibleTypes(
pm.exceptionTypes, exceptionTypes, legalExceptions);
pm.exceptionTypes = new Class[legalExceptions.size()];
pm.exceptionTypes =
legalExceptions.toArray(pm.exceptionTypes);
return;
}
}
}
//如果没有找到相同的标识，proxyMethods添加一个新的key-value键值对，value是一个list初始容量为3
else {
sigmethods = new ArrayList<ProxyMethod>(3);
proxyMethods.put(sig, sigmethods);
}
//无论是在proxyMethods中与m有相同标识但是返回类型不同，还是没有相同标识，都要向proxyMethods对应key的list中添加m
sigmethods.add(new ProxyMethod(name, parameterTypes, returnType,
exceptionTypes, fromClass));
}
经历该方法后，proxyMethods中某个key的list的ProxyMethod个数可能大于1（如果直接用来生成代理类，将会有重复的方法），这些ProxyMethod的name和参数列表相同，返回类型不同，接下来checkReturnTypes处理
checkReturnTypes
在前面是通过
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
checkReturnTypes(sigmethods);
}
这段代码来进入checkReturnTypes方法的
/**checkReturnTypes方法是专门进行兼容性处理，对于需要实现的接口中有重复的方法（如前面问题2的a,b），为了对实现这些接口的类都进行代理，代理类必须生成一个同时对它们进行重写了的方法，也就是说动态生成的这个方法，在每个接口看来都是对它内部抽象方法的重写，真相就是：代理类方法的返回类型必须是interfaces中所有重复方法返回类型的中的一个，并且这个返回类型是其他重复方法返回类型的子类（例如：参照开头interface a,b，代理类的get方法的返回类型是String）**/
static void checkReturnTypes(List<ProxyMethod> methods) {
//如果proxyMethods中该标识的list元素小于2，那就不需要处理了
if (methods.size() < 2) {
return;
}
//用来记录已经处理的所有返回类型中，已经兼容其它返回类型的返回类型（例如：参照开头interface a,b，在处理了它们的重复get方法之后，代理类方法返回类型为String）
LinkedList<Class<?>> uncoveredReturnTypes = new LinkedList<>();
//continue的跳转标签
nextNewReturnType:
for (ProxyMethod pm : methods) {
Class<?> newReturnType = pm.returnType;
//如果某个Proxymethod的返回类型是基本类型（int,char,long,double等),就直接抛出异常，因为基本类型和其它返回类型都不兼容
if (newReturnType.isPrimitive()) {
throw new IllegalArgumentException(
"methods with same signature " +
getFriendlyMethodSignature(pm.methodName,
pm.parameterTypes) +
" but incompatible return types: " +
newReturnType.getName() + " and others");
}
boolean added = false;
//遍历uncoveredReturnTypes
ListIterator<Class<?>> liter = uncoveredReturnTypes.listIterator();
while (liter.hasNext()) {
Class<?> uncoveredReturnType = liter.next();
//如果pm的返回类型是uncoveredReturnType的父类，那么uncoveredReturnType也兼容pm，直接continue
if (newReturnType.isAssignableFrom(uncoveredReturnType)) {
assert !added;
continue nextNewReturnType;
}
//如果pm的返回类型是uncoveredReturnType的子类，那么pm代替uncoveredReturnType兼容其它已经处理的returntype
if (uncoveredReturnType.isAssignableFrom(newReturnType)) {
if (!added) {
liter.set(newReturnType);
added = true;
}
//uncoveredReturnType中可能也有多个returnType，它们之间不兼容，当下面分支执行的时候，就说明pm的返回类型同时兼容uncoveredReturnType中的某些returnType，那么在uncoveredReturnType中这些returnType就可以移除了
else {
liter.remove();
}
}
}
//向uncoveredReturnTypes中添加不兼容的类，
if (!added) {
uncoveredReturnTypes.add(newReturnType);
}
}
//如果uncoveredReturnTypes中返回类型多于1个，也就是说：不存在一个返回类型兼容其它所有的，那么代理类中对于该方法也就无法重写了，抛出异常
if (uncoveredReturnTypes.size() > 1) {
ProxyMethod pm = methods.get(0);
throw new IllegalArgumentException(
"methods with same signature " +
getFriendlyMethodSignature(pm.methodName, pm.parameterTypes) +
" but incompatible return types: " + uncoveredReturnTypes);
}
}
表述的比较拗口，下图展示checkReturnTypes方法
最后LinedList就是兼容所有类型的类
$proxy0代码
public final class $Proxy0 extends Proxy implements a,b{
//根据方法生成的静态的域
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
//类加载时，会在clinit方法中进行初始化
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode",
new Class[0]);
m3 = Class.forName("my.java.reflect").getMethod("get",
new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString",
new Class[0]);
} catch (NoSuchMethodException nosuchmethodexception) {
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
} catch (ClassNotFoundException classnotfoundexception) {
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}
//还记得Proxy类中InvocationHandler h的访问权限为protected吗？这个时候赋值
public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}
@Override
public final boolean equals(Object obj) {
try {
return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))
.booleanValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final int hashCode() {
try {
return ((Integer) super.h.invoke(this, m0, null)).intValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final String get() {
try {
return (String)super.h.invoke(this, m3, null);
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final String toString() {
try {
return (String) super.h.invoke(this, m2, null);
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}
以上