// 步骤4：通过动态代理对象，调用目标对象的方法
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 1. 创建 调用处理器类 对象
DynamicProxy DynamicProxy = new DynamicProxy();
// 2. 创建 目标类 对象
Buyer1 mBuyer1 = new Buyer1();
// 3. 创建动态代理类 & 对象：通过调用处理器类对象newProxyInstance（）
// 传入上述目标类对象
Subject Buyer1_DynamicProxy = (Subject) DynamicProxy.newProxyInstance(mBuyer1);
// ->>关注1
// 4. 通过调用动态代理对象方法从而调用目标对象方法
// ->>关注2
Buyer1_DynamicProxy.buybuybuy();
// 以上代购为小成代购Mac
// 以下是代购为小何代购iPhone
Buyer2 mBuyer2 = new Buyer2();
Subject Buyer2_DynamicProxy = (Subject) DynamicProxy.newProxyInstance(mBuyer2);
Buyer2_DynamicProxy.buybuybuy();
}
}
此处有两个重要的源码分析点：
关注1：创建动态代理类 & 对象：通过调用处理器类对象newProxyInstance（）
解决的问题是：动态代理类 及其对象实例是如何生成的？
关注2：通过调用动态代理对象方法从而调用目标对象方法
解决的问题是：如何通过调用动态代理对象方法，从而调用目标对象方法？
下面，我们将主要分析这两处源码。
4.1 （关注1）创建动态代理类 & 对象：通过调用处理器类对象newProxyInstance（）
// 使用代码
Subject Buyer1_DynamicProxy = (Subject) DynamicProxy.newProxyInstance(mBuyer1);
1
2
即，动态代理类 及其对象实例是如何生成的？
下面，我们直接进入DynamicProxy.newProxyInstance()
<-- 关注1：调用处理器 类的newProxyInstance（） -->
// 即步骤1中实现的类：DynamicProxy
// 作用：
// 1. 生成 动态代理对象
// 2. 指定 代理对象运行目标对象方法时需要完成的 具体任务
// 注：需实现InvocationHandler接口 = 调用处理器 接口
public class DynamicProxy implements InvocationHandler {
// 声明代理对象
private Object ProxyObject;
public Object newProxyInstance(Object ProxyObject){
this.ProxyObject =ProxyObject;
return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
ProxyObject.getClass().getInterfaces(),this);
// Proxy.newProxyInstance（）作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类实例，并最终返回
// ->>关注2
}
// 以下暂时忽略，下文会详细介绍
// 复写InvocationHandler接口的invoke（）
// 动态代理对象调用目标对象的任何方法前，都会调用调用处理器类的invoke（）
@Override
public Object invoke(Object proxy, Method method, Object[] args)
// 参数说明：
// 参数1：动态代理对象（即哪个动态代理对象调用了method（）
// 参数2：目标对象被调用的方法
// 参数3：指定被调用方法的参数
throws Throwable {
System.out.println("代购出门了");
Object result = null;
// 通过Java反射机制调用目标对象方法
result = method.invoke(ProxyObject, args);
return result;
}
// 至此，关注1分析完毕，跳出
}
<-- 关注2：newProxyInstance（）源码解析-->
// 作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类及其对象实例，并最终返回
public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException {
// 参数说明：
// 参数1：指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
// 参数2：指定目标对象的实现接口
// 即要给目标对象提供一组什么接口。若提供了一组接口给它，那么该代理对象就默认实现了该接口，这样就能调用这组接口中的方法
// 参数3：指定InvocationHandler对象。即动态代理对象在调用方法时，会关联到哪个InvocationHandler对象
...
// 仅贴出核心代码
// 1. 通过 为Proxy类指定类加载器对象 & 一组interface，从而创建动态代理类
// >>关注3
Class cl = getProxyClass(loader, interfaces);
// 2. 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
Constructor cons = cl.getConstructor(constructorParams);
// 3. 通过动态代理类的构造函数 创建 代理类实例（传入调用处理器对象
return (Object) cons.newInstance(new Object[] { h });
// 特别注意
// 1. 动态代理类继承 Proxy 类 & 并实现了在Proxy.newProxyInstance()中提供的一系列接口（接口数组）
// 2. Proxy 类中有一个映射表
// 映射关系为：(<ClassLoader>,(<Interfaces>,<ProxyClass>) )
// 即：1级key = 类加载器，根据1级key 得到 2级key = 接口数组
// 因此：1类加载器对象 + 1接口数组 = 确定了一个代理类实例
...
// 回到调用关注2的原处
}
<-- 关注3：getProxyClass（）源码分析 -->
// 作用：创建动态代理类
public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)
throws IllegalArgumentException {
...
// 仅贴出关键代码
<-- 1. 将目标类所实现的接口加载到内存中 -->
// 遍历目标类所实现的接口
for (int i = 0; i < interfaces.length; i++) {
// 获取目标类实现的接口名称
String interfaceName = interfaces.getName();
Class interfaceClass = null;
try {
// 加载目标类实现的接口到内存中
interfaceClass = Class.forName(interfaceName, false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != interfaces) {
throw new IllegalArgumentException(
interfaces + " is not visible from class loader");
}
}
<-- 2. 生成动态代理类 -->
// 根据传入的接口 & 代理对象 创建动态代理类的字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
// 根据动态代理类的字节码 生成 动态代理类
proxyClass = defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
}
// 最终返回动态代理类
return proxyClass;
}
// 回到调用关注3的原处
总结
通过调用处理器类对象的.newProxyInstance()创建动态代理类 及其实例对象（需传入目标类对象）
具体过程如下：
通过 为Proy类指定类加载器对象 & 一组接口，从而创建动态代理类的字节码；再根据类字节码创建动态代理类
通过反射机制获取动态代理类的构造函数（参数类型 = 调用处理器接口类型
通过动态代理类的构造函数 创建 代理类实例（传入调用处理器对象
4.2 (关注2）通过调用动态代理对象方法从而调用目标对象方法
即，如何通过调用动态代理对象方法，从而调用目标对象方法？
// 使用代码
Buyer1_DynamicProxy.buybuybuy();
1
2
在关注1中的 DynamicProxy.newProxyInstance()生成了一个动态代理类 及其实例
该动态代理类记为 ：$Proxy0
下面我们直接看该类实现及其 buybuybuy()
该方法的逻辑如下：
<-- 动态代理类 $Proxy0 实现-->
// 继承：Java 动态代理机制的主类：java.lang.reflect.Proxy
// 实现：与目标对象一样的接口（即上文例子的Subject接口）
public final class $Proxy0 extends Proxy implements Subject {
// 构造函数
public ProxySubject(InvocationHandler invocationhandler)
{
super(invocationhandler);
}
// buybuybuy（）是目标对象实现接口（Subject）中的方法
// 即$Proxy0类必须实现
// 所以在使用动态代理类对象时，才可以调用目标对象的同名方法（即上文的buybuybuy（））
public final void buybuybuy（） {
try {
super.h.invoke(this, m3, null);
// 该方法的逻辑实际上是调用了父类Proxy类的h参数的invoke（）
// h参数即在Proxy.newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象
// 即调用了调用处理器的InvocationHandler.invoke（）
// 而复写的invoke（）利用反射机制：Object result=method.invoke(proxied,args)
// 从而调用目标对象的的方法 ->>关注4
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
<-- 关注4：调用处理器 类复写的invoke（） -->
// 即步骤1中实现的类：DynamicProxy
// 内容很多都分析过了，直接跳到复写的invoke（）中
public class DynamicProxy implements InvocationHandler {
private Object ProxyObject;
public Object newProxyInstance(Object ProxyObject){
this.ProxyObject =ProxyObject;
return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
ProxyObject.getClass().getInterfaces(),this);
}
// 复写InvocationHandler接口的invoke（）
// 动态代理对象调用目标对象的任何方法前，都会调用调用处理器类的invoke（）
@Override
public Object invoke(Object proxy, Method method, Object[] args)
// 参数说明：
// 参数1：动态代理对象（即哪个动态代理对象调用了method（）
// 参数2：目标对象被调用的方法
// 参数3：指定被调用方法的参数
throws Throwable {
System.out.println("代购出门了");
Object result = null;
// 通过Java反射机制调用目标对象方法
result = method.invoke(ProxyObject, args);
return result;
}
总结
动态代理类实现了与目标类一样的接口，并实现了需要目标类对象需要调用的方法
该方法的实现逻辑 = 调用父类 Proxy类的 h.invoke（）
其中h参数 = 在创建动态代理实例中newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象
在 InvocationHandler.invoke（） 中通过反射机制，从而调用目标类对象的方法
4.3 原理总结
我用一张图总结第4节说的关于动态代理模式的源码分析。
收藏
淘帖
踩
