1. JDK动态代理
DK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的，只能对实现了接口的类生成代理，而不是针对类，该目标类型实现的接口都将被代理。原理是通过在运行期间创建一个接口的实现类来完成对目标对象的代理。
JDK动态代理的应用范围很广，比较有代表性的就Spring框架的AOP功能，切面逻辑就是基于动态代理实现的，能在方法前后增强方法。
2. 方法解析
- 自定义代理类实现
InvocationHandle接口，实现其中的invoke方法，在该方法中实现增强逻辑，并通过反射动态调用被代理的方法，或者直接匿名内部类实现都可。 - 代理类或者测试程序中调用
Proxy.newProxyInstance方法，该方法能根据传入的参数，动态生成代理对象，最终使用该对象调用代理方法。
/**
* 重写代理方法逻辑，不用让类去继承Shop接口了，可以代表任意实际方法，泛用性强
* @param proxy 没啥用，调用invoke方法千万别用这个对象
* @param method 反射获取到“被代理对象”的Method对象，调用真正实现类方法
* @param args 反射获取到的真实方法参数列表
* @return 返回一个封装好的代理对象
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//实现逻辑，调用真实实现对象
}
/*========================================================*/
/**
* Proxy.newProxyInstance是jdk动态代理的核心方法，通过反射获取到接口方法，实现动态获取代理对象
* 由于做演示，这里直接写死了返回"结算接口"，也可以在方法调用是动态传入参数。
*
* 参数1：用哪个类加载器去加载
* 参数2：“被代理类”实现的接口集合
* 参数3：重写了invoke()方法的类对象，反射通过h.invoke()掉用真实方法，即上面重写的方法
由于在代理类内部实现了方法，所以传this，否则传入代理对象。
*/
Proxy.newProxyInstance(this.getClass().getClassLoader(),
Settlement.class.getInterfaces(),
this);
3. 案例模拟
实现功能：
商场购买货品结账时，能根据用户是否为本店会员进行相应的折扣处理。
- 功能接口
Shop：商场提供一个货物结算方法settlement()用于购物结算 - 结算类
Settlement：实现结算接口方法，进行正常的无折扣金额计算。 - 结算折扣类
SettlementProxy：实现根据用户类型来进行折扣，如果是会员给9折，不是会员不打折。代理结算类，进行了方法增强。 - 测试类
JDKProxyMain
Shop类
- shop 是接口，定义结账方法
public interface Shop {
//结算方法
Double settlement(Double... money );
}
Settlement类
- Settlement 是实现类，实现结账方法，这里充当 “被代理类”
public class Settlement implements Shop{
//按物品原价计算总价
public Double settlement(Double... moneys) {
Double total = 0.0;
for (Double money: moneys) {
total += money;
}
return total;
}
}
SettlementProxy类
- 结算类的代理类，需要实现 InvocationHandler 接口方法
- invoke 方法是核心，对 被代理类 实现逻辑增强
public class SettlementProxy implements InvocationHandler {
// 用来接收被代理类对象
private Object obj;
public void setObj(Object obj) {
this.obj = obj;
}
/**
* 重写代理方法逻辑，不用让类去继承Shop接口了，可以代表任意实际方法，泛用性强
* @param proxy 没啥用，调用invoke方法千万别用这个对象
* @param method 反射获取到“被代理对象”的Method对象，调用真正实现类方法
* @param args 反射获取到的真实方法参数列表
* @return 返回一个封装好的代理对象
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//调用被代理方法，传入被代理对象，计算金额
Double total = (Double)method.invoke(obj, args);
System.out.println("查询数据库，用户是本店会员，给予折扣");
for (int i = 0; i < 5; i++){
Thread.sleep(1000);
System.out.print(".");
}
//打九折
return total*0.9;
}
//为了方便，这里提供获取代理对象的方法
public Object getInstance(){
/**
* Proxy.newProxyInstance是jdk动态代理的核心方法，通过反射获取到接口方法，实现动态获取代理对象
* 由于做演示，这里直接写死了返回"结算接口"，也可以在方法调用是动态传入参数。
*
* 参数1：用哪个类加载器去加载
* 参数2：“被代理类”实现的接口集合
* 参数3：重写了invoke()方法的类对象，通过h.invoke掉用，由于本例实现了，所以传this
*/
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
Settlement.class.getInterfaces(),
this);
}
}
JDKProxyMain
- main 函数测试
public class JDKProxyMain {
public static void main(String[] args) {
//创建代理对象，设置需要代理的类对象
SettlementProxy proxy = new SettlementProxy();
// 方法传入 被代理对象，其实也说明了核心功能还是由被代理对象实现，代理类只是在方法调用前后做增强处理！
proxy.setObj(new Settlement());
//自己封装的代理方法，获取代理对象
Shop instance = (Shop)proxy.getInstance();
//代理对象调用方法
Double total = instance.settlement(5.0, 10.0);
System.out.println(total);
}
}
延伸：源码阅读
1. 生成代理类的字节码
- 下列代码可生成jdk代理模式的字节码文件
//生成jdk动态代理字节码文件
public static void generatorProxyClass(){
//生成JDK动态代理字节码文件，
//第一个参数是代理类名字，自定义，第二个参数是被代理类的实现接口
byte[] bytes = ProxyGenerator.generateProxyClass("$proxy1",
Settlement.class.getInterfaces());
//将字节码文件写出，这里直接放在项目下
FileOutputStream outputStream = null;
try {
outputStream = new FileOutputStream(new File("E:\\IntelliJ IDEA\\proxy\\src","$Proxy1.class"));
outputStream.write(bytes);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (outputStream != null){
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
生成的字节码文件
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
import cn.edu.jyu.jdk.Shop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $proxy1 extends Proxy implements Shop {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $proxy1(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final Double settlement(Double[] var1) throws {
try {
return (Double)super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("cn.edu.jyu.jdk.Shop").getMethod("settlement", Class.forName("[Ljava.lang.Double;"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
2. 阅读字节码文件
public final class $proxy1 extends Proxy implements Shop- 每个JDK动态生成的代理类，都会继承Proxy类，并且实现自定义接口
- 由于Java是单继承的，所以不能再继承“被代理类”。
m1 m2 m3 m0m1通过反射获取的Object类中的equals方法对象m2通过反射获取的Object类中的toString方法对象m3通过反射获取的“自定义接口”中的接口方法对象m0通过反射获取的Object类中的hashCode方法对象
- 核心实现方法
public final Double settlement(Double[] var1) throws {
try {
return (Double)super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
(Double)super.h.invoke(this, m3, new Object[]{var1})- 这个方法调用父类Proxy中
InvocationHandler引用中的方法invoke - 由于
InvocationHandler是一个接口，invoke方法不能直接调用，所以JVM自动寻找InvocationHandler接口的实现类 - 找到了我自定义的
SettlementProxy，最终调用的就是我们自定义类中重写的invoke方法。
- 这个方法调用父类Proxy中
此时也解决了另一个问题，由于这里传入的invoke的第一个参数是this，也就是jdk生成的代理类对象，所以重写的invoke方法中调用方法 Double total = (Double)method.invoke(obj, args);时，第一个参数传入的我们接受的obj对象，而不是传过来的参数proxy。
如果参数使用了传过来的proxy会怎样？
此时可以等同于 m3.invoke(this, new new Object[]{var1})，由于代理对象$proxy1中 settlement方法还是调用return (Double)super.h.invoke(this, m3, new Object[]{var1});，所以导致无限重复调用方法，直到JVM栈溢出。
7157
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
