Android：Retrofit源码解析
前言
本文主要是带着三个问题去理解Retrofit的工做原理；java
- 1.咱们调用定义好的接口后发生了什么，接口api究竟是怎么解析出来的？
- 2.Retrofit是怎么和Okhttp合做的，由于发送请求最终都是Okhttp；
- 3.解析返回的数据怎么corvert成RxJava的observable的？
带着这三个问题，咱们开始下面的讲解。android
Retrofit的使用
public interface MedalApi {
String url = "employeeMedal/medalList.do";
@FormUrlEncoded
@POST(url)
Observable<AchievedMedalResult> getAchievedMedal(@Field("account") String account,
@Field("accountType") String accountType,
@Field("queryEmployeeId263") String queryEmployeeId263);
@GET(url)
Observable<AchievedMedalResult> testMedal();
@POST("/example_copy_copy/medallist")
Observable<AchievedMedalDetailResult> getAchievedMedalDetail(@Field("account") String account,
@Field("accountType") String accountType,
@Field("queryEmployeeId263") String queryEmployeeId263,
@Field("queryMedalCode") String queryMedalCode
);
}
public static <T> T createService(Class<T> service, String baseUrl) {
//日志处理
HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
@Override
public void log(String message) {
L.d(TAG, message);
}
});
loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient okHttpClient = new OkHttpClient.Builder()
//.addInterceptor(new LoggerInterceptor("TAG"))
.connectTimeout(CONNECT_TIMEOUT, TimeUnit.MILLISECONDS)
.readTimeout(READ_TIMEOUT, TimeUnit.MILLISECONDS)
/* 关闭OkHttp失败重试链接的机制，该问题致使发帖重复的问题 */
.retryOnConnectionFailure(false)
.addInterceptor(loggingInterceptor)
.addInterceptor(new HttpHeadInterceptor())
.addInterceptor(new SecurityInterceptor(AppInstance.INSTANCE)) // 加密解密
.addNetworkInterceptor(new StethoInterceptor())
.dns(new SunlandDNS())
// 其余配置
.build();
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(baseUrl)
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient)
.build();
return retrofit.create(service);
}
复制代码
上面就是实际使用了，作一些简单配置就能够发送请求了，返回的数据是转换后好的实体类，确实很方便。json
原理解析
上面简单讲了使用方法，下面开始进入正题，讲讲背后的原理。api
Retrofit实例化
首先看看它是怎么被初始化的，就是入口在哪？很显然，就是那个build，建造者模式，这个和okhttp是殊途同归。缓存
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> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
// Make a defensive copy of the converters.
List<Converter.Factory> converterFactories =
new ArrayList<>(1 + this.converterFactories.size());
// Add the built-in converter factory first. This prevents overriding its behavior but also
// ensures correct behavior when using converters that consume all types.
converterFactories.add(new BuiltInConverters());
converterFactories.addAll(this.converterFactories);
return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}
}
复制代码
它会接收一些外面传进来的参数，好比url，默认初始化okhttpclient，covert等，而后直接new了一个Retrofit，这才是把初始化的一些值真正保存到Retrofit对象里面去；bash
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.
this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
this.callbackExecutor = callbackExecutor;
this.validateEagerly = validateEagerly;
}
复制代码
这里面的参数都是很是重要的，有的是默认的，有的是外面初始化的时候传递进来的。网络
Retrofit的create（）
好了retrofit实例有了，接着看create方法。app
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, @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);
}
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.adapt(okHttpCall);
}
});
}
复制代码
这里把咱们定义好的api接口当作class参数传递进来，能够看到，这里面采用的是java动态代理技术，把接口api里面的方法集中在代理的invoke方法中去执行了，作了以下几件事异步
- 对method作校验，object默认的方法咱们不用去管，直接执行。
- 对平台的校验，在java8中默认会作校验，android中，咱们不用去理会。
- 重点的是最后三行代码，建立ServiceMethod，实例化OkHttpCall， serviceMethod.adapt。
接下来咱们对最后三行代码作分析；ide
首先看loadServiceMethod ：
private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();
ServiceMethod<?, ?> loadServiceMethod(Method method) {
ServiceMethod<?, ?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder<>(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
复制代码
serviceMethodCache里面存放的是Method和ServiceMethod的键值对，首先从map中去读取ServiceMethod，若是当前的值存在，那就直接使用。否者就须要新建ServiceMethod。这个逻辑是很是简单的，就是使用了缓存机制，由于java的动态代理和注解的解析都是比较耗时的，因此缓存是颇有必要的。接下来看看ServiceMethod究竟是何方神圣，须要咱们大费周折的去获取或新建。 ServiceMethod的Build（）
this.retrofit = retrofit;
this.method = method;
this.methodAnnotations = method.getAnnotations();
this.parameterTypes = method.getGenericParameterTypes();
this.parameterAnnotationsArray = method.getParameterAnnotations();
}
复制代码
这里把retrofit和method看成参数传递过来，而后获取method里面的一些参数，是的，api接口看上去是很抽象的，里面有注解，参数类型，还有参数的注解等等，首先获取api里的这些参数，而后看看build（）；
public ServiceMethod build() {
callAdapter = createCallAdapter();
responseType = callAdapter.responseType();
if (responseType == Response.class || responseType == okhttp3.Response.class) {
throw methodError("'"
+ Utils.getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
responseConverter = createResponseConverter();
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
if (httpMethod == null) {
throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
}
if (!hasBody) {
if (isMultipart) {
throw methodError(
"Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
}
if (isFormEncoded) {
throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
+ "request body (e.g., @POST).");
}
}
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
Type parameterType = parameterTypes[p];
if (Utils.hasUnresolvableType(parameterType)) {
throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
parameterType);
}
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
if (parameterAnnotations == null) {
throw parameterError(p, "No Retrofit annotation found.");
}
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
if (relativeUrl == null && !gotUrl) {
throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
}
if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
throw methodError("Non-body HTTP method cannot contain @Body.");
}
if (isFormEncoded && !gotField) {
throw methodError("Form-encoded method must contain at least one @Field.");
}
if (isMultipart && !gotPart) {
throw methodError("Multipart method must contain at least one @Part.");
}
return new ServiceMethod<>(this);
}
复制代码
这个方法看上去比较长，可是并不难，咱们分步说明之：
- 1.建立calladapter，这个方法最终的建立过程是在retrofit中，例如建立RxJava的CallAdapter
- 2.建立responseConverter，返回结果的covert，这个最终也是在retrofit里面建立的，例如建立GsonConveter
- 3.查找method中的全部注解，并一个个解析出来，http的各类请求post，get，put等注解，都是在这里解析出来的。
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);
if (!Void.class.equals(responseType)) {
throw methodError("HEAD method must use Void as response type.");
}
}
复制代码
- 4.对上面解析出来的注解作个校验，须要有httpmethod，也就是说必需要有请求方法的注解才行，不然会抛异常，这也很好理解，发请求确定是要指明是post仍是get吧。
- 5.对请求作一些其余的校验，好比post请求必须含有body等。再就是URL是否为空。
- 6.全部的校验经过之后，最后就是实例化了，以下：
ServiceMethod(Builder<R, T> builder) {
this.callFactory = builder.retrofit.callFactory();
this.callAdapter = builder.callAdapter;
this.baseUrl = builder.retrofit.baseUrl();
this.responseConverter = builder.responseConverter;
this.httpMethod = builder.httpMethod;
this.relativeUrl = builder.relativeUrl;
this.headers = builder.headers;
this.contentType = builder.contentType;
this.hasBody = builder.hasBody;
this.isFormEncoded = builder.isFormEncoded;
this.isMultipart = builder.isMultipart;
this.parameterHandlers = builder.parameterHandlers;
}
复制代码
好了，这个扯得有点多了，让咱们仍是回到那个代理类得invoke方法里面去。
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
复制代码
这里实例化OkHttpCall，其中参数就是咱们刚刚新建好的serviceMethod，这个call实质上就是okhttp里面的那个call，对的，最终调用网络请求就靠它了。 若是上面的都是准备工做的话，接下来才是正式开始发送请求了。这里我决定分两部分讲，一种是adapt返回普通的Call，另一种返回RxJava的Observable，实质上这也是Retrofit的两种不一样用法。
return serviceMethod.adapt(okHttpCall);
复制代码
返回类型是Call的调用
adapt方法返回类型是有okhttpcall里面的servicemethod来决定的。OkHttpCall实现了Call，这里返回的是call，接下来就是执行请求了。请求的执行分同步和异步。 同步的请求方法是 call.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 if (creationFailure instanceof RuntimeException) {
throw (RuntimeException) creationFailure;
} else {
throw (Error) creationFailure;
}
}
call = rawCall;
if (call == null) {
try {
call = rawCall = createRawCall();
} catch (IOException | RuntimeException | Error e) {
throwIfFatal(e); // Do not assign a fatal error to creationFailure.
creationFailure = e;
throw e;
}
}
}
if (canceled) {
call.cancel();
}
return parseResponse(call.execute());
}
复制代码
发送请求的是rawCall；
private okhttp3.Call createRawCall() throws IOException {
okhttp3.Call call = serviceMethod.toCall(args);
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
复制代码
继续跟
/** Builds an HTTP request from method arguments. */
okhttp3.Call toCall(@Nullable Object... args) throws IOException {
RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
contentType, hasBody, isFormEncoded, isMultipart);
@SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;
int argumentCount = args != null ? args.length : 0;
if (argumentCount != handlers.length) {
throw new IllegalArgumentException("Argument count (" + argumentCount
+ ") doesn't match expected count (" + handlers.length + ")");
}
for (int p = 0; p < argumentCount; p++) {
handlers[p].apply(requestBuilder, args[p]);
}
return callFactory.newCall(requestBuilder.build());
}
复制代码
这个过程调用servicemethod的toCall方法去构建网络请求，返回okhttp3.call，以后再调用call里面的ececute（），最后调用parseResponse对返回的结果进行解析；这里解析就不作过多分析了。
接着看看异步的调用： 事实上了解同步之后，异步也就差很少了：
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "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) {
throwIfFatal(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) {
Response<T> response;
try {
response = parseResponse(rawResponse);
} catch (Throwable e) {
callFailure(e);
return;
}
try {
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();
}
}
});
}
复制代码
就是把刚刚新建的request放到线程池里面去，而后使用callback对返回结果进行解析。以上就是普通的返回call的调用方法。
对于RxJava中的调用
咱们使用的时候是怎么初始化的：
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
复制代码
这里是使用的RxJava和GsonConvert，将它们保存在Retrofit的对象里面先存着，后面会用到。接着看ServiceMethod中build（），里面会调用createCallAdapter（），从字面意思能够理解为建立adapter； 最终会调用Retrofit中的函数：
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");
int start = callAdapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
...
}
复制代码
咱们只看重点，它就是遍历callAdapterFactories里面的CallAdapter，callAdapterFactories不就是咱们刚刚往里面addCallAdapterFactory值了的吗，没错，因此最终会调用RxJavaCallAdapterFactory的get方法
@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
...
if (!(returnType instanceof ParameterizedType)) {
String name = isSingle ? "Single" : "Observable";
throw new IllegalStateException(name + " return type must be parameterized"
+ " as " + name + "<Foo> or " + name + "<? extends Foo>");
}
Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
Class<?> rawObservableType = getRawType(observableType);
...
return new RxJavaCallAdapter(responseType, scheduler, isAsync, isResult, isBody, isSingle,
false);
}
复制代码
看重点，这个get方法通过必定处理后，最终会实例化一个RxJavaCallAdapter 对象，而后会去调用这个类里面的adapt方法。
@Override public Object adapt(Call<R> call) {
OnSubscribe<Response<R>> callFunc = isAsync
? new CallEnqueueOnSubscribe<>(call)
: new CallExecuteOnSubscribe<>(call);
OnSubscribe<?> func;
if (isResult) {
func = new ResultOnSubscribe<>(callFunc);
} else if (isBody) {
func = new BodyOnSubscribe<>(callFunc);
} else {
func = callFunc;
}
Observable<?> observable = Observable.create(func);
if (scheduler != null) {
observable = observable.subscribeOn(scheduler);
}
if (isSingle) {
return observable.toSingle();
}
if (isCompletable) {
return observable.toCompletable();
}
return observable;
}
复制代码
T adapt(Call<R> call) {
return callAdapter.adapt(call);
}
复制代码
因此不一样的callAdapter会调用不一样的类中的adapt，返回的结果也不同，前面说的默认的都是返回的call，RxJava返回的是Observable。而后就是使用Rxjava去发网络请求咯：
@Override public void call(Subscriber<? super Response<T>> subscriber) {
// Since Call is a one-shot type, clone it for each new subscriber.
Call<T> call = originalCall.clone();
CallArbiter<T> arbiter = new CallArbiter<>(call, subscriber);
subscriber.add(arbiter);
subscriber.setProducer(arbiter);
Response<T> response;
try {
response = call.execute();
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
arbiter.emitError(t);
return;
}
arbiter.emitResponse(response);
}
}
复制代码
里面的call.execute()就是执行网络请求的，这些就和前面没有区别了，最后会获得Respone，而后进行解析，这就讲清楚了怎么使用RxJava发送网络请求的，那么第二个问题，最终咱们怎么把返回值转换为对应的Observable呢。接着看，分析方法相似于上面，在ServiceMethod的build中有
responseConverter = createResponseConverter();
复制代码
这就是建立Convert，这个Convert就是初始化的时候传递进去的，咱们传的是GsonConverterFactory，因此和adapter同样最终会走到Retrofit里面去：
{
checkNotNull(type, "type == null");
checkNotNull(annotations, "annotations == null");
int start = converterFactories.indexOf(skipPast) + 1;
for (int i = start, count = converterFactories.size(); i < count; i++) {
Converter<ResponseBody, ?> converter =
converterFactories.get(i).responseBodyConverter(type, annotations, this);
if (converter != null) {
//noinspection unchecked
return (Converter<ResponseBody, T>) converter;
}
}
}
复制代码
代码和分析adapter的差很少，最终会走到GsonConverterFactory
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}
复制代码
当Retrofit在解析Respone数据的时候会调用ServiceMothod的以下方法：
/** Builds a method return value from an HTTP response body. */
R toResponse(ResponseBody body) throws IOException {
return responseConverter.convert(body);
}
复制代码
继续跟：
@Override public T convert(ResponseBody value) throws IOException {
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
T result = adapter.read(jsonReader);
if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
throw new JsonIOException("JSON document was not fully consumed.");
}
return result;
} finally {
value.close();
}
}
复制代码
就是Gson将返回结果作了处理，直接convert成对象返回了,最后再封装成Observable。
总结
分析完后咱们再来看看文章开头的三个问题，是否是都已经有结果了，最后咱们上一张图，整个Retrofit的分析流程图：
相关文章
- 1. Android源码解析：LayoutInflater源码解析
- 2. 源码解析
- 3. 《MapReduce 3》--inputFormat源码解析、FileInputFormat源码解析、TextInputFormat源码解析、LineRecordReader源码解析
- 4. redux源码解读－－createStore源码解析
- 5. redux源码解读--compose源码解析
- 6. redux源码解读－－bindActionCreators源码解析
- 7. 开源框架源码解析系列（2）——LeakCanary源码解析
- 8. 开源框架源码解析系列（3）——ButterKnife源码解析
- 9. LinkedList源码解析
- 10. ReentrantLock源码解析
- 更多相关文章...
- • XML DOM 解析器 - XML DOM 教程
- • TCP报文格式解析 - TCP/IP教程
- • Scala 中文乱码解决
- • 互联网组织的未来：剖析GitHub员工的任性之源
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Android源码解析：LayoutInflater源码解析
- 2. 源码解析
- 3. 《MapReduce 3》--inputFormat源码解析、FileInputFormat源码解析、TextInputFormat源码解析、LineRecordReader源码解析
- 4. redux源码解读－－createStore源码解析
- 5. redux源码解读--compose源码解析
- 6. redux源码解读－－bindActionCreators源码解析
- 7. 开源框架源码解析系列（2）——LeakCanary源码解析
- 8. 开源框架源码解析系列（3）——ButterKnife源码解析
- 9. LinkedList源码解析
- 10. ReentrantLock源码解析