一、说明
代理模式（百度百科）：
- 为其他对象提供一种代理以控制对这个对象的访问。
- 在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
二、组成
- 抽象角色（subject）:通过接口、抽象类声明真是角色需要的业务方法。
- 代理角色（Proxy）代理真实角色操作。
- 真实角色（RealSubject）：实现抽象角色，定义真实角色需要的业务逻辑。
三、类图
代理模式.png
四、优缺点
优点：
- 和静态代理相比，不需要创建多个实现类来维护，更灵活。
五、使用场景
- Retrofit类似框架，直接代理接口，而不需要实现类。
六、代码举例
（1）subject 抽象接口
/**
* 接口类
*/
public interface ISaleCarInterface {
//卖车
void saleCar();
}
(2) RealSubject 宝马汽车厂
/**
* 被代理人：宝马汽车厂
*/
public class BMW implements ISaleCarInterface{
/**
* 汽车厂商自己卖车需要的手续
*/
@Override
public void saleCar() {
System.out.println("----宝马厂：收钱----");
System.out.println("----宝马厂：签合同----");
System.out.println("----宝马厂：交车----");
}
}
(3) proxy 代理商：4s店，此时动态代理是没有具体实现的，因为他是在运行时由程序动态创建的。
创建过程：
- 1、Proxy.newProxyInstance()工具类动态创建代理类的proxy0.class文件。放在com.sun.proxy包下。
- 2、执行方法时，相当于调用这个动态生成的proxy0.class的方法。
/**
* 统一调用处理类：
*/
public class DynamicProxyHandler implements InvocationHandler {
//真实被代理人对象
private Object subject;
public DynamicProxyHandler(Object subject) {
this.subject = subject;
}
/**
* 这个调度方法，是在proxy0.class字节码文件的方法里会调用。
* 这个就是通过反射来接收到proxy0.class的调用。
*
* @param proxy：Proxy 代理人对象
* @param method：被代理人的方法名。宝马厂的方法。
* @param args：被代理人的参数，宝马厂方法的参数。
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("subject= " + subject.getClass() + "; proxy= " + proxy.getClass() + "; method= " + method + "; args= " + args);
//1、代理人自己的处理
GregorianCalendar calendar = new GregorianCalendar();
int hour = calendar.get(Calendar.HOUR_OF_DAY);
if (hour < 9 || hour > 18) {
System.out.println("====4s店：下班了，明天再来吧！====" + hour);
return null;
}
System.out.println("====动态代理处理：4s店收费，并收取佣金。。。====");
//2、反射方式调用被代理人方法
Object invoke = method.invoke(subject, args);
//3、代理人最后还可添加自己的处理
System.out.println("====动态代理处理：4s店推销保险，并交车！。。。====");
return invoke;
}
}
(4) 客户端测试类
public class Test {
public static void main(String[] args) {
//这一句是生成代理类的class文件，前提是你需要在工程根目录下创建com/sun/proxy目录，不然会报找不到路径的io异常
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
//动态代理模式
//1、创建需要被代理的类
BMW bmw = new BMW();
//2、获得加载被代理类的 类加载器
ClassLoader loader = Thread.currentThread().getContextClassLoader();
//3、指明被代理类实现的接口
Class<?>[] interfaces = bmw.getClass().getInterfaces();
//4、将被代理人对象传入，创建被代理类的委托类,之后想要调用被代理类的方法时，都会委托给这个类的invoke(Object proxy, Method method, Object[] args)方法
DynamicProxyHandler h = new DynamicProxyHandler(bmw);
//5、生成代理类
ISaleCarInterface dynamicProxy = (ISaleCarInterface) Proxy.newProxyInstance(loader,interfaces,h);
//6、调用代理类方法。
dynamicProxy.saleCar();
}
}
（5）动态生成的proxy0.class字节码文件
/**
* 这就是动态生成的代理类
*/
public final class $Proxy0 extends Proxy implements ISaleCarInterface {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
/**
* 这个就是实现的我们卖车接口方法了。
*/
public final void saleCar() throws {
try {
//super.h 就是我们的DynamicProxyHandler自定义处理器。
//就是调用我们自定义的那个invoke方法。从而实现m3方法的调用。这里的m3Method代表就是saleCar()方法。
//如果还有其他接口方法。比如 buyCar()，那么就会有一个m4对应buyCar()。这个就是一对一的。
super.h.invoke(this, m3, (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("com.crm.web.controller.ISaleCarInterface").getMethod("saleCar");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
/**
* 系统Object默认需要实现的方法
*/
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);
}
}
/**
* 系统Object默认需要实现的方法
*/
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);
}
}
/**
* 系统Object默认需要实现的方法
*/
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);
}
}
}
说明：
-
其实动态代理模式顾名思义，它确实是动态生成一个代理类的字节码文件，并在其中实现好我们声明的接口。
-
而在调用时使用反射机制，Method.invoke()来实现不同方法的调用。
Retrofit
非常巧妙的利用了动态代理的这个特性。
- 每个代理后的接口调用都会走invoke()方法，所以retrofit在invoke方法中，获取接口方法上的注解以及参数，来组成Request请求体，然后交给okhttpClient发起网络请求。
网友评论