Proxy属于代理型设计模式
定义:
为其它对象提供一种代理以控制对这个对象的访问控制；在某些情况下，客户不想或者不能直接引用另一个对象，这时候代理对象可以在客户端和目标对象之间起到中介的作用。
作用:
1.实现无侵入式的代码扩展
2.解耦,交给代理处理
缺点:
java系统中的动态代理只能代理接口
应用场景:
如Retrofit中请求服务的接口, 面向切面编程的Aop
Proxy.class
1.创建实现interfaces接口的对象
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces, InvocationHandler h)
loader: - 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces: -一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
h: -一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
2.生成关于intfs接口实现的class对象
Class<?> cl = getProxyClass0(loader, intfs);
通过ProxyClassFactory创建此class对象
步骤一.生成接口实现类的字节数组
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
步骤二.生成实现类的class对象
private static native Class<?> defineClass0(ClassLoader loader, String name,byte[] b, int off, int len)
3.生成实现类对象
Constructor<?> cons = cl.getConstructor(constructorParams);
///////////////省略其他代码///////////////
return cons.newInstance(new Object[]{h});
由此可知: 实现类对象是通过Proxy构造后, 生成字节数组; 再调用底层代码将字节数组转换成class对象; 最后class对象通过 构造器创建对象的方式，创建了实现类对象
InvocationHandler.class
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable;
proxy: - 指代我们所代理的那个真实对象
method: - 指代的是我们所要调用真实对象的某个方法的Method对象
args: - 指代的是调用真实对象某个方法时接受的参数
根据3 生成实现类对象,InvocationHandler作为了实现类的构造参数, 因此
InvocationHandler的invoke显然和实现类对象的方法调用有关, 到底是什么关系?
最好看看实现类长什么样, 前面有提到 生成的字节数组, 因此可以将该字节数组生成一个类，展示出来
1.Subject是一个接口
public interface Subject {
/**
* 写入字符串
* @param string
*/
void writeString(String string);
/**
* 读取字符串
* @return
*/
String readString();
}
2.生成实现类方法
byte[] bytes = ProxyGenerator.generateProxyClass(
"InterfaceImpl", new Class[]{Subject.class}, Modifier.FINAL | Modifier.PUBLIC);
FilesKt.writeBytes(new File("InterfaceImpl.class"), bytes);
3.实现类
public final class InterfaceImpl extends Proxy implements Subject, Material {
/**
* m0,m1.. 为当前的方法对象
*/
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m4;
private static Method m5;
private static Method m0;
public InterfaceImpl(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
/**
* 间接调用InvocationHandler对象中的invoke方法
*/
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 readString() throws {
try {
return (String)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 void writeString(String var1) throws {
try {
super.h.invoke(this, m4, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String getColor() throws {
try {
return (String)super.h.invoke(this, m5, (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("chapter_pattern.agent.dynamic.Subject").getMethod("readString");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m4 = Class.forName("chapter_pattern.agent.dynamic.Subject").getMethod("writeString", Class.forName("java.lang.String"));
m5 = Class.forName("chapter_pattern.agent.dynamic.Material").getMethod("getColor");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
显然在调用实现类方法的时候，实际会通过InvocationHandler对象调用其重写的invoke方法，通常我们会在重写的invoke方法中去调用接口的实现类对象(注意:这个实现类对象不是我们通过字节码生成的实现类对象, 而是业务中实现接口的类对象)
动态代理简单模型
代码链接:https://github.com/A18767101271/java-/tree/master/src/chapter_pattern/agent/dynamic
