Retrofit 是 RESTful 的 HTTP 网络请求框架的封装。网络请求的工作本质上是 OkHttp 完成的，而 Retrofit 仅负责网络请求接口的封装。
创建 Retrofit 实例
// 配置 Retrofit
mRetrofit = new Retrofit.Builder()
.baseUrl(Constant.API_YOUTU_BASE) // 设置 base url
.client(OkhttpManager.getInstance().getOkhttpClient()) // 设置 client
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();Retrofit 实例是使用建造者模式通过 Builder 类进行创建的，我们先跳过 build，看下 Retrofit 的成员变量的定义
它的 build 类中的成员变量和 Retrofit 的成员变量基本是一一对应的，通过 build 就可以配置 Retrofit 了。
看下 Builder 类
public static final class Builder {
private final Platform platform;
private @Nullable okhttp3.Call.Factory callFactory;
private @Nullable HttpUrl baseUrl;
private final List<Converter.Factory> converterFactories = new ArrayList<>();
private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();
private @Nullable Executor callbackExecutor;
private boolean validateEagerly;
Builder(Platform platform) {
this.platform = platform;
}
public Builder() {
this(Platform.get());
}
Builder(Retrofit retrofit) {
}
}少了 serviceMethodCache，多了 Platform。
Platform类构建
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();
}Platform 是静态单例的，它通过 Class.forName 检查是在哪个平台，可以看到它还支持 Java 平台。这里返回的就是 Android 平台。
static class Android extends Platform {
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Override List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
@Nullable Executor callbackExecutor) {
if (callbackExecutor == null) throw new AssertionError();
DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);
return Build.VERSION.SDK_INT >= 24
? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
: singletonList(executorFactory);
}
@Override List<? extends Converter.Factory> defaultConverterFactories() {
return Build.VERSION.SDK_INT >= 24
? singletonList(OptionalConverterFactory.INSTANCE)
: Collections.<Converter.Factory>emptyList();
}
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
}这里面由好多个 default 的配置：
defaultCallbackExecutor()：返回的是 MainThreadExecutor，它其中的 handler 是 MainLooper，所以 execte 方法执行的是在主线程。
defaultCallAdapterFactories()：这里添加了 CompletableFutureCallAdapterFactory、DefaultCallAdapterFactory。之后重点讲解 GsonConverterFactory 。
final class DefaultCallAdapterFactory extends CallAdapter.Factory
final class CompletableFutureCallAdapterFactory extends CallAdapter.Factory {
static final CallAdapter.Factory INSTANCE = new CompletableFutureCallAdapterFactory();
}defaultConverterFactories()：默认添加了 OptionalConverterFactory 。之后重点讲解 RxJava2CallAdapterFactory 。
看完了 Platform 在回头看下 Retrofit 的 serviceMethodCache，它是网络请求配置对象，这里就是接口中定义的方法解析所得的对象，存储了网络请求相关的配置，如网络请求的方法、数据转换器、网络请求适配器、网络请求工厂等。这个唯一不是 build 构建出来的。
build()
callFactory：网络请求工厂，默认为 OkHttp
public Retrofit build() {
//...
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
//...
}baseUrl：网络请求的 url 地址
public Builder baseUrl(String baseUrl) {
checkNotNull(baseUrl, "baseUrl == null");
return baseUrl(HttpUrl.get(baseUrl));
}
public Builder baseUrl(HttpUrl baseUrl) {
checkNotNull(baseUrl, "baseUrl == null");
List<String> pathSegments = baseUrl.pathSegments();
if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
}
this.baseUrl = baseUrl;
return this;
}baseUrl 必须传
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
//...
}converterFactories：数据转换器工厂集合，将 GsonConverterFactory.create() 创建的加入集合。
public static GsonConverterFactory create() {
return create(new Gson());
}
public static GsonConverterFactory create(Gson gson) {
if (gson == null) throw new NullPointerException("gson == null");
return new GsonConverterFactory(gson);
}
public final class GsonConverterFactory extends Converter.FactorycallAdapterFactories：网络请求器的工厂集合，将 RxJava2CallAdapterFactory.create() 创建的加入集合。
public static RxJava2CallAdapterFactory create() {
return new RxJava2CallAdapterFactory(null, false);
}
public final class RxJava2CallAdapterFactory extends CallAdapter.FactorycallbackExecutor：回调方法。
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
Platform中
@Nullable Executor defaultCallbackExecutor() {
return null;
}validateEagerly，是否提前对业务接口中的注解进行验证转换的标志位。
由于使用了构建者模式，大多数都很简单，源码中的build配置也很好读，我们就创建好了Retrofit的实例。
了解下重要的三个类：
ParameterizedType
public interface ParameterizedType extends Type {
Type[] getActualTypeArguments();
Type getRawType();
Type getOwnerType();
}
getActualTypeArguments()：获取“泛型实例”中<>里面的“泛型变量”（也叫类型参数）的值，这个值是一个类型。因为可能有多个“泛型变量”（如：Map<K,V>）,所以返回的是一个 Type[]。
getRawType()：返回最外层<>前面那个类型，即 Map<K ,V> 的 Map。
getOwnerType()：获得这个类型的所有者的类型。这主要是对嵌套定义的内部类而言的，例如于对 java.util.Map.Entry<K,V> 来说，调用 getOwnerType 方法返回的就是 interface java.util.Map。
当然还有其他的 Type，这里举一个 ParameterizedType 说明下，之后的 gson 的解析会与这边关联。
GsonConverterFactory，继承 Converter.Factory，它重写了其中两个方法：
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}
@Override
public Converter<?, RequestBody> requestBodyConverter(Type type,
Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonRequestBodyConverter<>(gson, adapter);
}可以看到都是 Gson 中高级方法，这里不解释那么多，这里创建了 GsonResponseBodyConverter 对象，在 convert 中处理数据。
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
private final Gson gson;
private final TypeAdapter<T> adapter;
GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
this.gson = gson;
this.adapter = adapter;
}
@Override public T convert(ResponseBody value) throws IOException {
//
}
}RxJava2CallAdapterFactory，继承 CallAdapter.Factory，重写了 get 方法，这里比较长，我将重点放进来。
@Override public @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit) {
Class<?> rawType = getRawType(returnType);
//判断是否是Completable类型
if (rawType == Completable.class) {
return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
false, true);
}
boolean isFlowable = rawType == Flowable.class;
boolean isSingle = rawType == Single.class;
boolean isMaybe = rawType == Maybe.class;
//...
return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
isSingle, isMaybe, false);
}判断类型，在创建不同的 RxJava2CallAdapter 对象，实现了 CallAdapter 的两个方法。
final class RxJava2CallAdapter<R> implements CallAdapter<R, Object> {
private final Type responseType;
private final @Nullable Scheduler scheduler;
private final boolean isAsync;
//..
RxJava2CallAdapter(Type responseType, @Nullable Scheduler scheduler, boolean isAsync,
boolean isResult, boolean isBody, boolean isFlowable, boolean isSingle, boolean isMaybe,
boolean isCompletable) {
this.responseType = responseType;
this.scheduler = scheduler;
this.isAsync = isAsync;
//...
}
@Override public Type responseType() {
return responseType;
}
@Override public Object adapt(Call<R> call) {
//
}
}接下来调用 create 方法了。
mService = mRetrofit.create(getServiceClass());
protected Class<Service> getServiceClass() {
return (Class<Service>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
} public <T> T create(final Class<T> service) {
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(service);
}
return //**
}判断是否需要提前验证，eagerlyValidateMethods 就是给接口的注解进行解析并得到一个 ServiceMethod 对象，放入上文的 serviceMethodCache 中，存储起来。
private void eagerlyValidateMethods(Class<?> service) {
Platform platform = Platform.get();
for (Method method : service.getDeclaredMethods()) {
if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
loadServiceMethod(method);
}
}
}
ServiceMethod<?> loadServiceMethod(Method method) {
ServiceMethod<?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}重点看下 loadServiceMethod 方法，将遍历出来的方法 method 缓存 serviceMethodCache 中存在，则从缓存中取，缓存中没有则 ServiceMethod.parseAnnotations 解析，之后放入缓存。
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
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);
}它创建 RequestFactory 对象，内部也是 build 模式。
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
return new Builder(retrofit, method).build();
}
//Builder构造函数
Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
this.methodAnnotations = method.getAnnotations();
this.parameterTypes = method.getGenericParameterTypes();
this.parameterAnnotationsArray = method.getParameterAnnotations();
}getAnnotations 方法返回该方法上所有的注解。
getGenericParameterTypes 方法返回的是参数的参数化的类型，里面的带有实际的参数类型。
getParameterAnnotations 方法得到一个二维数组，因为参数前可以添加多个注解，一个参数上不可以添加相同的注解，同一个注解可以添加到不同的参数上。
RequestFactory.Build 的 build()，就是根据这数据去获取接口中的请求信息。
这里列举一个 GET 请求，看下接口中注解 GET 的去向，由 getAnnotations 解析出来 GET 了，接下来在 build() 中。
RequestFactory build() {
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
//...
}
private void parseMethodAnnotation(Annotation annotation) {
if (annotation instanceof DELETE) {
parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
} else if (annotation instanceof GET) {
parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
}
//...
isFormEncoded = true;
}
}
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
//...
this.httpMethod = httpMethod;
this.hasBody = hasBody;
if (value.isEmpty()) {
return;
}
//...
}将 GET 就转换成 httpMethod 了。
后续调用 HttpServiceMethod.parseAnnotations 将 retrofit、method、requestFactory 转成ServiceMethod 对象返回。
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
//...
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
//...
Type responseType = callAdapter.responseType();
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
//...
okhttp3.Call.Factory callFactory = retrofit.callFactory;
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
}这里面有几个重点方法：
createCallAdapter：根据网络接口方法的返回值和注解类型，从 Retrofit 对象中获取对应的网络请求适配器。这里类型是 RxJava 的话会返回 RxJava2CallAdapter。
private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
try {
return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) {
}
}
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
int start = callAdapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
}callAdapter.responseType()：根据网络请求接口方法的返回值和注解类型，从 Retrofit 中获取该网络适配器返回的数据类型。这里是 RxJava 适配的话，返回数据的 Type 类型。
@Override public Type responseType() {
return responseType;
}createResponseConverter：根据网络请求接口方法的返回值和注解类型，从 Retrofit 中获取对应的数据转换器。这里将获取的 Type 传入，如果是 Gson 的话返回的就是 GsonResponseBodyConverter 解析器。
private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
Retrofit retrofit, Method method, Type responseType) {
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.responseBodyConverter(responseType, annotations);
} catch (RuntimeException e) {
}
}
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
return nextResponseBodyConverter(null, type, annotations);
}
public <T> Converter<ResponseBody, T> nextResponseBodyConverter(
@Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
int start = converterFactories.indexOf(skipPast) + 1;
for (int i = start, count = converterFactories.size(); i < count; i++) {
Converter<ResponseBody, ?> converter =
converterFactories.get(i).responseBodyConverter(type, annotations, this);
if (converter != null) {
//noinspection unchecked
return (Converter<ResponseBody, T>) converter;
}
}
}将 requestFactory、callFactory、responseConverter、callAdapter 封装成 CallAdapted 对象返回。
这种是提前转化，如果没有提前验证的话，则进行动态解析对应的方法，得到 ServiceMethod 对象。
create方法之后的rerurn
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.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});通过动态代理创建网络请求接口的实例，创建了网络请求接口的动态代理对象，该动态代理为了拿到接口实例上面的所有注解。
上篇将了反射和静态代理，这篇看下动态代理的实现，调用 Proxy.newProxyInstance 函数，
第一个参数是接口的实现类，第二个参数是创建了接口实例，第三个参数是将代理类交给 InvocationHandler 作为具体的实现。
newProxyInstance 的具体代码实现这边就不贴了，它其实是getProxyClass(service.getClassLoader(), new Class<?>[] { service }).getConstructor(InvocationHandler.class).newInstance(new InvocationHandler(){});
getDeclaringClass 方法表示声明此method对象的方法的类的Class对象。
之后就再次调用 loadServiceMethod 方法去获取 ServiceMethod 对象。
之后的这里retrofit的版本不同，我这边是2.6.1的，这里调用的是 invoke 方法，实则调用到了HttpServiceMethod 里面。
@Override final @Nullable ReturnT invoke(Object[] args) {
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
return adapt(call, args);
}创建 Retrofit 里面封装的 Call 对象，调用 adapt 方法。
public interface Call<T> extends Cloneable {
Response<T> execute() throws IOException;
void enqueue(Callback<T> callback);
boolean isExecuted();
void cancel();
Call<T> clone();
Request request();
}这里的 OkHttpCall 实现了上面的 Call 接口，可以看到它里面有很多与 OkHttp 的方法名字类似的，实则 OkHttpCall 里面就是将之前获取的数据封装成 okhttp3.Call，调用 Okhttp 的方法去请求网络的。
static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
@Override protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
return callAdapter.adapt(call);
}
}如果我们是 RxJava2CallAdapter 的话。
@Override public Object adapt(Call<R> call) {
Observable<Response<R>> responseObservable = isAsync
? new CallEnqueueObservable<>(call)
: new CallExecuteObservable<>(call);
Observable<?> observable;
if (isResult) {
observable = new ResultObservable<>(responseObservable);
} else if (isBody) {
observable = new BodyObservable<>(responseObservable);
} else {
observable = responseObservable;
}
if (scheduler != null) {
observable = observable.subscribeOn(scheduler);
}
if (isFlowable) {
return observable.toFlowable(BackpressureStrategy.LATEST);
}
if (isSingle) {
return observable.singleOrError();
}
if (isMaybe) {
return observable.singleElement();
}
if (isCompletable) {
return observable.ignoreElements();
}
return RxJavaPlugins.onAssembly(observable);
}以泛型中 Flowable 为例，scheduler 为 null，isAsync 为 false，创建 CallExecuteObservable 的 Observable，执行 observable.toFlowable(BackpressureStrategy.LATEST)。实际我们的 mService.requestxxx(type) 就是创建了不同的被观察者。
这里看下 CallExecuteObservable。
final class CallExecuteObservable<T> extends Observable<Response<T>> {
private final Call<T> originalCall;
CallExecuteObservable(Call<T> originalCall) {
this.originalCall = originalCall;
}
}subscribeActual 在订阅时候触发。
@Override protected void subscribeActual(Observer<? super Response<T>> observer) {
Call<T> call = originalCall.clone();
CallDisposable disposable = new CallDisposable(call);
observer.onSubscribe(disposable);
//
boolean terminated = false;
try {
Response<T> response = call.execute();
if (!disposable.isDisposed()) {
observer.onNext(response);
}
if (!disposable.isDisposed()) {
terminated = true;
observer.onComplete();
}
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
//..
}
}执行了 call.execute() 同步请求的方法，异步和同步大家都理解，这里看下异步请求。
异步请求enqueue
调用 enqueue 可发送异步请求
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
okhttp3.Call call;
synchronized (this) {
call = rawCall;
failure = creationFailure;
call = rawCall = createRawCall();
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
//..
}
});
}通过 createRawCall 创建真正的 Okhttp 的 call 对象，调用 enqueue 去请求网络。
onResponse 中返回数据，即将开始根据 Retrofit 中的配置解析数据。
Response<T> response;
try {
response = parseResponse(rawResponse);
} catch (Throwable e) {
throwIfFatal(e);
callFailure(e);
return;
}
try {
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
throwIfFatal(t);
t.printStackTrace(); // TODO this is not great
}关注下 parseResponse
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
//错误判断
try {
T body = responseConverter.convert(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
}
}这里掉用 responseConverter 的 convert ，responseConverter 就是我们在创建 OkHttpCall 时传入的 Converter。解析后封装成一个 Retrofit 中定义的 Response 对象。
这里再关注下 DefaultCallAdapterFactory 这个默认的构造器创建出来的 CallAdapter，它的异步请求操作。
final Executor callbackExecutor;
final Call<T> delegate;
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
delegate.enqueue(new Callback<T>() {
@Override public void onResponse(Call<T> call, final Response<T> response) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
if (delegate.isCanceled()) {
callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
} else {
callback.onResponse(ExecutorCallbackCall.this, response);
}
}
});
}
@Override public void onFailure(Call<T> call, final Throwable t) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
callback.onFailure(ExecutorCallbackCall.this, t);
}
});
}
});
}如果都是默认的，它内部的 callbackExecutor 即我们开始看到的 MainThreadExecutor，它执行 execute 后切换到了主线程。
总结： Retrofit 使用建造者模式通过 Builder 类建立了一个 Retrofit 实例，可以配置平台类型对象、网络请求的 url 地址、网络请求工厂、OkHttpCall、网络请求适配器、数据转换器、回调方法执行器。通过动态代理解析网络请求接口的注解，配置网络请求参数，生成网络请求对象。最后执行网络请求。
Retrofit 中有很多设计模式，如
动态代理：动态创建网络请求接口的实例。
构建者：创建 Retrofit、创建 RequestFactory。
策略：通过解析网络请求接口方法的参数、返回值和注解类型，获取对应的网络请求的url地址、网络请求执行器、网络请求适配器、数据转换器。
装饰：retrofit 创建也是装饰模式。
工厂：网络请求适配器、数据转换器。
等等
扫一扫
174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
