用法：retrofit是怎么創建service接口實例的？
public interface GitHubService {
@GET("users/{user}/repos")
Call<List<Repo>> listRepos(@Path("user") String user);
}
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
GitHubService github = retrofit.create(GitHubService.class);
// Retrofit.class
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.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
args = args != null ? args : emptyArgs;
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args);
}
});
}
調用retrofit 的create方法，通過動態代理技術返回一個service接口的代理實例，之后對service接口的訪問，都會走到InvocationHandler#invoke()方法。
如果調用的是 Object 的方法，例如 equals，toString，那就直接調用。
如果是 default 方法（Java 8 引入），就調用 default 方法。
否則就通過loadServiceMethod(method).invoke(args)調用service的接口，拿到返回值。
// 生成的代理類：
class $Proxy0 extends Proxy implements GitHubApiService {
protected $Proxy0(InvocationHandler h) {
super(h);
}
// 調用interface的方法其實就是調用代理對象對應的方法，然后代理對象在對應的方法中調用InvocationHandler#invoke()
@Override
public void listRepos(String user) {
Method method = Class.forName("GitHubService").getMethod("listRepos", String.class);
super.h.invoke(this, method, new Object[]{user});
}
}
動態代理技術，簡而言之，就是動態生成接口的實現類（當然生成實現類有緩存機制），并創建其實例（稱之為代理），代理把對接口的調用轉發給 InvocationHandler 實例，而在 InvocationHandler 的實現中，除了執行真正的邏輯（例如再次轉發給真正的實現類對象），我們還可以進行一些有用的操作，例如統計執行時間、進行初始化和清理、對接口調用進行檢查等。
為什么要用動態代理？
因為對接口的所有方法的調用都會集中轉發到 InvocationHandler#invoke函數中，我們可以集中進行處理，更方便了。你可能會想，我也可以手寫這樣的代理類，把所有接口的調用都轉發到 InvocationHandler#invoke 呀，當然可以，但是可靠地自動生成豈不更方便？
// retrofit.class
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;
}
ServiceMethod
一個 ServiceMethod 對象對應于一個 API interface 的一個方法，Retrofit#loadServiceMethod(method)方法負責加載 ServiceMethod：
這里實現了緩存邏輯，同一個 API 的同一個方法，只會創建一次。這里由于我們每次獲取 API 實例都是傳入的 class 對象，而 class 對象是進程內單例的，所以獲取到它的同一個方法 Method 實例也是單例的，所以這里的緩存是有效的。
// ServiceMethod.java
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
// 獲取方法的注解、參數的注解、參數的類型，得到http的請求方式、請求參數、請求頭，baseUrl，relativeUrl等，包裝成RequestFactory
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.");
}
// 將RequestFactory傳給HttpServiceMethod，返回一個HttpServiceMethod
// 之后在ServiceMethod#loadServiceMethod中會調用HttpServiceMethod#invoke()方法，在invoke方法中創建OkHttpCall時將RequestFactory傳給OkHttpCall，在OkHttpCall的enqueue方法中，會通過RequestFactory的create方法創建一個okhttp.Request
// 另外callFactory、callAdapter、responseConverter都是在parseAnnotations中被賦值給HttpServiceMethod的
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
retrofit通過getGenericReturnType來獲取類型信息。
jdk的class、Method、Field類提供了一系列獲取 泛型類型 的相關方法。
以Method為例，getGenericReturnType獲取帶泛型信息的返回類型，getGenericParameterTypes獲取帶泛型信息的參數類型。
具體看Retrofit/gson是怎么獲取泛型擦除后的類型的
ServiceMethod#parseAnnotations(...)調用HttpServiceMethod#parseAnnotations()生成對應的HttpServiceMethod的子類：
// HttpServiceMethod.class
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
...
if (isKotlinSuspendFunction) {
// 獲取kotlin suspend 方法的adapterType
} else {
adapterType = method.getGenericReturnType();
}
// 創建CallAdapter
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
...
Type responseType = callAdapter.responseType();
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
// 從retrofit獲取callFactory，并傳給HttpServiceMethod的子類，后面要用它來創建OkHttpCall
okhttp3.Call.Factory callFactory = retrofit.callFactory;
if (!isKotlinSuspendFunction) {
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
} else if (continuationWantsResponse) {
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForResponse<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForBody<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable);
}
}
private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
}
private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
Retrofit retrofit, Method method, Type responseType) {
return retrofit.responseBodyConverter(responseType, annotations);
}
ServiceMethod#parseAnnotations()返回了一個HttpServiceMethod的子類實例后，調用了HttpServiceMethod#invoke()方法：
// HttpServiceMethod.class
@Override
final @Nullable ReturnT invoke(Object[] args) {
// args參數是GitHubService里邊方法的參數
// 創建了OkHttpCall對象，就是GitHubService里邊方法的返回值Call對象
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
return adapt(call, args);
}
HttpServiceMethod有3個子類：CallAdapted<ResponseT, ReturnT>、SuspendForResponse<ResponseT>、SuspendForBody<ResponseT>
static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT>
static final class SuspendForResponse<ResponseT> extends HttpServiceMethod<ResponseT, Object>
static final class SuspendForBody<ResponseT> extends HttpServiceMethod<ResponseT, Object>
在不使用 Kotlin 協程的情況下，其實調用的是子類 CallAdapted 的 adapt方法
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);
}
}
Retrofit的OkHttpCall是如何做網絡請求的？
// OkHttpCall.class
public void enqueue(final Callback<T> callback) {
...
call = rawCall = createRawCall();
...
call.enqueue(new okhttp3.Callback() {
@Override
public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
// 省略部分try catch代碼
// 解析相應數據，將OkHttp.Response轉換成Rerofit.Response
Response<T> response = parseResponse(rawResponse);
callback.onResponse(OkHttpCall.this, response);
}
// 省略onFailure()的代碼
}
}
private okhttp3.Call createRawCall() throws IOException {
// callFactory 和 requestFactory在HttpServiceMethod#parseAnnotations中被賦值的
// requestFactory.create(args)創建okhttp.Request對象
// callFactory是okHttpClient，newCall(request)創建RealCall對象
okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
requestFactory
在ServiceMethod#parseAnnotations中調用，負責解析service中對應方法的注解、參數的注解、參數的類型，得到http的請求方式、請求參數、請求頭，baseUrl，relativeUrl等，包裝成RequestFactory。
// RequestFactory.class
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
return new Builder(retrofit, method).build();
}
// RequestFactory.Builder.class
Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
// 獲取方法上的注解
this.methodAnnotations = method.getAnnotations();
// 獲取參數類型
this.parameterTypes = method.getGenericParameterTypes();
// 獲取參數上的注解
this.parameterAnnotationsArray = method.getParameterAnnotations();
}
RequestFactory build(){
for (Annotation annotation : methodAnnotations) {
// 解析并保存方法上的注解
parseMethodAnnotation(annotation);
}
...
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
// 解析并保存方法參數上的注解
parameterHandlers[p] = parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
}
...
return new RequestFactory(this);
}
// 解析方法上的注解，如: @GET
private void parseMethodAnnotation(Annotation annotation) {
if (annotation instanceof DELETE) {
parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
} else if (annotation instanceof GET) {
.. 其他類似，省略
}
}
// 解析方法上的注解以及對應的value中的路徑，如：@GET("listRepos")，則會將GET、listRepos保存起來
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
...
// 保存http請求方式
this.httpMethod = httpMethod;
this.hasBody = hasBody;
if (value.isEmpty()) {
return;
}
...
// 保存請求路徑
this.relativeUrl = value;
// 解析路徑中的參數并保存在Set中
this.relativeUrlParamNames = parsePathParameters(value);
}
// 解析路徑中的參數，例如：@GET("users/{id}")，則解析路徑中的id，并保存在set中
static Set<String> parsePathParameters(String path) {
Matcher m = PARAM_URL_REGEX.matcher(path);
Set<String> patterns = new LinkedHashSet<>();
while (m.find()) {
patterns.add(m.group(1));
}
return patterns;
}
// 解析方法的參數上的注解，根據方法的參數下標（第幾個參數）、參數類型、參數的注解等，返回對應的ParameterHandler
private @Nullable ParameterHandler<?> parseParameter(
int p, Type parameterType, @Nullable Annotation[] annotations, boolean allowContinuation) {
ParameterHandler<?> result = null;
if (annotations != null) {
for (Annotation annotation : annotations) {
// 遍歷解析參數的注解，就是 @Path @Query @Field 等注解
ParameterHandler<?> annotationAction =
parseParameterAnnotation(p, parameterType, annotations, annotation);
if (annotationAction == null) {
continue;
}
result = annotationAction;
}
}
if (result == null) {
// 如果是kotlin的suspend方法，則方法的最后一個參數是Continuation
// 如果是方法的最后一個參數，allowContinuation為true
if (allowContinuation) {
try {
// 如果最后一個參數是Continuation，則說明是suspend函數，將isKotlinSuspendFunction設為true，后面在HttpServiceMethod#parseAnnotations()中會根據isKotlinSuspendFunction判斷返回HttpServiceMethod子類的類型
if (Utils.getRawType(parameterType) == Continuation.class) {
isKotlinSuspendFunction = true;
return null;
}
} catch (NoClassDefFoundError ignored) {
}
}
throw parameterError(method, p, "No Retrofit annotation found.");
}
return result;
}
// 將方法的參數類型、參數的注解、參數值等，封裝成對應的ParameterHandler并返回
private ParameterHandler<?> parseParameterAnnotation(
int p, Type type, Annotation[] annotations, Annotation annotation) {
if (annotation instanceof Url) {
// 返回@URL對應的ParameterHandler，即ParameterHandler.RelativeUrl
if (type == HttpUrl.class
|| type == String.class
|| type == URI.class
|| (type instanceof Class && "android.net.Uri".equals(((Class<?>) type).getName()))) {
return new ParameterHandler.RelativeUrl(method, p);
}
} else if(annotation instanceof Path){
// 返回@PATH對應的ParameterHandler，即ParameterHandler.Path
Path path = (Path) annotation;
String name = path.value();
validatePathName(p, name);
Converter<?, String> converter = retrofit.stringConverter(type, annotations);
return new ParameterHandler.Path<>(method, p, name, converter, path.encoded());
} else if(...){
...
}
}
callFactory
負責創建 HTTP 請求，HTTP 請求被抽象為了 okhttp3.Call 類，它表示一個已經準備好，可以隨時執行的 HTTP 請求。
// Retrofit.Builder.class
public Builder client(OkHttpClient client) {
return callFactory(Objects.requireNonNull(client, "client == null"));
}
// OkHttpClient implements okhttp3.Call.Factory
public Builder callFactory(okhttp3.Call.Factory factory) {
this.callFactory = Objects.requireNonNull(factory, "factory == null");
return this;
}
public Retrofit build() {
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
return new Retrofit(
callFactory,
baseUrl,
unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories),
callbackExecutor,
validateEagerly);
}
所以，Retrofit.callFactory是OkHttpClient。
callAdapter
在HttpServiceMethod#parseAnnotation中創建
// HttpServiceMethod.class
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
...
if (isKotlinSuspendFunction) {
// 獲取kotlin suspend 方法的adapterType
} else {
adapterType = method.getGenericReturnType();
}
// 創建CallAdapter
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
Type responseType = callAdapter.responseType();
...
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
// 從retrofit獲取callFactory，并傳給HttpServiceMethod的子類，后面要用它來創建OkHttpCall
okhttp3.Call.Factory callFactory = retrofit.callFactory;
if (!isKotlinSuspendFunction) {
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
} else if (continuationWantsResponse) {
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForResponse<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForBody<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable);
}
}
private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
}
private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
Retrofit retrofit, Method method, Type responseType) {
return retrofit.responseBodyConverter(responseType, annotations);
}
// Retrofit.class
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
public CallAdapter<?, ?> nextCallAdapter(
CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {
// callAdapterFactories會在調用Retrofit.Builder#addCallAdapterFactory(CallAdapter.Factory)時添加CallAdapterFactory，例如：builder.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
// 找到第一個開始遍歷的CallAdapterFactory
int start = callAdapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
// CallAdapterFactory根據返回類型拿到CallAdapter，之后會在HttpServiceMethod#invoke中調用對應子類的adapt()方法，然后就會調用CallAdapter#adapt()方法
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
}
adapt()方法會把 retrofit2.Call<R> 轉為 其他類型<R>，例如Observable<R>（注意將 retrofit2.Call 和 okhttp3.Call 區分開來，retrofit2.Call 表示的是對一個 Retrofit 方法的調用），如果沒有給retrofit添加CallAdapter.Factory，會有個默認的factory，在adapt(call, args)中返回Call<R>。
之后會通過adapt(call, args)返回的類進行網絡請求，如果返回的是個Call<R>對象，則直接調用enqueue(callback)方法進行網絡請求，其他類似，例如返回的是Observable<R>(ps: Call<R>被包裝在了Observable中 )，在subscribe()中會調用call.enqueue(callback)進行網絡請求，然后在callback的onResponse中調用observer的onNext(response)和onComplete()，在onFailure()中調用observer.onError(throwable)。
如何支持 Kotlin 協程的 suspend 掛起函數的？
- 通過 RequestFactory 解析方法上的最后一個參數是否Continuation，來判斷是不是一個掛起函數，是的話把 isKotlinSuspendFunction 變量置為 true
- 根據 isKotlinSuspendFunction 這個變量來判斷響應類型是否是 Response 類型，是的話把continuationWantsResponse 置為 true
- 根據 continuationWantsResponse 這個變量，來返回 SuspendForResponse對象，還是SuspendForBody對象
- 如果是SuspendForResponse對象，后面調用 SuspendForResponse 的 adapt方法時，通過 Call 的擴展函數awaitResponse()，來調用 Call 的 enqueue方法
- 請求結束后通過協程來返回
static final class SuspendForResponse<ResponseT> extends HttpServiceMethod<ResponseT, Object> {
private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;
@Override
protected Object adapt(Call<ResponseT> call, Object[] args) {
// 如果沒有添加額外的CallAdpter.Factory的話，默認的factory返回的adapter會通過adapt返回原來的call對象
call = callAdapter.adapt(call);
// kotlin的suspend函數經過編譯后，在方法的參數列表里面會多一個Continuation參數，在最后一個參數的位置
Continuation<Response<ResponseT>> continuation =
(Continuation<Response<ResponseT>>) args[args.length - 1];
try {
// 調用suspend Call<T>.awaitResponse(): Retrofit.Resonse<T>，獲取網絡請求結果
return KotlinExtensions.awaitResponse(call, continuation);
} catch (Exception e) {
return KotlinExtensions.suspendAndThrow(e, continuation);
}
}
}
// KotlinExtensions.class
suspend fun <T> Call<T>.awaitResponse(): Response<T> {
return suspendCancellableCoroutine { continuation ->
continuation.invokeOnCancellation {
cancel()
}
// 調用Retrofit.Call#enquque(Retrofit.Callback)進行網絡請求
enqueue(object : Callback<T> {
override fun onResponse(call: Call<T>, response: Response<T>) {
// 通過continuation.resume()將網絡請求結果回調到調用該方法的地方，即SuspendForResponse#adapt()
continuation.resume(response)
}
override fun onFailure(call: Call<T>, t: Throwable) {
continuation.resumeWithException(t)
}
})
}
}
responseConverter
請求響應結果是如何解析的？
在前面章節“Retrofit的OkHttpCall是如何做網絡請求的？”中，可以看到在retrofit.call#enqueue(retrofit.callback)的callback#onResponse()中，調用了parseResponse(response)
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
// ...不需要ResponseBody的情況
ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
// 使用ResponseConverter將ResponseBody轉化為我們需要的類型
T body = responseConverter.convert(catchingBody);
// 將我們需要的類型和okhttp.Response包裝成retrofit.Response
return Response.success(body, rawResponse);
}
responseConverter賦值過程
類似于callAdapter，在HttpServiceMethod#parseAnnotation中創建
//OkHttpCall.java
private final Converter<ResponseBody, T> responseConverter;
OkHttpCall(
RequestFactory requestFactory,
Object[] args,
okhttp3.Call.Factory callFactory,
Converter<ResponseBody, T> responseConverter) {
this.requestFactory = requestFactory;
this.args = args;
this.callFactory = callFactory;
//在構造中賦值
this.responseConverter = responseConverter;
}
// OkHttpCall 在 HttpServiceMethod#invoke()中實例化
//注意換類了
//HttpServiceMethod.java
private final Converter<ResponseBody, ResponseT> responseConverter;
HttpServiceMethod(
RequestFactory requestFactory,
okhttp3.Call.Factory callFactory,
Converter<ResponseBody, ResponseT> responseConverter) {
this.requestFactory = requestFactory;
this.callFactory = callFactory;
//在構造中賦值
this.responseConverter = responseConverter;
}
@Override
final @Nullable ReturnT invoke(Object[] args) {
// 構造OkHttpCall
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
return adapt(call, args);
}
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
...
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
// 1 實例化responseConverter
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;
// 實例化HttpServiceMethod的子類，傳入responseConverter
if (!isKotlinSuspendFunction) {
//2 CallAdapted的實例化賦值
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
}
...
}
private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
Retrofit retrofit, Method method, Type responseType) {
Annotation[] annotations = method.getAnnotations();
//調用的是 retrofit的方法
return retrofit.responseBodyConverter(responseType, annotations);
}
// Retrofit.java
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) {
// 找到第一個開始遍歷的ConverterFactory
int start = converterFactories.indexOf(skipPast) + 1;
for (int i = start, count = converterFactories.size(); i < count; i++) {
// 從ConverterFactory中根據 responseType返回值類型 來取到對應的 Converter，如果不為空，直接返回此 Converter 對象，后續就用這個Converter轉換數據類型；如果為空，則取下一個ConverterFactory繼續判斷是否能取到Converter
// 在Retrofit.parseResponse(okhttp.Response)中調用Converter#convert(responseBody)，將ResponseBody轉化為需要的數據類型
// 例如通常我們會在Service的方法中返回Call<BaseResponse<User>>，我們可以自定義Converter，“脫去”BaseResponse，直接返回User，這樣我們就可以在Service的方法中聲明返回Call<User>
// converterFactories會在調用Retrofit.Builder#addConverterFactory(Converter.Factory)時添加Converter.Factory，例如：builder.addConverterFactory(GsonConverterFactory.create())
)
Converter<ResponseBody, ?> converter = converterFactories.get(i).responseBodyConverter(type, annotations, this);
if (converter != null) {
return (Converter<ResponseBody, T>) converter;
}
}
}
注意：是怎么找到ConverterFactory來調用 Converter 的 convert方法的呢？ 在遍歷converterFactories時會根據 responseType來找到對應的Converter，如果responseType能被識別處理，則ConverterFactory返回Converter，否則ConverterFactory返回null，之后繼續遍歷converterFactories，取下一個ConverterFactory來獲取Converter。
看一下 converterFactories 這個對象的賦值過程
//Retrofit.java
final List<Converter.Factory> converterFactories;
Retrofit(
okhttp3.Call.Factory callFactory,
HttpUrl baseUrl,
List<Converter.Factory> converterFactories,
List<CallAdapter.Factory> callAdapterFactories,
@Nullable Executor callbackExecutor,
boolean validateEagerly) {
this.callFactory = callFactory;
this.baseUrl = baseUrl;
this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
//通過 Retrofit 的構造賦值，Retrofit的 初始化是通過內部 Builder 類的build方法
this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
this.callbackExecutor = callbackExecutor;
this.validateEagerly = validateEagerly;
}
//Retrofit.java 內部類 Builder 類的build方法
//Builder.java
public Retrofit build() {
...
List<Converter.Factory> converterFactories =
new ArrayList<>(
1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
// 添加默認的構建的轉換器，如果Service的方法用@STREAMING修飾，則返回StreamingResponseBodyConverter，否則返回BufferingResponseBodyConverter
converterFactories.add(new BuiltInConverters());
// 加入我們自己添加的ConverterFactory，例如addConverterFactory(GsonConverterFactory.create())
converterFactories.addAll(this.converterFactories);
// 如果是 Java8(Android sdk >= 24) 就是一個 OptionalConverterFactory 的轉換器，否則就是一個空列表converterFactories.addAll(platform.defaultConverterFactories));
return new Retrofit(
callFactory,
baseUrl,
unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories),
callbackExecutor,
validateEagerly);
}
parameterHandlers
內部封裝了參數類型、參數的注解、參數值等值。詳見RequestFactory一節。
Retrofit使用流程
Retrofit創建代理類流程
Retrofit請求過程
Retrofit請求結果轉換過程
Type的類型
也可以參考這篇文章
Retrofit整個請求流程是怎樣的？
1、我們在調用Retrofit.create(GithubService.class)時生成代理對象，代理對象持有InvocationHandler
2、當我們調用代理對象的方法時，會調用Invocation#invoke方法
3、在Invocation#invoke方法中，會調用Retrofit#loadServiceMethod方法，在該方法中會調用RequestFactory#parseAnnotations()解析代理方法的參數；會調用HttpServiceMethod#parseAnnotations()根據方法類型生成不同的子類。
4、之后調用HttpServiceMethod#invoke方法，在該方法中會生成OkHttpCall對象，然后調用HttpServiceMethod子類的adapt()方法，將Call對象轉換成用戶想要的類型，例如Observable，默認還是返回OkHttpCall
5、之后會調用OkHttpCall#enqueue(retrofit.callback)方法，在該方法中會通過RequestFactory創建一個okhttp.Request對象，并通過CallFactory.newCall(okhttp.Request)創建一個okhttp.Call對象，之后就是通過okhttp.Call#enqueue(okhttp.Callback)進行網絡請求
6、請求成功后會通過Converter將服務端返回的數據轉換成用戶感興趣的數據類型，并回調retrofit.callback接口
參考鏈接：一定能看懂的 Retrofit 最詳細的源碼解析！
什么是動態代理？
動態代理就是指運行期，創建一個代理類，代理類與委托類實現了相同的接口，代理類主要負責為委托類預處理、過濾、轉發，以及事后處理等。代理類與委托類之間通常會存在關聯關系，一個代理類的實例與它的委托類的實例是關聯的。代理類的實例本身是并不真正關心被調用方法的內部邏輯，而是會通過內部訪問 調用 委托類的實例真正實現了的方法，來為調用者提供服務。
動態代理實現原理
在內存中動態生成的代理類，不但繼承了Proxy類，還實現了和委托類相同的接口，并持有了InvocationHandler，當調用代理類的方法時，在方法中會調用InvocationHandler#invoke方法。
而InvocationHandler構建時持有了委托類的實例，當InvocationHandler#invoke方法被調用時，會調用委托類對應的方法，這樣就實現了代理實例執行委托實例的方法。參考這里
