前言
Retrofit系列文章
Retrofit系列文章（一） - Retrofit简介
Retrofit系列文章（二） - Retrofit常见问题的解决
Retrofit系列文章（三） - Retrofit源码分析
Retrofit系列文章（四） - 手写Retrofit核心架构部分
拓展 - 应用是怎么来的？
1. Retrofit源码分析
1>：Builder设计模式
Retrofit retrofit = new Retrofit.Builder()
// 访问后台接口的主路径
.baseUrl("http://192.168.8.169:8080/OkHttpServer/")
// 添加解析转换工厂，Gson解析、Xml解析
.addConverterFactory(GsonConverterFactory.create())
// 添加OkHttpClient，不添加就是默认的光杆 OkHttpClient
.client(okHttpClient)
.build() ;
2>：动态代理设计模式
mServiceApi = retrofit.create(ServiceApi.class) ;
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);
}
});
}
动态代理作用：用作解耦；
体现形式有很多：绕过插件化 AndroidManifest.xml ，可以让Activity不需要在清单文件中注册，主要作用是用作Hook拦截；
MVP主要用作：AOP切面，AOP思想就是：把通用的代码统一管理起来，放到一个地方去处理，不要去写重复的代码，只要能够达到这种思想，那么不管是 MVP 或者其他都可以；
总之上边采用的原理其实都是：方法的拦截，像前两节写的Retrofit用法中的所有的类、所有的方法，不管是 RetrofitClient类中所有方法、ServiceApi所有代码、MainActivity用测试 Retrofit代码等等所有有关于 Retrofit的代码，调用之后都会执行 这个 Proxy.newProxyInstance()拦截方法的；
3>：工厂设计模式
简单工厂、抽象工厂、方法工厂
A：简单工厂：创建Platform，点击 mServiceApi = retrofit.create(ServiceApi.class) ;进入 create()方法中，然后点击 动态代理中的 Platform.get();进入下边代码：
private static final Platform PLATFORM = findPlatform();
static Platform get() {
return PLATFORM;
}
private static Platform findPlatform() {
try {
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0) {
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("java.util.Optional");
return new Java8();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}
B：方法工厂：GsonConverterFactory.crete() ；
public static GsonConverterFactory create() {
return create(new Gson());
}
/**
* Create an instance using {@code gson} for conversion. Encoding to JSON and
* decoding from JSON (when no charset is specified by a header) will use UTF-8.
*/
public static GsonConverterFactory create(Gson gson) {
return new GsonConverterFactory(gson);
}
C：抽象工厂：Converter，Factory，GsonConverterFactory；
// 添加解析转换工厂，Gson解析、Xml解析
.addConverterFactory(GsonConverterFactory.create())
点击addConverterFactory进到这个方法
public Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
4>：adapter设计模式
.addCallAdapterFactory()
下边这个方法是 第二个 动态代理模式的 Proxy.newProxyInstance() 中 最后的 return语句
serviceMethod.callAdapter.adapt(okHttpCall);
如果不采用 RxJava，默认直接返回okHttpCall就可以，这里为什么还调用一次？
Retrofit返回的 是 Call，但是一旦采用 RxJava，我想要的就必须是 Observable，Call 与 Observable 是两个完全不一样的对象，所以 adapter 设计模式 在这里的体现就是：把 Call 适配成 Observable；
5>：模板设计模式
ParameterHandler源码中：
abstract class ParameterHandler<T> {
abstract void apply(RequestBuilder builder, @Nullable T value) throws IOException;
final ParameterHandler<Iterable<T>> iterable() {
return new ParameterHandler<Iterable<T>>() {
@Override void apply(RequestBuilder builder, @Nullable Iterable<T> values)
throws IOException {
if (values == null) return; // Skip null values.
for (T value : values) {
ParameterHandler.this.apply(builder, value);
}
}
};
}
ServiceMethod的源码中：
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
不同的对象调用不同的 apply，ParameterHandler源码中：
@Override void apply(RequestBuilder builder, @Nullable T value) throws IOException {
if (value == null) return; // Skip null values.
String headerValue = valueConverter.convert(value);
if (headerValue == null) return; // Skip converted but null values.
builder.addHeader(name, headerValue);
}
}
模板设计模式就是：
制定通用的流程，具体的算法细节由不同的子类去实现，确定 Retrofit的请求流程，解析方法参数注解，但是其具体的各个参数细节由子类去实现。
这里还可以衍生出另一种设计模式，叫做策略设计模式，不同的参数注解采用不同的添加策略；
6>：享元设计模式、原型、单例、观察者（回调）设计模式
享元设计模式：避免创建更多的对象，达到对象的复用
Retrofit源码中的：
// 对象的复用
private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();
ServiceMethod<?, ?> loadServiceMethod(Method method) {
ServiceMethod<?, ?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder<>(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
