Retrofit 源码简单分析
2017-11-22 本文已影响73人
jh352160
众所周知，在现在的Android开发中，针对与网络请求，Retrofit+okHttp的组合绝对是不二之选，而在网上针对于Retrofit分析的文章也有很多了，这次我也分享一些阅读Retrofit源码的心得，希望能够对大家有所帮助。由于我在工作中使用的版本为2.1，所以本次也是针对2.1版本进行分析，首先来看看Retrofit一种简单的用法：
Retrofit简单使用示例
首先创建出Retrofit对象，进行相应的初始化配置：
retrofit=new Retrofit.Builder()
.baseUrl(baseUrl)
.addConverterFactory(GsonConverterFactory.create())
.client(getClient())
.build();
然后在Service接口中写入相应方法，并加上相应的注解：
public interface Api {
@GET(apiUrl)
Call<Response> methodName();
}
最后传入请求的回调方法Callback就完成了：
retrofit.create(Api.class).methodName().enqueue(Callback);
对于Retrofit对象的Build中，主要的都是对于参数的初始化，所以本次就从Retrofit类中的create(final Class<T> service)入手
Retrofit.create
public <T> T create(final Class<T> service) {
//api类必须为接口，且不能实现或继承其他接口，否则在动态代理步骤将会抛出异常
Utils.validateServiceInterface(service);
if (validateEagerly) {
//立即开始遍历调用service中的所有方法
eagerlyValidateMethods(service);
}
//返回service类的动态代理对象，当调用service中的方法时，就会进入其中进行处理
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
//获取当前平台（Android或Java8）
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.
// 如果该方法为Class类中的方法，则直接执行
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
//判断给方法是否为default method，针对Android平台，该值永远为false，所以不应在Service类中加入default方法，经尝试可能会导致崩溃
//关于default method可以参考 http://ebnbin.com/2015/12/20/java-8-default-methods/
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
//1.获取调用方法的ServiceMethod对象
ServiceMethod serviceMethod = loadServiceMethod(method);
//2.创建OkHttpCall对象
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
//3.将上一步生成的OkHttpCall对象转换为在service中所配置的Call对象
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
在这段代码的最后所返回的Call对象就是用来使用的Call对象了。
其中有一个很有趣的地方，在 Platform 类中有一个通过判断特定的类是否存在的方式获取当前平台的步骤，在我的2.1版本中有这么一段代码：
try {
Class.forName("org.robovm.apple.foundation.NSObject");
return new IOS();
} catch (ClassNotFoundException ignored) {}
但在最新的2.3版本中这段代码已被移除，这说明Retrofit在之前版本中有对IOS平台的支持，但是我在网上却没有找到相关的资料，不知道有没有哪位朋友能为我解答一下。
在上面的代码中，重点是最后的三行代码，下面就分别对于这三行代码进分析：
1.ServiceMethod serviceMethod = loadServiceMethod(method);
Retrofit.loadServiceMethod
下面来通过loadServiceMethod方法看看ServiceMethod对象是如何创建出来的
ServiceMethod loadServiceMethod(Method method) {
ServiceMethod result;
synchronized (serviceMethodCache) {
//该方法的ServiceMethod对象是否已存在缓存中，如果是，则直接使用缓存中的对象
result = serviceMethodCache.get(method);
if (result == null) {
//创建ServiceMethod对象并将其放入缓存
result = new ServiceMethod.Builder(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
在代码中可以看出创建ServiceMethod对象主要都在ServiceMethod.Builder之中
在其中我发现了一点，在我所使用的2.1版本中，作为缓存使用的serviceMethodCache为LinkedHashMap，但在最新的2.3版本中已被换成了线程安全的ConcurrentHashMap。
ServiceMethod.Builder.Builder
首先看看Build中的构造方法：
public Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit; //retrofit对象
this.method = method; //所调用的方法
this.methodAnnotations = method.getAnnotations(); //方法上的注解
this.parameterTypes = method.getGenericParameterTypes(); //方法中参数的类型
this.parameterAnnotationsArray = method.getParameterAnnotations(); //方法中参数上的注解
}
可以看出，构造方法中的代码很简单，就是针对各个变量的赋值操作。下面就是ServiceMethod中的重头戏，也就是build方法，对于注解的解析也都是在这里完成的，这一部分的代码虽多，但是大部分都是对于注解的解析与异常的判断，还是一样先来看看代码：
ServiceMethod.Builder.build
public ServiceMethod build() {
//代码中将略去其中的合法性检测部分
//通过retrofit中的CallAdapterFactory生成CallAdapter，用以生成网络请求所需的执行器
callAdapter = createCallAdapter();
//数据数据转换工厂，例如常用的GsonConverterFactory
responseConverter = createResponseConverter();
//解析方法上的注解
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
//解析方法中各参数上的注解
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
Type parameterType = parameterTypes[p];
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
//返回ServiceMethod对象
return new ServiceMethod<>(this);
}
其中最重要的应该是属于对于方法与参数的注解解析的部分了，这也是Retrofit的特色之一，先来看看对于方法部分的注解解析：
ServiceMethod.parseMethodAnnotation
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);
} else if (annotation instanceof HEAD) {
parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
} else if (annotation instanceof PATCH) {
parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
} else if (annotation instanceof POST) {
parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
} else if (annotation instanceof PUT) {
parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
} else if (annotation instanceof OPTIONS) {
parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
} else if (annotation instanceof HTTP) {
HTTP http = (HTTP) annotation;
parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
} else if (annotation instanceof retrofit2.http.Headers) {
String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
headers = parseHeaders(headersToParse);
} else if (annotation instanceof Multipart) {
isMultipart = true;
} else if (annotation instanceof FormUrlEncoded) {
isFormEncoded = true;
}
}
可以看出来，这个方法中的逻辑很简单，主要是判断出注解的类型，并将对应的字符串传入之后的处理中，真正的处理还是在parseHttpMethodAndPath与parseHeaders两个方法中
ServiceMethod.parseHttpMethodAndPath
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
//除去异常判断后的代码
//方法的类型（如GET，POST，PUT等）
this.httpMethod = httpMethod;
//是否含有Body
this.hasBody = hasBody;
//判断相对路径是否为空
if (value.isEmpty()) {
return;
}
//将相对路径
this.relativeUrl = value;
//解析相对路径中的参数
this.relativeUrlParamNames = parsePathParameters(value);
}
在除去其中异常判断后，这个方法的逻辑就变得非常清晰了
ServiceMethod.parsePathParameters
static Set<String> parsePathParameters(String path) {
// PARAM_URL_REGEX = \{([a-zA-Z][a-zA-Z0-9_-]*)\}
Matcher m = PARAM_URL_REGEX.matcher(path);
Set<String> patterns = new LinkedHashSet<>();
while (m.find()) {
patterns.add(m.group(1));
}
return patterns;
}
这个方法也很好理解，使用正则表达式匹配出相对路径中以"{}"包裹的变量，然后放入Set集合中
ServiceMethod.parseHeaders
该方法的作用为Header注解的解析：
private Headers parseHeaders(String[] headers) {
Headers.Builder builder = new Headers.Builder();
for (String header : headers) {
//解析出header中的key和value
int colon = header.indexOf(':');
String headerName = header.substring(0, colon);
String headerValue = header.substring(colon + 1).trim();
//针对Content-type的头，将其存入contentType变量中
if ("Content-Type".equalsIgnoreCase(headerName)) {
MediaType type = MediaType.parse(headerValue);
contentType = type;
} else {
builder.add(headerName, headerValue);
}
}
//创建Headers对象
return builder.build();
}
ServiceMethod.parseParameterAnnotation
这个方法用于参数注解的解析
private ParameterHandler<?> parseParameterAnnotation(
int p, Type type, Annotation[] annotations, Annotation annotation) {
if (annotation instanceof Url) {
//do something
} else if (annotation instanceof Path) {
//do something
} else if (annotation instanceof Query) {
//do something
} else if (annotation instanceof QueryMap) {
//do something
} else if (annotation instanceof Header) {
//do something
} else if (annotation instanceof HeaderMap) {
//do something
} else if (annotation instanceof Field) {
//do something
} else if (annotation instanceof FieldMap) {
//do something
} else if (annotation instanceof Part) {
//do something
} else if (annotation instanceof PartMap) {
gotPart = true;
//do something
} else if (annotation instanceof Body) {
//do something
}
return null; // Not a Retrofit annotation.
}
parseParameterAnnotation这个方法中的代码虽然多，但是在简化之后可以看出来，就是针对不同的参数类型进行不同的处理然后返回相应的ParameterHandler对象，因为其中针对各个类型参数的处理比较繁琐，就不一一列举了。
需要提到的是，在这个方法中，有一个类的出现频率非常的高，这就是ParameterHandler类，这个类的主要作用是将注解中的各项参数通过RequestBuilder类转换为okHttp中使用的Request。
2.OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
在OkHttpCall类中，最主要的就是execute与enqueue两个方法，分别为同步与异步的网络请求，但是需要注意的是，这两个方法并不是我们在使用中所调用的方法，真正提供给外界调用的方法，会在文章之后的部分讲到。
OkHttpCall.execute
@Override public Response<T> execute() throws IOException {
//okHttp中的call对象，由于本次分析限于Retrofit中，所以不做深究
okhttp3.Call call;
synchronized (this) {
//一个OkhttpCall对象只能执行一次网络请求
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
//省略部分异常判断代码
call = rawCall;
if (call == null) {
try {
//如果okHttp对象未创建，则在创建后赋值给变量call
call = rawCall = createRawCall();
} catch (IOException | RuntimeException e) {
creationFailure = e;
throw e;
}
}
}
//防止当调用过cancel方法后新创建的Call未被cancel的情况
if (canceled) {
call.cancel();
}
//使用okhttp开始执行网络请求
return parseResponse(call.execute());
}
OkHttpCall.enqueue
@Override public void enqueue(final Callback<T> callback) {
if (callback == null) throw new NullPointerException("callback == null");
//okHttp中的call对象，由于本次分析限于Retrofit中，所以不做深究
okhttp3.Call call;
Throwable failure;
//一个OkhttpCall对象只能执行一次网络请求
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
call = rawCall;
failure = creationFailure;
if (call == null && failure == null) {
try {
//如果okHttp对象未创建，则在创建后赋值给变量call
call = rawCall = createRawCall();
} catch (Throwable t) {
failure = creationFailure = t;
}
}
}
//创建okhttp对象失败时，直接进行Fail的回调方法
if (failure != null) {
callback.onFailure(this, failure);
return;
}
//防止当调用过cancel方法后新创建的Call未被cancel的情况
if (canceled) {
call.cancel();
}
//使用okhttp开始执行网络请求，并针对返回结果调用Callback中相应的回调方法
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();
}
}
});
}
enqueue方法在主要的逻辑上，与上面的execute是基本相同的，但是有一点需要注意，就是当收到Response时并不会马上进行Callback中的onResponse回调，而是会调用parseResponse方法对返回的Response进行一次解析，如果解析中出现了异常，依然会进行onFailure的回调方法。
OkHttpCall.parseResponse
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
// 取出Response中的Body
ResponseBody rawBody = rawResponse.body();
// 这个变量就是最后获得的Response中的rawResponse，这实际上是一个在请求中返回的，去除了body部分的okhttp.Response原始对象
// 移除okhttp3.Response中的Source部分并重建一个okhttp.Response对象
// 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();
//如果code不在200~299的范围内，则代表请求异常
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();
}
}
// 204 NO CONTENT 与 205 RESET CONTENT 两个code是不含有body的
// 具体可以查阅https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/204与
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/205
if (code == 204 || code == 205) {
return Response.success(null, rawResponse);
}
// ExceptionCatchingRequestBody是为了捕获在解析rawBody中的内容的buffer时抛出的异常
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
// 通过Converter（如：GsonResponseBodyConverter）将Response中的流解析为所需的返回类型
T body = serviceMethod.toResponse(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;
}
}
这个方法主要是对okhttp中返回的response进行一次解析，对其进行一些预处理，并将其转换为更易于使用的Response对象
OkHttpCall.createRawCall
private okhttp3.Call createRawCall() throws IOException {
//获取ServiceMethod生成的Request对象
Request request = serviceMethod.toRequest(args);
//通过callFactory将Request转换为Okhttp3.Call
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
这个方法主要用于创建okHttp中的Call对象，逻辑非常简单，就不多做分析了
3.serviceMethod.callAdapter.adapt(okHttpCall)
这个方法实际是使用在创建Retrofit对象时传入的CallAdapterFactory将OkHttpCall对象转换为最后使用所需的对象，Retrofit中会默认配置一个ExecutorCallAdapterFactory，除此之外还有常用的RxJavaCallAdapterFactory与一个最简单的DefaultCallAdapterFactory。我们抽取出其中的adapt方法来看一看：
DefaultCallAdapterFactory
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
//DefaultCallAdapterFactory在返回时为一个单例对象
static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();
//构造方法
@Override
public CallAdapter<?> 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;
}
//将传入的Call对象转换为最后处理所需要的对象返回，在DefaultCallAdapterFactory中为将传入其中的对象直接返回
@Override public <R> Call<R> adapt(Call<R> call) {
return call;
}
};
}
}
这个是Retrofit中最为基本的CallAdapter，也只有在平台为Java8或者无法判断平台时才会使用，也由于这个类的逻辑非常简单，也可以通过这个类了解到CallAdapter.Factory最核心的两个方法的作用
ExecutorCallAdapterFactory
ExecutorCallAdapterFactory类为Android平台的默认CallAdapter：
final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
final Executor callbackExecutor;
//构造方法
ExecutorCallAdapterFactory(Executor callbackExecutor) {
this.callbackExecutor = callbackExecutor;
}
//获取CallAdapter对象
@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;
}
//将传入的Call对象转换为最后处理所需要的对象返回,在这里的返回类型为内部类ExecutorCallbackCall
@Override public <R> Call<R> adapt(Call<R> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
//这就是在ExecutorCallAdapterFactory中返回给外界去使用的对象，也就是在文章开头调用了相应的api方法后所返回的对象
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;
}
//在文章开头的使用示例中所传入的CallBack实际就是在这里调用相应的回调方法
@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来源于针对当前平台的对象Platform中的defaultCallbackExecutor方法
//在Android平台中，该方法的返回语句为 return new MainThreadExecutor();
//MainThreadExecutor的实现为通过handler将Runnable对象发送至主线程执行
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作用同上
callbackExecutor.execute(new Runnable() {
@Override public void run() {
callback.onFailure(ExecutorCallbackCall.this, t);
}
});
}
});
}
//do something
}
结语
那么，到现在为止，我们简单梳理了Retrofit中的Call的创建流程与ServiceMethod类中的主要逻辑，而这些，也只是Retrofi中的一部分而已，而我也是第一次写这样的文章，加上我的技术还不到位，所以肯定会有很多的不足，欢迎大家来批评指正。
