代理模式UML
图1-1，代理模式UML建模
什么是代理模式？
给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。
比如说，我想在喝星巴克的咖啡；正常流程下，我要自己去星巴克店里购买，是我执行买这个操作，但现在我通过外卖服务，这个买的人就变成了外卖小哥，而不是我本人，这里的外卖小哥其实就是我的代理，他代我实现了这个买的操作。这里的我相当于Client，买咖啡是一个借口Subject，外卖小哥就是ReallySubject，ProxySubject就是我要买咖啡的一个代理（我并不关心真正的执行者是谁）
一个简单的代理实现代码
public class Delegate {
public void main() {
// 真正执行者
Subject reallySubject =new ReallySubject();
// 代理执行者
Subject proxySubject =new ProxySubject(reallySubject);
// 看似是代理执行者在做事【所谓的代理】
proxySubject.doSomethings();
}
}
interface Subject {
void doSomethings();
}
public class ReallySubjectimplements Subject {
@Override
public void doSomethings() {
Log.e("实际执行人","真正要做事的");
}
}
public class ProxySubjectimplements Subject {
private Subjectsubject;
public ProxySubject(Subject subject) {
this.subject = subject;
}
@Override
public void doSomethings() {
Log.e("我是代办人","通知真正办事的者，办事！");
if (subject !=null)
subject.doSomethings();
}
}
什么是静态代理和动态代理？
静态代理：在编译时就将接口、实现类、代理类实现了，说白点就是咱们自己手动全部敲出来。
动态代理：在程序运行时，根据需要动态的创建代理类及相关实例。
都是代理又为什么要区分静态代理和动态代理呢？
当我们遇到某个需求要实现大量的代理的时候，每一个都要手动去敲是一件很费时操作，而且大部分的代码又都是重复的，这个时候就有大神就提出了动态代理的方案，来简化这些没有营养的操作了，即动态代理的出现。
动态代理的实现
public class DelegateSubject implements InvocationHandler {
private Subject subject;
public DelegateSubject(Subject subject) {
this.subject = subject;
}
/**
*
* @param proxy 代理对象（表示哪个代理对象调用了method方法）
* @param method 调用方法
* @param args 调用方法参数
* @return 代理实例调用具体的方法返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object object = null;
// 添加自己的代码1
// 根据自己的需要甚至可以不调用method.invoke()方法
object = method.invoke(subject, args);
// 添加自己的代码2
return object;
}
}
public class Delegate {
public void main() {
// 真正执行者
ReallySubject reallySubject = new ReallySubject();
// 代理执行器
DelegateSubject delegateSubject = new DelegateSubject(reallySubject);
// 构造动态代理
// 第一个参数 真正执行者加载器
// 第二个参数 真正执行者实现的接口
// 第三个参数 代理执行器
Subject subject = (Subject) Proxy.newProxyInstance(
ReallySubject.class.getClassLoader(),
ReallySubject.class.getInterfaces(), // 或者 new Class<?>[] { Subject.class },
delegateSubject);
// 通过代理执行对象方法
// 调用此方法执行 DelegateSubject的invoke()
subject.doSomethings();
}
}
看看retrofit是怎么使用动态代理
public <T> T create(final Class<T> service) {
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(service);
}
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
private final Platform platform = Platform.get();
@Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
// If the method is a method from Object then defer to normal invocation.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
看了retrofit的代码你会不会产生疑问，retrofit只有接口没并没有具体的执行者啊！！！
还记得上面的这段代码么？
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object object = null;
// 添加自己的代码1
// 根据自己的需要甚至可以不调用method.invoke()方法
object = method.invoke(subject, args);
// 添加自己的代码2
return object;
}
中提到过 “根据需要你甚至可以不调用method.invoke()”，没错retrofit就这么干的
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
这段代码只要是使用OkHttp进行网络请求，并将OkHttp的返回结果作为最终函数的返回结果。
