title: retrofit源碼解析2.md
date: 2016-06-10
categories: android
tags: [retrofit]
使用
首先定義一個(gè)接口
public interface GitHubService {
@GET("users/{user}/repos")
Call<List<Repo>> listRepos(@Path("user") String user);
}
構(gòu)造Retrofit，實(shí)例化接口
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.build();
GitHubService service = retrofit.create(GitHubService.class);
Retrofit.Builder 是 Retrofit 對象的一個(gè)嵌套類，負(fù)責(zé)用來創(chuàng)建 Retrofit 實(shí)例對象，使用『建造者模式』的好處是清晰明了可定制化
執(zhí)行
Call<List<Repo>> repos = service.listRepos("octocat");
構(gòu)造出 repos可以同步執(zhí)行，或者異步
關(guān)于 Query & QueryMap URL 配置 Part & PartMap 等可以參考官方文檔
源碼分析
create()
由入口 retrofit.create()開始分析
public <T> T create(final Class<T> service) {
//校驗(yàn) service是否為注解
Utils.validateServiceInterface(service);
//如果將 validateEagerly 標(biāo)識設(shè)置為 True，那么在我們調(diào)用 .eagerlyValidateMethods(service) 方法之前就提前驗(yàn)證并創(chuàng)建好啦。
if (validateEagerly) {
eagerlyValidateMethods(service);
}
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
//得到Platform，這里得到的是Android，主要作用是在主線程的 Looper 并構(gòu)造了一個(gè) 主線程的 Handler，于是在 Android 平臺(tái)，調(diào)用 Callback 時(shí)會(huì)將該請求 post 到主線程上去執(zhí)行。
private final Platform platform = Platform.get();
@Override public Object invoke(Object proxy, Method method, 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);
}
//默認(rèn)是 false，是定義在接口中有默認(rèn)的實(shí)現(xiàn)，則返回 true
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
//在這里構(gòu)造了一個(gè) call
return loadMethodHandler(method).invoke(args);
}
});
}
用到了 java 的動(dòng)態(tài)代理，最終調(diào)用了 loadMethodHandler(method).invoke(args); 獲得了一個(gè)call，默認(rèn)為 OkHttpCall，之后可以用這個(gè)call 的enqueue、exctue等等來操作
build
繼續(xù)看看 retrofit 的 build方法
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(Platform.get().defaultCallAdapterFactory(callbackExecutor));
// Make a defensive copy of the converters.
List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
callbackExecutor, validateEagerly);
}
public Builder baseUrl(final 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);
}
return baseUrl(new BaseUrl() {
@Override public HttpUrl url() {
return baseUrl;
}
});
}
/**
* Set an API base URL which can change over time.
*
* @see #baseUrl(HttpUrl)
*/
public Builder baseUrl(BaseUrl baseUrl) {
this.baseUrl = checkNotNull(baseUrl, "baseUrl == null");
return this;
}
/** Add converter factory for serialization and deserialization of objects. */
public Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
/**
* Add a call adapter factory for supporting service method return types other than {@link
* Call}.
*/
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
adapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
/**
* The executor on which {@link Callback} methods are invoked when returning {@link Call} from
* your service method.
* <p>
* Note: {@code executor} is not used for {@linkplain #addCallAdapterFactory custom method
* return types}.
*/
public Builder callbackExecutor(Executor executor) {
this.callbackExecutor = checkNotNull(executor, "executor == null");
return this;
}
/**
* When calling {@link #create} on the resulting {@link Retrofit} instance, eagerly validate
* the configuration of all methods in the supplied interface.
*/
public Builder validateEagerly(boolean validateEagerly) {
this.validateEagerly = validateEagerly;
return this;
}
在使用Build模式時(shí)，將屬性 baseUrl、adapterFactories、converterFactories等賦值。在build()時(shí)構(gòu)造出retrofit實(shí)例返回
loadMethodHandler
MethodHandler loadMethodHandler(Method method) {
MethodHandler handler;
synchronized (methodHandlerCache) {
handler = methodHandlerCache.get(method);
if (handler == null) {
handler = MethodHandler.create(this, method);
methodHandlerCache.put(method, handler);
}
}
return handler;
}
解析對應(yīng)的方法（接口方法），創(chuàng)建 MethodHandler 加入到 methodHandlerCache 中，返回得到 MethodHandler。如果緩存里有則在methodHandlerCache拿到MethodHandler，若沒有，則通過MethodHandler.create(this, method)得到MethodHandler，并存入緩存
MethodHandler
正如之前所說在retrofit的creat方法中，最終調(diào)用的是 MethodHandler的invoke方法得到的一個(gè) call
Object invoke(Object... args) {
return callAdapter.adapt(
new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));
}
繼續(xù)看看 MethodHandler 中其他的方法
//MethodHandler 的創(chuàng)建方法，在這個(gè)方法里面通過創(chuàng)建 CallAdapter，responseConverter，requestFactory，最后創(chuàng)建 MethodHandler。
static MethodHandler create(Retrofit retrofit, Method method) {
CallAdapter<?> callAdapter = createCallAdapter(method, retrofit);
Type responseType = callAdapter.responseType();
if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw Utils.methodError(method, "'"
+ Types.getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
Converter<ResponseBody, ?> responseConverter =
createResponseConverter(method, retrofit, responseType);
//注意這里，RequestFactoryParser.parse根據(jù)注解生成 `RequestFactory` RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
return new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,
responseConverter);
}
//通過 retrofit 的 newCallAdapter 創(chuàng)建 CallAdapter
private static CallAdapter<?> createCallAdapter(Method method, Retrofit retrofit) {
Type returnType = method.getGenericReturnType();
if (Utils.hasUnresolvableType(returnType)) {
throw Utils.methodError(method,
"Method return type must not include a type variable or wildcard: %s", returnType);
}
if (returnType == void.class) {
throw Utils.methodError(method, "Service methods cannot return void.");
}
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw Utils.methodError(e, method, "Unable to create call adapter for %s", returnType);
}
}
//過 retrofit 的 responseConverter 方法得到 responseConverter
private static Converter<ResponseBody, ?> createResponseConverter(Method method,
Retrofit retrofit, Type responseType) {
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.responseBodyConverter(responseType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw Utils.methodError(e, method, "Unable to create converter for %s", responseType);
}
}
MethodHandler 是 retrofit 中連接了解析部分，執(zhí)行部分，轉(zhuǎn)換部分的一個(gè)關(guān)鍵的中間類。不過 MethodHandler 的代碼量很少。它可以說是連接各個(gè)部分的橋梁，也是接口方法的描述類。它有包含了 retrofit，requestFactory，callAdapter，responseConverter 成員變量。主要方法如下
callAdapter.adapt
最終是通過 callAdapter.adapt得到一個(gè) call 的，adapter 通過 adapt 把一種 call 適配成另一種 call供我們使用
ExecutorCallAdapterFactory
舉例分析ExecutorCallAdapterFactory
在get方法時(shí)，得到 CallAdapter的實(shí)例
@Override
public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
return new CallAdapter<Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public <R> Call<R> adapt(Call<R> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
注意 CallAdapt 的adapt 方法，這里構(gòu)造了一個(gè)call,
return new ExecutorCallbackCall<>(callbackExecutor, call);
這里有兩個(gè)參數(shù)，callbackExecutor ，call
-
callbackExecutor是platform傳入的，目的是為了 callback 能運(yùn)行在UI 線程，再回來看platform的代碼
static class Android extends Platform {
@Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
if (callbackExecutor == null) {
callbackExecutor = new MainThreadExecutor();
}
return new ExecutorCallAdapterFactory(callbackExecutor);
}
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
}
這個(gè)結(jié)構(gòu)體就是我們最后拿到的call，我們來看看他的結(jié)構(gòu)
static final class ExecutorCallbackCall<T> implements Call<T> {
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) {
delegate.enqueue(new Callback<T>() {
@Override public void onResponse(final Call<T> call, final Response<T> response) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
if (delegate.isCanceled()) {
// Emulate OkHttp's behavior of throwing/delivering an IOException on cancelation
callback.onFailure(call, new IOException("Canceled"));
} else {
callback.onResponse(call, response);
}
}
});
}
@Override public void onFailure(final Call<T> call, final Throwable t) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
callback.onFailure(call, t);
}
});
}
});
}
@Override public boolean isExecuted() {
return delegate.isExecuted();
}
@Override public Response<T> execute() throws IOException {
return delegate.execute();
}
@Override public void cancel() {
delegate.cancel();
}
@Override public boolean isCanceled() {
return delegate.isCanceled();
}
@SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
@Override public Call<T> clone() {
return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
}
@Override public Request request() {
return delegate.request();
}
}
正如之前所分析的，在異步執(zhí)行回調(diào)時(shí) onResponse、onFailure，使用了Executor來執(zhí)行，這樣我們的回調(diào)就運(yùn)行在了 UI 線程，我們甚至可以自定義Executor，運(yùn)行在我們希望的線程
這里的 execute、request等方法都是靜態(tài)代理模式，直接由構(gòu)造時(shí)傳入的call執(zhí)行
那么 call 是哪里傳入的？
再次回到 create中
Object invoke(Object... args) {
return callAdapter.adapt(
new OkHttpCall<>(callFactory, requestFactory, args, responseConverter));
}
可以看到最終執(zhí)行這些方法的是 new OkHttpCall<>(callFactory, requestFactory, args, responseConverter)
OkHttpCall
OkHttpCall是call的一個(gè)實(shí)現(xiàn)，其中 wrapper 了okhttp3.Call，最終的網(wǎng)絡(luò)請求是okhttp3去請求的，retrofit 本身沒有對網(wǎng)絡(luò)進(jìn)行請求的操作
構(gòu)造方法
OkHttpCall(okhttp3.Call.Factory callFactory, RequestFactory requestFactory, Object[] args,
Converter<ResponseBody, T> responseConverter) {
this.callFactory = callFactory;
this.requestFactory = requestFactory;
this.args = args;
this.responseConverter = responseConverter;
}
在構(gòu)造時(shí)requestFactory，responseConverter都已經(jīng)拿到了
舉例分析 execute
@Override public Response<T> execute() throws IOException {
okhttp3.Call call;
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
if (creationFailure != null) {
if (creationFailure instanceof IOException) {
throw (IOException) creationFailure;
} else {
throw (RuntimeException) creationFailure;
}
}
call = rawCall;
if (call == null) {
try {
call = rawCall = createRawCall();
} catch (IOException | RuntimeException e) {
creationFailure = e;
throw e;
}
}
}
if (canceled) {
call.cancel();
}
return parseResponse(call.execute());
}
-------------
private okhttp3.Call createRawCall() throws IOException {
okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
createRawCall得到了一個(gè) okhttp 的 call， callFactory在retrofit build 時(shí)默認(rèn)賦值為OkHttpClient，最好執(zhí)行的是okhttp 的 call 的 excute
繼續(xù)看執(zhí)行 excute 后的解析
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
// Remove the body's source (the only stateful object) so we can pass the response along.
rawResponse = rawResponse.newBuilder()
.body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
.build();
int code = rawResponse.code();
if (code < 200 || code >= 300) {
try {
// Buffer the entire body to avoid future I/O.
ResponseBody bufferedBody = Utils.buffer(rawBody);
return Response.error(bufferedBody, rawResponse);
} finally {
rawBody.close();
}
}
if (code == 204 || code == 205) {
return Response.success(null, rawResponse);
}
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
//這里完成了原始 Response 的解析，T 就是我們想要的結(jié)果,使用了responseConverter
T body = responseConverter.convert(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
// If the underlying source threw an exception, propagate that rather than indicating it was
// a runtime exception.
catchingBody.throwIfCaught();
throw e;
}
}
RxJavaCallAdapterFactory
看完了ExecutorCallAdapterFactory，繼續(xù)看看另一種實(shí)現(xiàn)RxJavaCallAdapterFactory
關(guān)鍵代碼
private CallAdapter<Observable<?>> getCallAdapter(Type returnType) {
Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
Class<?> rawObservableType = getRawType(observableType);
if (rawObservableType == Response.class) {
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Response must be parameterized"
+ " as Response<Foo> or Response<? extends Foo>");
}
Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
return new ResponseCallAdapter(responseType);
}
if (rawObservableType == Result.class) {
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Result must be parameterized"
+ " as Result<Foo> or Result<? extends Foo>");
}
Type responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
return new ResultCallAdapter(responseType);
}
return new SimpleCallAdapter(observableType);
}
根據(jù)返回的類型選擇不同的CallAdapter,選取SimpleCallAdapter領(lǐng)看看
static final class SimpleCallAdapter implements CallAdapter<Observable<?>> {
private final Type responseType;
SimpleCallAdapter(Type responseType) {
this.responseType = responseType;
}
@Override public Type responseType() {
return responseType;
}
@Override public <R> Observable<R> adapt(Call<R> call) {
return Observable.create(new CallOnSubscribe<>(call)) //
.flatMap(new Func1<Response<R>, Observable<R>>() {
@Override public Observable<R> call(Response<R> response) {
if (response.isSuccess()) {
return Observable.just(response.body());
}
return Observable.error(new HttpException(response));
}
});
}
}
通過一個(gè) flatMap，將 response 中的結(jié)構(gòu)發(fā)送出去。，。。最終返回的是一個(gè)Observable類型
最好來張圖總結(jié)下
圖片出自 https://github.com/android-cn/android-open-project-analysis/tree/master/tool-lib/network/retrofit
參考
http://blog.qiji.tech/archives/9546
http://www.itdecent.cn/p/07dac989272c
https://mp.weixin.qq.com/s?__biz=MzA3NTYzODYzMg==&mid=2653577186&idx=1&sn=1a5f6369faeb22b4b68ea39f25020d28&scene=0&key=f5c31ae61525f82eff1e94d54c4abd1c47958e9f7fe5751f2d201958841a354f0423e4ce98cb895058808f330921bde6&ascene=0&uin=MTYzMjY2MTE1&devicetype=iMac+MacBookPro10%2C1+OSX+OSX+10.11.4+build(15E65)&version=11020201&pass_ticket=rsJxex9Bn1eN7iJgW6FUI2KG3V9O6e3TH42j1U%2Fy5SU%3D
https://github.com/android-cn/android-open-project-analysis/tree/master/tool-lib/network/retrofit
http://www.tuicool.com/articles/UryUnyF
http://www.itdecent.cn/p/c1a3a881a144
