Retrofit是用在网络请求中非常常用的一个库,这里从2.5.0版本
的源码去分析一下它的工作机制。看看它实际做了什么事情以及和okhttp的关系。由于本人水平有限,不喜勿喷。
使用介绍
直接上代码,下面是Retrofit最简单的使用方法
public interface GitHubService {
@GET("users/{user}/repos")
Call<List<Repo>> listRepos(@Path("user") String user);
}
//创建Retrofit对象
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
//生成接口的动态代理类
GitHubService service = retrofit.create(GitHubService.class);
//调用接口方法生成返回值对象
Call<List<Repo>> repos = service.listRepos("octocat");
//异步请求方法,加入队列返回结果
repos.enqueue(new Callback<List<Repo>>() {
@Override
public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
}
@Override
public void onFailure(Call<List<Repo>> call, Throwable t) {
}
});
以上就是Retrofit的最简单的异步调用,流程大概分为
1. 首先要定义请求的接口,用注解说明请求方法类型和接口参数
2. 用Builder模式创建Retrofit对象,这里可以添加baseUrl、添加数据解析类(Converter)、数据转换类(CallAdapter)等
3. 用动态代理生成1步骤中定义的接口的代理类
4. 调用接口方法生成Call对象,将Call对象加入队列,等待结果回调。
我一般看源码是从离用户最近的调用开始看的,这里就是4步骤中的enqueue
方法,但是点进去之后发现enqueue
是一个接口方法,所以可以确定是一个实现类调用了这边,这里走不通。往上走看create
方法
public <T> T create(final Class<T> service) {
//1. 验证是否是接口类型
Utils.validateServiceInterface(service);
//2. 这里是一个用于提前测试调用性能的方法,可以观察极端情况下的调用时间等
if (validateEagerly) {
eagerlyValidateMethods(service);
}
//3. 用动态代理生成类实例
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 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);
}
});
}
这里的代码大概可以分为三部分
- 验证传入的类是否为接口类,并且是不能有继承的接口,否则会抛出异常
- 字面意思是急切的验证方法,这里主要用于测试,在接口声明的方法很多时可能会影响性能,可以提前发现问题
- 返回一个service实例,也就是接口实例,这里面用到了动态代理的方法来产生实例
动态代理
我们先说一下动态代理是什么,Proxy.newProxyInstance
是生成动态代理的方法,这个要传入三个参数,第一个是类加载器,第二个是要生成动态代理的类,第三个是一个回调。动态代理有什么特点呢?就是动态代理类所有方法的调用都会回调到第三个参数的回调invoke
方法里面,包括继承的方法等(hashCode、equals、toString等
)。
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
我们再看看invoke
方法
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable;
这个方法的参数包括代理对象,调用方法,方法参数,说白了就是方法里面的所有信息都会回调到这里。一般用动态代理是为了对调用方法作某种统一处理,比如信息验证、Log打印等,Retrofit用动态代理是为了统一处理注解,生成okhttp的Call对象。我们看动态代理里面的代码
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
//1. 这个是一个和平台相关的类
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
// If the method is a method from Object then defer to normal invocation.
// 2.如果方法是Object的方法,让它走正常调用流程
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
// 默认方法的处理
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
// 3. 其实核心的代码是这一句
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});
所有在Interface里面定义的接口请求都会经过上面的拦截,这里面大概也可以分为三部分
- 首先要知道Retrofit可以用在Android和Java,
Platform
是一个和平台相关的类,它的子类有Android
和Java8
,Platform
主要就是处理和平台相关的逻辑的。 - 这部分代码主要是防止对Object类的方法的干扰,包括
toString、hashCode、equals
等,让这些方法该怎么样就怎么样。 - 这行代码才是真正做事情的,返回的是你在接口定义的方法的返回值,
invoke
是ServiceMethod
类中的一个抽象方法,要看实现类
ServiceMethod<?> loadServiceMethod(Method method) {
//从缓存中取得ServiceMethod实例
ServiceMethod<?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
//如果缓存不存在就去生成,然后放进缓存
if (result == null) {
//生成ServiceMethod对象
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}
loadServiceMethod
的逻辑很简单,方法传入的是从动态代理获得的Method
,里面的逻辑从缓存取得ServiceMethod
对象,如果没有缓存则生成一个
ServiceMethod
ServiceMethod
是一个抽象类,它相对于是一个中间人的作用,是用户调用和真正实现的一个中介,这里面会把网络请求需要的参数和回调准备好给Okhtt使用,并且把网络请求结果返回给用户。
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//处理注解生成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.");
}
//生成ServiceMethod对象
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
这是生成ServiceMethod
对象的方法,参数是Retrofit和Method对象,这个方法把生成ServiceMethod
的工作委托给了HttpServiceMethod类,其中的RequestFactory.parseAnnotations(retrofit, method)
是用来解析注解的地方,RequestFactory
保存了解析后的参数,然后把这个对象往下传递,具体的流程可以自己去看一下。
HttpServiceMethod
继续往下走,HttpServiceMethod
是 ServiceMethod
的唯一的子类,所以它就是干事情的地方,到这里我们大概就知道了在动态代理最后调用的invoke
方法就是HttpServiceMethod
方法。
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
//生成 CallAdapter方法
CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method);
Type responseType = callAdapter.responseType();
if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw methodError(method, "'"
+ Utils.getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
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);
//生成okhttpClient
okhttp3.Call.Factory callFactory = retrofit.callFactory;
//生成ServiceMethod实例并返回到
return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter);
}
这是生成ServiceMethod
对象的方法,因为HttpServiceMethod
是ServiceMethod
的子类,这个方法里面生成了几个重要的参数
1. callAdapter
用于对请求结果进行包装的类,它可以说是Retrofit最核心的设计,下面会进行分析
2. responseConverter
用于数据解析的类,比如你可以指定想要的数据是Gson、xml、String等,它也是Retrofit的核心设计
3. callFactory
实际上就是OkHttpClient对象
4. RequestFactory
用于保存注解解析后的值,已经在 ServiceMethod
创建出来了。
上面这四个参数中的前三个默认值在Retrofit的build方法中赋值的,这四个参数各司其职,实际上这里已经为网络请求准备好了所有的条件,这里直接看invoke
方法。
@Override ReturnT invoke(Object[] args) {
return callAdapter.adapt(
new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}
invoke
方法代码非常简单,用了适配者模式,适配者模式通常是把一种对象适配成另一种对象,或者相同对象之间的转换。这里就是把OkHttpCall
对象通过callAdapter转换成接口的返回值(我们定义的是Retrofit的Call对象)并且返回。这里我们可以先去分析OkHttpCall
类,通过它我们大概就知道这个适配到底是用来干什么的。
OkHttpCall
OkHttpCall
是Call接口的子类,上一个步骤中创建的2、3、4参数都会传递到这里来,而Call
就是我们在步骤1中定义的Call<List<Repo>>
的对象,OkHttpCall
里面定义了调用Okhttp进行网络请求的方法,有异步请求enqueue
方法和同步请求execute
方法,我们在步骤4中就是通过enqueue
方法得到请求结果的,我们具体看看enqueue
方法
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
//okhttp里面的Call对象
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 {
//1.生成okhttp的Call对象
call = rawCall = createRawCall();
} catch (Throwable t) {
throwIfFatal(t);
failure = creationFailure = t;
}
}
}
if (failure != null) {
callback.onFailure(this, failure);
return;
}
if (canceled) {
call.cancel();
}
//2.执行okhttp的请求
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
try {
//3.得到结果
response = parseResponse(rawResponse);
} catch (Throwable e) {
throwIfFatal(e);
callFailure(e);
return;
}
try {
//4.把成功的请求结果回调出去
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
@Override public void onFailure(okhttp3.Call call, IOException e) {
callFailure(e);
}
private void callFailure(Throwable e) {
try {
//把失败的请求结果回调出去
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
上面的代码的核心大概可以分为4部分
1. 生成okhttp3.Call
对象,注意这个Call和Retrofit的Call不是同一个类,这里是把保存了注解参数的requestFactory
转换成okhttp的call对象,详细的转换过程这里不分析
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;
}
2. 这部分实际上是okhttp的使用,通过生成的okhttp3.Call
对象进行异步的网络请求
3. 通过parseResponse
方法对结果进行转换,根据你定义的返回类型解析成相应的数据类型,比如Json格式,xml格式等
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
...
try {
//通过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;
}
}
上面已经说到responseConverter
是一个数据解析类,这里就是对请求结果进行解析的地方。
4. 把请求成功和失败的结果回调出去。
CallAdapter
到这里已经进行请求,数据已经解析,并且解析后的结果已经回调出去了,似乎不需要再处理什么了,但是这段代码里面的适配到底是做什么的呢?我们找到callAdapter的实例就能知道这个适配做了什么
@Override ReturnT invoke(Object[] args) {
return callAdapter.adapt(
new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}
追踪callAdapter还是来到了Retrofit的bulid方法
public Retrofit build() {
...
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
//calladapter的默认实现
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
...
return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}
这里面的默认实现是根据不同平台来处理的,我们之间看Android
类里面的实现
@Override List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
@Nullable Executor callbackExecutor) {
if (callbackExecutor == null) throw new AssertionError();
//默认的callAdapter
ExecutorCallAdapterFactory executorFactory = new ExecutorCallAdapterFactory(callbackExecutor);
return Build.VERSION.SDK_INT >= 24
? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
: singletonList(executorFactory);
}
@Override public @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
return new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
//适配者中的adapter方法,call就是OkHttpCall
@Override public Call<Object> adapt(Call<Object> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
这段代码是从callAdapterFactories
获得callAdapter
的方法,里面的返回值ExecutorCallbackCall
就是用来适配的callAdapter
对象,里面的adapt
方法就是适配OkHttpCall里面的那个方法
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
//调用OkHttpCall里面的enqueue方法,取得结果
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);
}
});
}
});
}
callbackExecutor
的实现类在Platform
的 Android
子类中,它会把结果通Handler把结果发送回主线程。callbackExecutor
的默认实现如下
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
但是CallAdapter在默认情况下是用来线程切换的,但是它不仅仅是线程切换,它的适配者设计机制是可插拔的,允许不同的执行机制来执行http调用,比如转换的Rxjava的Observable
, Flowable
, Single
, Completable
, Maybe
对象,这里是现今一些流行库流行库的支持。如果官方的CallAdapter不能满足你的要求,你可以自定义一个CallAdapter,比如自定义一个LiveData
类型的CallAdapter。
总结
根据上面的分析,其实Retrofit只是对okhttp的封装,Retrofit把注解的参数解析后交给okhttp去处理的,Retrofit拿到请求结果后进行数据转换,Retrofit封装的核心是CallAdapter
和Converter
,这两个转换可以让我们可以灵活的处理数据。