一、代理模式的原理
1.1、代理模式是如何实现的
代理模式是常用的设计模式之一，它一般分为三个角色：
- 抽象角色：指代理角色和真实角色对外提供的公共方法，一般为一个接口
- 真实角色：需要实现抽象角色接口，定义了真正所要实现的业务逻辑，以便代理角色调用。
- 代理角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑来实现抽象方法，并可以附加自己的操作，将统一的流程控制都放到代理角色中处理。
三个角色的关系图如下：
1.2、使用代理模式的目的
- 通过引入代理对象来间接访问目标对象，可对调用者和目标对象进行解耦，保护目标对象。
- 可用过代理对象对目标对象的实现进行扩展和增强。
二、代理模式分类
2.1、静态代理
简单的demo：
这里我们构建一个在京东（代理对象）买实体厂家（目标对象）空调的场景。
//抽象角色(空调厂家)
public interface ACFactory {
void deliverGoods();
}
//真实角色
public class Geli implements ACFactory{
@Override
public void deliverGoods() {
System.out.println("格力空调....发货了");
}
}
//真实角色
public class Haier implements ACFactory{
@Override
public void deliverGoods() {
System.out.println("海尔空调....发货了");
}
}
//代理角色
public class JD implements ACFactory{
private Factory factory;
public JD(Factory factory) {
this.factory = factory;
}
private void sailBefore(){
System.out.println("售前服务");
}
private void sailAfter(){
System.out.println("售后服务");
}
//对真实角色的行为(方法)进行增强
@Override
public void deliverGoods() {
sailBefore();
factory.deliverGoods();
sailAfter();
}
}
//调用者
public class ShoppingTest {
public static void main(String[] args) {
Factory haier = new Haier();
JD jd = new JD(haier);
jd.deliverGoods();
}
}如果此时我感觉格力和海尔的空调太贵了不适合我，我想买个奥克斯的（新需求），此时我们能快速的进行扩展。
public class Aux implements ACFactory{
@Override
public void deliverGoods() {
System.out.println("奥克斯空调....发货了");
}
}
//调用者
public class ShoppingTest {
public static void main(String[] args) {
Factory aux = new Aux();
JD jd = new JD(aux);
jd.deliverGoods();
}
}再说一个真实场景帮助大家理解，当我们进行Android开发时会用到网络请求框架，比如最早使用的是Volley框架，之后我想换成okhttp框架，如果之前是强关联（即在业务代码中直接引用Volley），想要做框架替换无疑是痛苦的，如果在设计之初，我们写了一个代理层则可以快速进行框架转换，哪怕将来要求替换为Retrofit也会毫不费力，代理模式可以增强我们代码的扩展性。
静态代理的缺点：
- 静态代理会导致类和接口泛滥，难以管理
- 如需对接口进行改动，那么所有实现类都要改动
正因静态代理的缺点，由此引出动态代理。
2.2、动态代理
首先需要说明的是静态代理和动态代理的思想和原理是一模一样的，只是实现代理类的方式不同。
静态代理：是手动创建代理类并实现接口(.java文件)，这个文件是实实在在存储在磁盘上的文件，然后经过编译生成字节码文件(.class文件)，最后通过类加载器加载到内存中。
动态代理：是在运行时动态生成字节流，其内容是和实现了接口的代理类的字节码文件是基本一致的，只不过它直接存储在内存中，帮我们省去了手动实现接口这一过程。
（可类比于Android中xml中的控件和java中直接new的控件的关系）。
下面先看一下动态代理的使用方式：
public class ShoppingTest {
public static void main(String[] args) {
//静态代理的使用方式
// Factory haier = new Haier();
// JD jd = new JD(haier);
// jd.deliverGoods();
//动态代理的使用方式，与静态代理对应着看有助于理解
//步骤一 创建目标对象
Haier haier = new Haier();
// o即静态代理中的JD代理类
//步骤二，创建代理类对象
Object o = Proxy.newProxyInstance(ShoppingTest.class.getClassLoader(), //类加载器，用于加载生成的字节码（是一个字节数组）
new Class[]{Factory.class}, //要实现的接口
new InvocationHandler() { //回调，会在生成的字节码中实现的接口方法中进行调用
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke= null;
if (method.getName().equals("deliverGoods")){
sailBefore();
//调用目标对象（真实角色）的方法
//步骤四 调用目标对象的方法（真正的逻辑代码）
invoke = method.invoke(haier, args);
sailAfter();
}
return invoke;
}
});
//相当于静态代理中jd.deliverGoods()
//步骤三 调用代理类接口方法
Factory factory = (Factory) o;
factory.deliverGoods();
}
private static void sailBefore() {
System.out.println("售前服务");
}
private static void sailAfter() {
System.out.println("售后服务");
}
}
看完动态代理的使用，我相信大家还是会有很多疑惑的，最大的疑惑肯定是代理类调用实现的接口方法到底是怎么回调到InvocationHandler的invoke()的呢？那接下来就来看下源码，相信所有的疑惑都会烟消云散。
Proxy.java
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
//检查h不为空
Objects.requireNonNull(h);
//拷贝接口类数组
final Class<?>[] intfs = interfaces.clone();
...
// 标记1：寻找或生成代理类.
Class<?> cl = getProxyClass0(loader, intfs);
...
try {
...
//获取代理类的构造方法
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
...
//通过反射创建代理类对象，并将传入的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);
}
}这个方法的源码很好理解，重点是标记一处的代理类是如何生成的，继续跟入最终来到Proxy.ProxyClassFactory的apply()方法：
public Class<?> apply(ClassLoader var1, Class<?>[] var2) {
...
//上面的逻辑就是做了一些字符上的拼接，这里得到的var22就是代理类的内容了
byte[] var22 = ProxyGenerator.generateProxyClass(var23, var2, var17);
try {
//这里根据上面的字节数组创建一个class对象
return Proxy.defineClass0(var1, var23, var22, 0, var22.length);
} catch (ClassFormatError var14) {
throw new IllegalArgumentException(var14.toString());
}
}
}那如果我们将byte[]输出到一个class文件，我们就能清楚生成的代理类到底是什么样子的了：
private static void generateProxy(){
String name = Factory.class.getName()+"$Proxy0";
byte[] bytes = ProxyGenerator.generateProxyClass(name, new Class[]{Factory.class});
try {
FileOutputStream fos = new FileOutputStream(name+".class");
fos.write(bytes);
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}运行此方法，我们就可以拿到生成的动态代理类了，内容如下：
//这里实现了Factory接口
public final class Factory$Proxy0 extends Proxy implements Factory {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
//这个InvocationHandler就是我们使用动态代理时传入的回调对象
public Factory$Proxy0(InvocationHandler var1) throws {
super(var1);
}
//重写了Object类中的equals()方法。
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);
}
}
//重写了Factory接口中的方法
public final void deliverGoods() throws {
try {
//super.h就是上面构造函数中的InvocationHandler对象，这里就调用了invoke()方法进行回调
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
//重写了Object类中的toString()方法。
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);
}
}
//重写了Object类中的hashCode()方法。
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.example.view.test4.Factory").getMethod("deliverGoods");
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());
}
}
}
同理如果我们传入多个接口，生成的代理类(只有一个类)会将他们全部实现，到此动态代理的原理就非常清晰了，很多优秀框架都用到了动态代理如Retrofit。
扫一扫
1133
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
