如果对retrofit使用不太了解的可以去网上查一些资料，本篇就直接对源码进行分析了。
一、首先你需要RestfulApi 类，里面声明了咱们的请求
public interface RestfulApi {
// 获取时间戳
@POST("app.do?")
Call<T> getTime(@Query("pattern") String pattern);
}然后封装Retrofit
public class HttpClient {
private RestfulApi apiService;
private OkHttpClient okHttpClient;
public HttpClient(Context context) {
okHttpClient = genericClient();
Retrofit retrofit = new Retrofit.Builder().baseUrl(AppEnvConstants.http_ip)
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient)
.build();
apiService = retrofit.create(RestfulApi.class);
}
// 创建OkHttpClient实例
private OkHttpClient genericClient() {
return new OkHttpClient.Builder().
addInterceptor(new HttpInterceptor())
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.build();
}
}然后调用异步接口就是
Call<T> call = apiService.getTime(pattern);
call.enqueue(callback);二、下边针对retrofit2进行源码分析
// 创建OkHttpClient实例
private OkHttpClient genericClient() {
return new OkHttpClient.Builder().
addInterceptor(new HttpInterceptor())
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.build();
}这一段代码很明显是对OkHttp中OkHttpClient的初始化,对OkHttp不了解可以看下
OkHttp3源码分析
Retrofit retrofit = new Retrofit.Builder().baseUrl(AppEnvConstants.http_ip)
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient)
.build();这一段代码是对Retrofit的初始化
addConverterFactory(GsonConverterFactory.create())//对返回的数据支持json格式解析client(okHttpClient)//设置okhttp3.Call.Factory callFactory = okHttpClient最主要的就是下面这段代码
apiService = retrofit.create(RestfulApi.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, 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)) {//Android/ios返回false，java8返回true
return platform.invokeDefaultMethod(method, service, proxy, args);
}
//组装ServiceMethod，里面有缓存，一样的方法只会执行一次，这个很大程度上优化了性能，因为反射是会消耗性能的
ServiceMethod serviceMethod = loadServiceMethod(method);
//传入的serviceMethod和参数
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}发现上面是典型的Java动态代理
看上面的注释，Android中一定会走到下面，直接分析下面重要代码
ServiceMethod serviceMethod = loadServiceMethod(method);ServiceMethod loadServiceMethod(Method method) {
ServiceMethod result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);//从缓存中获取serviceMethod
if (result == null) {
result = new ServiceMethod.Builder(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}由于动态代理是用的反射的原理，然而所有的反射都有性能消耗，这里对method进行了缓存，每个方法只会运行一次
private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();final修饰，引用地址不可变，这里用了LinkedHashMap表示不是很理解，LinkedHashMap底层是链表实现的，哪位朋友知道评论一下
//TODOServiceMethod里面的代码暂缓，等下再分析
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);看一下OkHttpCall的构造器
OkHttpCall(ServiceMethod<T> serviceMethod, Object[] args) {
this.serviceMethod = serviceMethod;
this.args = args;
}只是把刚声明的ServiceMethod和args参数传过去
serviceMethod.callAdapter.adapt(okHttpCall);三、分析问题
1、serviceMethod.callAdapter是什么？
2、serviceMethod.callAdapter.adapt(okHttpCall)是什么？
先分析一下第一个问题
首先看ServiceMethod的build()里
public ServiceMethod build() {
callAdapter = createCallAdapter()private CallAdapter<?> createCallAdapter() {
Type returnType = method.getGenericReturnType();
if (Utils.hasUnresolvableType(returnType)) {
throw methodError(
"Method return type must not include a type variable or wildcard: %s", returnType);
}
if (returnType == void.class) {
throw methodError("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 methodError(e, "Unable to create call adapter for %s", returnType);
}
}跑到了Retrofit类里
public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");
int start = adapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = adapterFactories.size(); i < count; i++) {
CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);//ExecutorCallAdapterFactory 执行
if (adapter != null) {
return adapter;
}
}
StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
.append(returnType)
.append(".\n");
if (skipPast != null) {
builder.append(" Skipped:");
for (int i = 0; i < start; i++) {
builder.append("\n * ").append(adapterFactories.get(i).getClass().getName());
}
builder.append('\n');
}
builder.append(" Tried:");
for (int i = start, count = adapterFactories.size(); i < count; i++) {
builder.append("\n * ").append(adapterFactories.get(i).getClass().getName());
}
throw new IllegalArgumentException(builder.toString());
}最后走到了nextCallAdapter里，然后看只是从adapterFactories里取数据，看一下adapterFactories是什么
看一下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();
}
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.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);
}
}重点看一下
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));看一下Android的Platform
static class Android extends Platform {
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
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);
}
}
}callbackExecutor = platform.defaultCallbackExecutor() = new MainThreadExecutor()；
由于MainThreadExecutor里的handler创建的Looper是主线程里的，so handler也是主线程（UI线程）里的，对Android的异步消息机制不了解的可以看下异步消息机制
看到没最后把UI线程赋值给了callbackExecutor
adapterFactories最后add的是ExecutorCallAdapterFactory
然后再回过头来
CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
//等同于
CallAdapter<?> adapter = ExecutorCallAdapterFactory.get(returnType, annotations, this);看一下ExecutorCallAdapterFactory类
final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
final Executor callbackExecutor;//MainThreadExecutor 主线程
ExecutorCallAdapterFactory(Executor callbackExecutor) {
this.callbackExecutor = callbackExecutor;
}
@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);
}
};
}
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;//okhttpCall
}
@Override public void enqueue(final Callback<T> callback) {
if (callback == null) throw new NullPointerException("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()) {
// Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
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);
}
});
}
});
}
@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();
}
}
}回过头来看一下问题
1、serviceMethod.callAdapter是什么？
2、serviceMethod.callAdapter.adapt(okHttpCall)是什么？
答案：
serviceMethod.callAdapter = ExecutorCallAdapterFactory.get(returnType, annotations, this);
callbackExecutor = MainThreadExecutor,这个是retrofit里传进来的
serviceMethod.callAdapter.adapt(okHttpCall) = ExecutorCallAdapterFactory.get(returnType, annotations, this).adapt(okHttpCall) = new ExecutorCallbackCall<>(callbackExecutor, okHttpCall) = new ExecutorCallbackCall<>(MainThreadExecutor, okHttpCall)
回过头来看一下我们业务层写的请求
Call<T> call = apiService.getTime(pattern);
call.enqueue(listener);call = serviceMethod.callAdapter.adapt(okHttpCall) = new ExecutorCallbackCall<>(MainThreadExecutor, okHttpCall)；
call.enqueue（callback） = ExecutorCallbackCall.enqueue（callback）
最后走到了OkHttpCall里，各位看官请看
delegate = OkHttpCall.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()) {
// Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
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);
}
});
}
});搞一段落，终于搞清楚了，最后代码会走到OkHttpCall.enqueue（）；
分析一下OkHttpCall.enqueue（）
@Override public void enqueue(final Callback<T> callback) {
if (callback == null) throw new NullPointerException("callback == null");
okhttp3.Call call;
Throwable failure;
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
call = rawCall;
failure = creationFailure;
if (call == null && failure == null) {
try {
call = rawCall = createRawCall();
} catch (Throwable t) {
failure = creationFailure = t;
}
}
}
if (failure != null) {
callback.onFailure(this, failure);
return;
}
if (canceled) {
call.cancel();
}
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
throws IOException {
Response<T> response;
try {
response = parseResponse(rawResponse);
} catch (Throwable e) {
callFailure(e);
return;
}
callSuccess(response);
}
@Override public void onFailure(okhttp3.Call call, IOException e) {
try {
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
private void callFailure(Throwable e) {
try {
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
private void callSuccess(Response<T> response) {
try {
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}private okhttp3.Call createRawCall() throws IOException {
Request request = serviceMethod.toRequest(args);
okhttp3.Call call = serviceMethod.callFactory.newCall(request);//serviceMethod.callFactory是okhttpClient
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}ServiceMethod的builder
ServiceMethod(Builder<T> builder) {
this.callFactory = builder.retrofit.callFactory();Retrofit里的
public Builder client(OkHttpClient client) {
return callFactory(checkNotNull(client, "client == null"));
}
/**
* Specify a custom call factory for creating {@link Call} instances.
* <p>
* Note: Calling {@link #client} automatically sets this value.
*/
public Builder callFactory(okhttp3.Call.Factory factory) {
this.callFactory = checkNotNull(factory, "factory == null");
return this;
}这里面的逻辑其实就是走到了OkHttp里的RealCall.enqueue，然后再解析，回调。
对OkHttp不是很了解可以看下OkHttp源码分析
对源码逻辑明白了，但是想一想设计者为什么要这样设计retrofit，你会学到的更多。
retrofit的设计模式这篇文章写的特别好。
盗用一下图
真的是很美妙啊啊……..
488
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
