简介
我们在Java动态代理详解（一）这篇博客中已经为大家介绍了代理模式，并且简单介绍了JDK静态代理、JDK动态代理以及cglib动态代理。我们在这一篇博客中，将会从源码的角度来对JDK动态代理进行详细讲解。
在上一篇博客中，我们使用动态代理的核心代码如下：
public class SubjectProxy implements InvocationHandler {
private Subject subject;
public Object getInstance(Subject subject) {
this.subject = subject;
Class clazz = subject.getClass();
Object obj = Proxy.newProxyInstance(subject.getClass().getClassLoader(), clazz.getInterfaces(), this);
return obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("SubjectProxy : request()");
// 调用目标方法前的处理方法
PreRequest();
// 调用目标方法
method.invoke(subject, args);
// 调用目标方法后的处理方法
PostRequest();
return null;
}
public void PreRequest() {
System.out.println("SubjectProxy : PreRequest()");
}
public void PostRequest() {
System.out.println("SubjectProxy : PostRequest()");
}
}从上述源码可知，SubjectProxy实现了InvocationHandler接口，并实现了invoke方法，我们通过getInstance方法来获取代理对象。代理对象的获取最终是通过Proxy类的静态方法newProxyInstance来实现的，我们下面就从该方法开始详解。
Java动态代理源码详解
newProxyInstance方法
newProxyInstance方法定义如下：
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// 判断h是否为null，若为null，则直接抛出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);
}
// 获取参数类型是InvocationHandler.class的代理类构造器
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;
}
});
}
// 传入InvocationHandler实例去创建一个代理类的实例
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);
}
}newProxyInstance方法接收三个参数，分别是目标类的类加载器，目标类实现的接口集合，InvocationHandler实例对象，我们忽略newProxyInstance方法中的权限检查等操作，newProxyInstance方法主要调用了两个方法：
// 先从缓存中获取代理类，若不存在，则生成代理类
Class<?> cl = getProxyClass0(loader, intfs);
// 传入InvocationHandler实例去创建一个代理类的实例
return cons.newInstance(new Object[]{h});我们主要来看getProxyClass0方法。
getProxyClass0方法
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
// 若目标类实现的接口数目大于65535，则直接抛出IllegalArgumentException异常
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
// 先从缓存中获取代理类，若不存在，则生成代理类
return proxyClassCache.get(loader, interfaces);
}getProxyClass0方法很简单，它首先会检查目标代理类实现的接口数目，若接口数目大于65535，则直接抛出IllegalArgumentException异常，然后，调用proxyClassCache.get(loader, interfaces)方法去生成一个代理类，proxyClassCache是WeakCache对象，定义如下：
private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());下面我们来看一下WeakCache类的定义。
WeakCache类
我们先来看一下WeakCache类中的成员变量:
// Reference引用队列
private final ReferenceQueue<K> refQueue
= new ReferenceQueue<>();
// the key type is Object for supporting null key
// 缓存的底层实现, key为一级缓存, value为二级缓存
// key被设置成为了Object以支持null
private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map
= new ConcurrentHashMap<>();
// reverseMap记录了所有代理类生成器是否可用, 这是为了实现缓存的过期机制
private final ConcurrentMap<Supplier<V>, Boolean> reverseMap
= new ConcurrentHashMap<>();
// 生成二级缓存key的工厂, 这里传入的是KeyFactory
private final BiFunction<K, P, ?> subKeyFactory;
// 生成二级缓存value的工厂, 这里传入的是ProxyClassFactory
private final BiFunction<K, P, V> valueFactory;我们在这里看到了引用队列，并且类名称带有Weak，所以，应该联想到该类与弱引用有关。
WeakCache类的构造方法：
// 传入生成二级缓存key的工厂和生成二级缓存value的工厂
public WeakCache(BiFunction<K, P, ?> subKeyFactory,
BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
this.valueFactory = Objects.requireNonNull(valueFactory);
}WeakCache缓存的内部实现是通过ConcurrentMap来完成的，成员变量map就是二级缓存的底层实现，reverseMap是为了实现缓存的过期机制，subKeyFactory是二级缓存key的生成工厂，通过构造器传入，这里传入的值是Proxy类的KeyFactory，valueFactory是二级缓存value的生成工厂，通过构造器传入，这里传入的是Proxy类的ProxyClassFactory。接下来我们看一下WeakCache的get方法。
// 形参key为类加载器，parameter为被代理类所实现的接口
public V get(K key, P parameter) {
// 这里要求实现的接口不能为空
Objects.requireNonNull(parameter);
// 清除过期的缓存
expungeStaleEntries();
// 将ClassLoader包装成CacheKey, 作为一级缓存的key
Object cacheKey = CacheKey.valueOf(key, refQueue);
// lazily install the 2nd level valuesMap for the particular cacheKey
// 获取得到二级缓存
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
// 如果根据ClassLoader没有获取到对应的值
if (valuesMap == null) {
// 以CAS方式放入, 如果不存在则放入，否则返回原先的值
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
// 如果oldValuesMap有值, 说明放入失败
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
// 根据代理类实现的接口数组来生成二级缓存key, 分为key0, key1, key2, keyx
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
// 这里通过subKey获取到二级缓存的值
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
// 这个循环提供了轮询机制, 如果条件为假就继续重试直到条件为真为止
while (true) {
// 如果通过subKey取出来的值不为空
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
// 在这里supplier可能是一个Factory也可能会是一个CacheValue
// 在这里不作判断, 而是在Supplier实现类的get方法里面进行验证
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) {
// 新建一个Factory实例作为subKey对应的值
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
// 到这里表明subKey没有对应的值, 就将factory作为subKey的值放入
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
// 到这里表明成功将factory放入缓存
supplier = factory;
}
// else retry with winning supplier
}
// 否则, 可能期间有其他线程修改了值, 那么就不再继续给subKey赋值, 而是取出来直接用
else {
// 成功将factory替换成新的值
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);
}
}
}
}WeakCache的get方法并没有用锁进行同步，那它是怎样实现线程安全的呢？因为它的所有会进行修改的成员变量都使用了ConcurrentMap，这个类是线程安全的。因此它将自身的线程安全委托给了ConcurrentMap， get方法尽可能的将同步代码块缩小，这样可以有效提高WeakCache的性能。我们看到ClassLoader作为了一级缓存的key，这样可以首先根据ClassLoader筛选一遍，因为不同ClassLoader加载的类是不同的。
然后它用接口数组来生成二级缓存的key，这里它进行了一些优化，因为大部分类都是实现了一个或两个接口，所以二级缓存key分为key0，key1，key2，keyX。key0到key2分别表示实现了0到2个接口，keyX表示实现了3个或以上的接口，事实上大部分都只会用到key1和key2。这些key的生成工厂是在Proxy类中，通过WeakCache的构造器将key工厂传入。这里的二级缓存的值是一个Factory实例，最终代理类的值是通过Factory这个工厂来获得的。
Factory类
Factory类是WeakCache类的静态内部类，定义如下：
private final class Factory implements Supplier<V> {
// 一级缓存key, 根据ClassLoader生成
private final K key;
// 代理类实现的接口数组
private final P parameter;
// 二级缓存key, 根据接口数组生成
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, 用来验证是否是Factory本身
Supplier<V> supplier = valuesMap.get(subKey);
// 在这里验证supplier是否是Factory实例本身, 如果不是则返回null让调用者继续轮询重试
// 期间supplier可能替换成了CacheValue, 或者由于生成代理类失败被从二级缓存中移除了
if (supplier != this) {
// something changed while we were waiting:
// might be that we were replaced by a CacheValue
// or were removed because of failure ->
// return null to signal WeakCache.get() to retry
// the loop
return null;
}
// else still us (supplier == this)
// create new value
V value = null;
try {
// 委托valueFactory去生成代理类, 这里会通过传入的ProxyClassFactory去生成代理类
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
// 只有value的值不为空才能到达这里
assert value != null;
// wrap value with CacheValue (WeakReference)
// 使用弱引用包装生成的代理类
CacheValue<V> cacheValue = new CacheValue<>(value);
// put into reverseMap
// 将cacheValue放入reverseMap, 对它进行标记
reverseMap.put(cacheValue, Boolean.TRUE);
// try replacing us with CacheValue (this should always succeed)
// 将包装后的cacheValue放入二级缓存中, 这个操作必须成功, 否则直接抛出异常
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;
}
}我们再看看Factory这个内部工厂类，可以看到它的get方法是使用synchronized关键字进行了同步。进行get方法后首先会去验证subKey对应的suppiler是否是工厂本身，如果不是就返回null，而WeakCache的get方法会继续进行重试。如果确实是工厂本身，那么就会委托ProxyClassFactory生成代理类，ProxyClassFactory是在构造WeakCache的时候传入的。所以这里解释了为什么最后会调用到Proxy的ProxyClassFactory这个内部工厂来生成代理类。生成代理类后使用弱引用进行包装并放入reverseMap中，最后会返回原装的代理类。
ProxyClassFactory类
Factory的get方法会委托valueFactory去生成代理类, 这里会通过传入的ProxyClassFactory去生成代理类，生成代理类的方法如下：
valueFactory.apply(key, parameter)valueFactory就是前面提到的ProxyClassFactory对象，ProxyClassFactory类是Proxy类的静态内部类，该类定义如下：
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 {
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.
*/
// 验证intf是否是一个接口
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());
}
}
// 生成代理类的包名
String proxyPkg = null; // package to define proxy class in
// 生成代理类的访问标志，默认为public final
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
// 遍历接口数组
for (Class<?> intf : interfaces) {
// 获取接口的访问标志
int flags = intf.getModifiers();
// 如果接口的访问标志不是public, 那么生成代理类的包名和接口包名相同
if (!Modifier.isPublic(flags)) {
// 生成的代理类的访问标志设置为final
accessFlags = Modifier.FINAL;
// 获取接口全限定名，例如：java.util.Collection
String name = intf.getName();
int n = name.lastIndexOf('.');
// 剪裁后得到包名，例如java.util
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
// 生成的代理类的包名和接口包名是一样的
if (proxyPkg == null) {
proxyPkg = pkg;
}
// 代理类如果实现不同包的接口, 并且接口都不是public的, 那么就会在这里报错
else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
// 如果接口访问标志都是public的话, 那生成的代理类都放到默认的包下：com.sun.proxy
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
// 生成代理类的序号
long num = nextUniqueNumber.getAndIncrement();
// 生成代理类的全限定名, 包名+前缀+序号, 例如：com.sun.proxy.$Proxy0
String proxyName = proxyPkg + proxyClassNamePrefix + num;
// 用ProxyGenerator来生成字节码, 并放在对应包下
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());
}
}
}在代码中可以看到：
- JDK生成的代理类的类名是“$Proxy” + 序号。
- 如果接口是public的，代理类默认是public final的，并且生成的代理类默认放到com.sun.proxy这个包下。
- 如果接口是非public的，那么代理类也是非public的，并且生成的代理类会放在对应接口所在的包下。
- 如果接口是非public的，并且这些接口不在同一个包下，那么就会报错。
生成具体的字节码是调用了ProxyGenerator这个类的generateProxyClass方法。
ProxyGenerator类
ProxyGenerator类放在sun.misc包下，generateProxyClass静态方法源码如下：
public static byte[] generateProxyClass(final String name,
Class<?>[] interfaces,
int accessFlags)
{
// 根据包名、接口以及访问标志创建一个ProxyGenerator对象
ProxyGenerator gen = new ProxyGenerator(name, interfaces, accessFlags);
// 用前面生成的ProxyGenerator对象来生成代理类的字节码
final byte[] classFile = gen.generateClassFile();
// 如果要保存生成的字节码，则将代理类的字节码保存到对应路径下
if (saveGeneratedFiles) {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
try {
int i = name.lastIndexOf('.');
Path path;
if (i > 0) {
Path dir = Paths.get(name.substring(0, i).replace('.', File.separatorChar));
Files.createDirectories(dir);
path = dir.resolve(name.substring(i+1, name.length()) + ".class");
} else {
path = Paths.get(name + ".class");
}
Files.write(path, classFile);
return null;
} catch (IOException e) {
throw new InternalError(
"I/O exception saving generated file: " + e);
}
}
});
}
// 返回代理类的字节码
return classFile;
}其实，我们可以看到生成代理类的字节码是通过generateClassFile方法来完成的，该方法源码如下：
private byte[] generateClassFile() {
// 第一步, 将所有的方法组装成ProxyMethod对象
// 首先为代理类生成toString, hashCode, equals等代理方法
addProxyMethod(hashCodeMethod, Object.class);
addProxyMethod(equalsMethod, Object.class);
addProxyMethod(toStringMethod, Object.class);
// 遍历每一个接口的每一个方法, 并且为其生成ProxyMethod对象
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]);
}
}
// 对于具有相同签名的代理方法, 检验方法的返回值是否兼容
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
checkReturnTypes(sigmethods);
}
// 第二步, 组装要生成的class文件的所有的字段信息和方法信息
try {
// 添加构造器方法
methods.add(generateConstructor());
// 遍历缓存中的代理方法
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
for (ProxyMethod pm : sigmethods) {
// 添加代理类的静态字段, 例如:private static Method m1;
fields.add(new FieldInfo(pm.methodFieldName,
"Ljava/lang/reflect/Method;", ACC_PRIVATE | ACC_STATIC));
// 添加代理类的代理方法
methods.add(pm.generateMethod());
}
}
// 添加代理类的静态字段初始化方法
methods.add(generateStaticInitializer());
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception");
}
// 验证方法和字段集合不能大于65535
if (methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
}
if (fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
}
// 第三步, 写入最终的class文件
// 验证常量池中存在代理类的全限定名
cp.getClass(dotToSlash(className));
// 验证常量池中存在代理类父类的全限定名, 父类名为:"java/lang/reflect/Proxy"
cp.getClass(superclassName);
// 验证常量池存在代理类接口的全限定名
for (int i = 0; i < interfaces.length; i++) {
cp.getClass(dotToSlash(interfaces[i].getName()));
}
// 接下来要开始写入文件了,设置常量池只读
cp.setReadOnly();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
try {
// 1.写入魔数
dout.writeInt(0xCAFEBABE);
// 2.写入次版本号
dout.writeShort(CLASSFILE_MINOR_VERSION);
// 3.写入主版本号
dout.writeShort(CLASSFILE_MAJOR_VERSION);
// 4.写入常量池
cp.write(dout);
// 5.写入访问修饰符
dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);
// 6.写入类索引
dout.writeShort(cp.getClass(dotToSlash(className)));
// 7.写入父类索引, 生成的代理类都继承自Proxy
dout.writeShort(cp.getClass(superclassName));
// 8.写入接口计数值
dout.writeShort(interfaces.length);
// 9.写入接口集合
for (int i = 0; i < interfaces.length; i++) {
dout.writeShort(cp.getClass(dotToSlash(interfaces[i].getName())));
}
// 10.写入字段计数值
dout.writeShort(fields.size());
// 11.写入字段集合
for (FieldInfo f : fields) {
f.write(dout);
}
// 12.写入方法计数值
dout.writeShort(methods.size());
// 13.写入方法集合
for (MethodInfo m : methods) {
m.write(dout);
}
// 14.写入属性计数值, 代理类class文件没有属性所以为0
dout.writeShort(0);
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception");
}
// 转换成二进制数组输出
return bout.toByteArray();
}可以看到，ProxyGenerator生成Class文件主要分为三步：
第一步：收集所有要生成的代理方法，将其包装成ProxyMethod对象并注册到Map集合中。
第二步：收集所有要为Class文件生成的字段信息和方法信息。
第三步：完成了上面的工作后，开始组装Class文件。
我们知道一个类的核心部分就是它的字段和方法。我们重点聚焦第二步，看看它为代理类生成了哪些字段和方法。在第二步中，按顺序做了下面四件事。
1. 为代理类生成一个带参构造器，传入InvocationHandler实例的引用并调用父类的带参构造器。
2. 遍历代理方法Map集合，为每个代理方法生成对应的Method类型静态域，并将其添加到fields集合中。
3. 遍历代理方法Map集合，为每个代理方法生成对应的MethodInfo对象，并将其添加到methods集合中。
4. 为代理类生成静态初始化方法，该静态初始化方法主要是将每个代理方法的引用赋值给对应的静态字段。
获取到代理类的字节码后，ProxyClassFactory通过defineClass0方法将字节码加载到JVM中，生成代理类的Class对象，defineClass0方法是native方法，这里就不再介绍。
private static native Class<?> defineClass0(ClassLoader loader, String name, byte[] b, int off, int len);这样，我们就获取到了代理类的Class对象，然后，我们再回到newProxyInstance方法中，通过getProxyClass0方法生成的Class对象为cl，然后，根据代理类的构造方法来创建一个代理对象。
代理类的字节码
我们来看一下通过ProxyGenerator类的generateProxyClass方法生成的代理类字节码是什么样子的。我们修改一下Java动态代理详解（一）中JDK动态代理的客户端代码：
package dynamic;
public class Client {
public static void main(String[] args) {
// 创建被代理对象
Subject subject = new RealSubject();
// 创建代理对象, 并使用接口对其进行引用
Subject subjectProxy = (Subject) (new SubjectProxy()).getInstance(subject);
// 调用目标方法
subjectProxy.request();
// 将生成的代理类字节码信息保存
saveProxyClassFile("$Proxy0", subject.getClass().getInterfaces(), Modifier.PUBLIC | Modifier.FINAL);
}
private static void saveProxyClassFile(final String name, Class<?>[] interfaces, int accessFlags) {
byte[] data = ProxyGenerator.generateProxyClass(name, interfaces, accessFlags);
FileOutputStream out = null;
try {
out = new FileOutputStream(name + ".class");
out.write(data);
} catch (Exception e) {
e.printStackTrace();
} finally {
if(null != out) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}运行代码之后，我们来看一下生成的代理类：
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler paramInvocationHandler) {
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject) {
try {
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString() {
try {
return (String)this.h.invoke(this, m2, null);
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void request() {
try {
this.h.invoke(this, m3, null);
return;
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode() {
try {
return ((Integer)this.h.invoke(this, m0, null)).intValue();
} catch (Error|RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("dynamic.Subject").getMethod("request", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
return;
} catch (NoSuchMethodException localNoSuchMethodException) {
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
} catch (ClassNotFoundException localClassNotFoundException) {
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
}通过上述的分析，我们知道：
- 代理类默认继承Porxy类，因为Java中只支持单继承，所以JDK动态代理只能去实现接口。
- 代理方法都会去调用InvocationHandler的invoke()方法，因此我们需要重写InvocationHandler的invoke()方法。
- 调用invoke()方法时会传入代理实例本身，目标方法和目标方法参数。这也解释了invoke()方法的参数是怎样来的。
我们使用刚刚生成的$Proxy0类来进行以下测试，我们需要先修改一下SubjectProxy类和Client类：
SubjectProxy类：
public class SubjectProxy implements InvocationHandler {
private Subject subject;
public SubjectProxy(Subject subject) {
this.subject = subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("SubjectProxy : request()");
// 调用目标方法前的处理方法
PreRequest();
// 调用目标方法
method.invoke(subject, args);
// 调用目标方法后的处理方法
PostRequest();
return null;
}
public void PreRequest() {
System.out.println("SubjectProxy : PreRequest()");
}
public void PostRequest() {
System.out.println("SubjectProxy : PostRequest()");
}
}Client类：
public class Client {
public static void main(String[] args) {
// 创建被代理对象
Subject subject = new RealSubject();
// 创建invocationHandler对象
InvocationHandler invocationHandler = new SubjectProxy(subject);
// 创建代理对象, 并使用接口对其进行引用
Subject proxy = new $Proxy0(invocationHandler);
// 调用目标方法
proxy.request();
}
}运行结果：
SubjectProxy : request()
SubjectProxy : PreRequest()
RealSubject : request()
SubjectProxy : PostRequest()可以看到，通过生成的$Proxy0类实现了和JDK动态代理一样的功能，再次验证了我们的分析是可靠且准确的。
相关博客
Class.newInstance()与new、Constructor.newInstance()的区别
参考资料
JDK动态代理[2]----JDK动态代理的底层实现之Proxy源码分析
1114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
