retroift2.9.0原理解析
retrofit是基于okhttp网络框架的基础上做的封装，使用了大量的设计模式，使网络请求更加便捷，同时减少代码的耦合性。
使用的设计模式
- 建造者模式
- 代理模式
- 工厂模式
- 适配器模式
使用方式：
1.首先通过建造者模式，实例化Retrofit对象
Retrofit one =
new Retrofit.Builder()
.addCallAdapterFactory(callAdapter)
.addConverterFactory(converter)
.baseUrl(baseUrl)
.callbackExecutor(executor)
.callFactory(callFactory)
.build();
2.然后通过create方法，创建请求的网络的接口实例（外观模式，统一调用方式）
CallMethod example = retrofit.create(CallMethod.class);
3.然后通过接口实例对象调用其中的方法，获取call对象，通过execute同步方法或者enqueue异步方法请求网络数据
String result = extending.getResponseBody().execute().body().string();
源码分析：
1.建造者模式实例化Retrofit对象
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
//如果callFactory为null，则使用okhttpclient
if (callFactory == null) {
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
//如果callbackExecutor为null，则使用平台默认的callbackExecutor
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
// Make a defensive copy of the adapters and add the default Call adapter.
//创建callAdapterFactor数组
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
//将平台默认的calladapterFactories加入数组
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
// Make a defensive copy of the converters.
//创建converterFactories数组，数组个数为1+当前设置的converterFactories的个数+平台默认的converterFactories的个数
List<Converter.Factory> converterFactories =
new ArrayList<>(
1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
// Add the built-in converter factory first. This prevents overriding its behavior but also
// ensures correct behavior when using converters that consume all types.
converterFactories.add(new BuiltInConverters());
//我们自己设置的converterFactories
converterFactories.addAll(this.converterFactories);
//平台默认的converterFactories
converterFactories.addAll(platform.defaultConverterFactories());
//实例化retrofit
return new Retrofit(
callFactory,
baseUrl,
unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories),
callbackExecutor,
validateEagerly);
}
2.调用create方法创建请求网络的接口实例，通过动态代理模式，生成请求网络接口实例的动态代理对象，所有接口中的方法调用，由动态代理的InvocationHandler转发
public <T> T create(final Class<T> service) {
validateServiceInterface(service);
//动态代理生成请求数据的接口类
return (T)
Proxy.newProxyInstance(
service.getClassLoader(),
new Class<?>[] {service},
new InvocationHandler() {
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override
public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
// If the method is a method from Object then defer to normal invocation.
//如果这个方法是来自Object类中的方法，则把这个方法当做普通方法来调用
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
args = args != null ? args : emptyArgs;
//loadServiceMethod方法解析Method，返回一个HttpServiceMethod调用其invoke方法
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args);
}
});
}
也就是说当我们通过create方法获取到请求网络接口的实例对象，通过该对象调用请求数据的方法，最终方法会转发到InvocationHandler中的invoke方法中，重点是loadServiceMethod方法，在这个方法中，我们解析我们接口里面方法的参数，返回值类型，注解等。 以下是loadServiceMethod方法：
ServiceMethod<?> loadServiceMethod(Method method) {
//从ConCurrentHashMap中获取ServiceMethod
ServiceMethod<?> result = serviceMethodCache.get(method);
//如果不为null，则直接返回该ServiceMethod对象
if (result != null) return result;
//同步锁，锁住ConCurrentHashMap
synchronized (serviceMethodCache) {
//从hashMap中获取缓存的serviceMethod
result = serviceMethodCache.get(method);
//如果为空
if (result == null) {
//解析注解并保存在hashMap中
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}
这个方法中，会先从一个hashMap中取serviceMethod对象，如果没有，就解析该方法ServiceMethod.paseAnnotations
abstract class ServiceMethod<T> {
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//通过RequetFactory解析注解
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
Type returnType = method.getGenericReturnType();
if (Utils.hasUnresolvableType(returnType)) {
throw methodError(
method,
"Method return type must not include a type variable or wildcard: %s",
returnType);
}
if (returnType == void.class) {
throw methodError(method, "Service methods cannot return void.");
}
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
abstract @Nullable T invoke(Object[] args);
}
最后解析生成HttpServiceMethod对象，我们方法的所有信息都在这个类里面 看一看HttpServiceMethod类
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
boolean continuationWantsResponse = false;
boolean continuationBodyNullable = false;
Annotation[] annotations = method.getAnnotations();
Type adapterType;
if (isKotlinSuspendFunction) {
//获取泛型方法参数类型
Type[] parameterTypes = method.getGenericParameterTypes();
Type responseType =
Utils.getParameterLowerBound(
0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]);
if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {
// Unwrap the actual body type from Response<T>.
responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
continuationWantsResponse = true;
} else {
// TODO figure out if type is nullable or not
// Metadata metadata = method.getDeclaringClass().getAnnotation(Metadata.class)
// Find the entry for method
// Determine if return type is nullable or not
}
adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
} else {
//获取泛型方法的返回值类型
adapterType = method.getGenericReturnType();
}
//创建CallAdapter，将adapterType也就是泛型方法返回值类型传入
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
Type responseType = callAdapter.responseType();
if (responseType == okhttp3.Response.class) {
throw methodError(
method,
"'"
+ getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
if (responseType == Response.class) {
throw methodError(method, "Response must include generic type (e.g., Response<String>)");
}
// TODO support Unit for Kotlin?
if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
throw methodError(method, "HEAD method must use Void as response type.");
}
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;
//注意这里：如果不是kotlin挂起方法，创建CallAdapted，将我们通过CallAdapterFactory创建的callAdapter对象传入
if (!isKotlinSuspendFunction) {
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
} else if (continuationWantsResponse) {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForResponse<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForBody<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable);
}
}
这里面调用了适配器的方法，把方法中的请求参数类型和返回值类型，通过适配器，转换成对服务器友好请求参数，和对用户友好的返回结果。 然后通过invoke方法执行方法
@Override
final @Nullable ReturnT invoke(Object[] args) {
//创建okHttpCall对象，并调用adapt方法
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
return adapt(call, args);
}
这里我们会获取到我们的call对象，然后调用adapt方法，进一步执行adapter方法
protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);
static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
private final CallAdapter<ResponseT, ReturnT> callAdapter;
CallAdapted(
RequestFactory requestFactory,
okhttp3.Call.Factory callFactory,
Converter<ResponseBody, ResponseT> responseConverter,
CallAdapter<ResponseT, ReturnT> callAdapter) {
super(requestFactory, callFactory, responseConverter);
this.callAdapter = callAdapter;
}
@Override
protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
return callAdapter.adapt(call);
}
}
可以看到adapt是个抽象方法，注意前面代码中的“注意这里”，我们已经创建了CallAdapted对象，所有adapt方法最终汇之星CallAdpted的adapt方法，而其中的callAdapter就是我们通过CallAdapteFactory创建的adapter,如果没有创建，就用默认的defaultCallAdapterFactroy
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
private final @Nullable Executor callbackExecutor;
DefaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
this.callbackExecutor = callbackExecutor;
}
@Override
public @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
if (!(returnType instanceof ParameterizedType)) {
throw new IllegalArgumentException(
"Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
}
final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
final Executor executor =
Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
? null
: callbackExecutor;
return new CallAdapter<Object, Call<?>>() {
@Override
public Type responseType() {
return responseType;
}
@Override
public Call<Object> adapt(Call<Object> call) {
return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
}
};
}
到这里的adapt，我们获取到了我们的call对象，就可以执行网络请求了。
