一、JDK动态代理实现
// 创建一个接口(人类)
public interface Person {
void findLove();
}
// 创建一个媒婆的客户，实现findLove方法
public class Customer implements Person {
public void findLove() {
System.out.println("高富帅");
}
}
// 媒婆类 实现InvocationHandler接口
public class JDKAgentMeiPo implements InvocationHandler {
// 被代理对象
private Person target;
public Object getInstance(Person target) {
this.target = target;
Class<? extends Person> aClass = target.getClass();
// 这里会创建代理类并返回
return Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), this);
}
// 代理类只要调用invoke方法就可以实现被代理类的方法，可以对被代理方法执行前后进行功能的扩展
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在被代理方法执行前做处理
before();
// 执行被代理类的具体方法
Object invoke = method.invoke(this.target, args);
// 在被代理方法执行后做处理
after();
return invoke;
}
private void before() {
System.out.println("我是媒婆:我要给你找对象,我现在已经确定你的需求了");
System.out.println("开始物色");
}
private void after() {
System.out.println("如果可以就结婚");
}
}
// 创建测试类
public class JDKAgentTest {
public static void main(String[] args) {
try {
// 被代理类
Customer customer = new Customer();
Person instance = (Person) new JDKAgentMeiPo().getInstance(customer);
instance.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果:
我是媒婆:我要给你找对象,我现在已经确定你的需求了
开始物色
高富帅
如果可以就结婚
那么我们的JDK代理模式时怎么实现的呢:
- 获取被代理对象的应用,并且获取它所有接口,反射获取
- JDK动态代理重新生成一个新的类,同时新的类要实现被代理对象实现的所有接口
- 动态生成JAVA代码
- 编译新生成的JAVA代码.class 文件
- 重新加载到JVM中运行
我们下面看下JDK生成的代理类:
// JDK生成的类名称一般由$符号开头
public final class $Proxy0 extends Proxy implements Person {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(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);
}
}
// 实现了findLove方法
public final void findLove() throws {
try {
// 调用JDKAgentMeiPo.invoke方法
// super.h 就是 JDKAgentMeiPo 这个对象,这个对象是在 Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), this); 这句代码中的this变量将JDKAgentMeiPo的对象传带Proxy中的
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
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 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"));
m3 = Class.forName("com.wangyahao.designpatterns.proxy.dynamicAgent.JDKAgent.Person").getMethod("findLove");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
大家可以使用这段代码将代理类输出到磁盘中
try {
// 被代理类
Customer customer = new Customer();
Person instance = (Person) new JDKAgentMeiPo().getInstance(customer);
instance.findLove();
// 将生成的代理对象转成字节数组
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Person.class});
FileOutputStream fileOutputStream = new FileOutputStream("/Users/wangyahao/Desktop/$Proxy0.class");
fileOutputStream.write(bytes);
fileOutputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
以上就是JDK动态代理的基本使用了,下面说下它和静态代理的区别:
- JDK动态代理和静态代理很像,只是静态代理是手动写代码,而JDK动态代理是根据反射自动生成代理,在代码维护上动态代理更加便于维护
- 在代码编写上静态代理类和被代理对象都需要实现同一个接口,而动态代理不需要
