Retrofit源码解析
Posted 流云易采
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Retrofit源码解析相关的知识，希望对你有一定的参考价值。
square公司开源了一系列的优秀库，比如Retrofit,OkHttp,Picasso等，
前面简单分析了Picasso的源码，这里来分析下Retrofit的使用：
一、gradle添加依赖
compile 'com.squareup.okhttp:okhttp:2.4.0'
compile 'com.squareup.okhttp:okhttp-urlconnection:2.4.0'
compile 'com.squareup.okio:okio:1.5.0'
compile 'com.google.code.gson:gson:2.2.4'
compile 'com.squareup.retrofit:retrofit:2.0.0-beta2'
compile 'com.squareup.retrofit:adapter-rxjava:2.0.0-beta2'
compile 'com.squareup.retrofit:converter-gson:2.0.0-beta2'
compile 'io.reactivex:rxandroid:1.1.0'
compile 'io.reactivex:rxjava:1.1.0'盗两张网上的图：
下面是从创建Retrofit出发，具体的使用流程；Retrofit最终的请求操作都是交由okHttp去执行的，执行的结果返回Response，再根据转换器进行解析成相对应的返回类型T;
Retrofit中使用了动态代理，方便了使用；通过retrofit.create返回的其实是个动态代理类，所有具体的处理逻辑交由MethodHandler进行处理；
下面是Retrofit系统中的整个类图，有点像外观模式，Retrofit持有所有子系统的引用；Retrofit比较重要的是两个Factory，一个使用来生成CallAdapter的CallAdapterFactory；一个是用来转换结果的ConvertFactory；这两个都可以用户自己进行添加。
在自定义的Service中，每一个method对应一个MethodHandler,MethodHandler持有retrofit，前面两个Factory以及生成Request的RequestFactory；在okHttp中，Request需要自己进行定义创建，而Retrofit简化了这个操作，进行了相应的封装，使用注解的方式来定义Request的相关参数信息；注解信息的解析则在RequestFactory中完成，通过RequestFactoryParser对注解信息进行简单解析，RequestBuilderAction是解析method中参数中的注解如@Path这些产生的中间产物，最终通过RequestBuilder来具体产生一个Request，RequestBuilder中持有okHttp中的Request.Builder类的引用，其创建Request过程其实都是交给okHttp来操作的；
生成的Request最终封装成为一个OkHttpCall，OkHttpCall则可以看做是对okHttp中Call的通过，它的enqueue等网络请求操作都是委托个给okHttp来操作的；同时对okHttp的返回Response进行解析，使用convertFactory，将其解析为用户所期望的返回类型；
二、使用
（一）使用Call形式
1、定义请求接口：
public interface RetrofirHttpService {
@GET("{user}")
Call<UserInfo> getData(@Path("user") String user);
}
注：UserInfo是自己定义的解析类：
public class UserInfo {
String username;
String password;
}2、使用GET获取信息：
// 原始的CallBack方式
private void getUseCall() {
// 添加拦截器
OkHttpClient client = new OkHttpClient();
client.interceptors().add(new LoggingInterceptor());
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://115.156.187.146/TransferServer/")
.client(client) // 添加okHttp
.addConverterFactory(GsonConverterFactory.create()) // GSON进行转换
.build();
RetrofirHttpService apiStores = retrofit.create(RetrofirHttpService.class);
Call<UserInfo> call = apiStores.getData("ServerMain.php");
// 异步调用
call.enqueue(new Callback<UserInfo>() {
@Override
public void onResponse(Response<UserInfo> response, Retrofit retrofit) {
UserInfo data = response.body();
LogUtils.i("Call Result:" + data.m);
}
@Override
public void onFailure(Throwable t) {
LogUtils.e(t.toString());
}
});
}（二）使用RxJava形式
1、定义请求接口
public interface RxHttpService {
@GET("{path}")
Observable<UserInfo> getData(@Path("path") String path);
}2、具体使用
// 使用RxJava方式
private void getUseRxJava() {
// 添加拦截器
OkHttpClient client = new OkHttpClient();
client.interceptors().add(new LoggingInterceptor());
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://115.156.187.146/TransferServer/")
.client(client) // 添加okHttp
.addConverterFactory(GsonConverterFactory.create()) // GSON进行转换
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.build();
RxHttpService apiStores = retrofit.create(RxHttpService.class);
Observable<UserInfo> observable = apiStores.getData("ServerMain.php");
observable.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<UserInfo>() {
@Override
public void onNext(UserInfo user) {
LogUtils.i("Call Result:" + user.m);
}
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable error) {
LogUtils.e(error.toString());
}
});
}三、源码分析：
（一）先来看创建动态代理类的过程：
RxHttpService apiStores = retrofit.create(RxHttpService.class);动态代理的知识具体见《 设计模式汇总：结构型模型（上）》中的代理模式中的解释。
1）Retrofit#create:
/** Create an implementation of the API defined by the {@code service} interface. */
@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
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)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
return loadMethodHandler(method).invoke(args);
}
});
}标准的动态代理创建过程；
来看代理类和委托类之间的中间InvocationHandler类的invoke函数具体执行逻辑；
loadMethodHandler(method).invoke(args);
2）Retrofit#loadMethodHandler:
private final Map<Method, MethodHandler<?>> methodHandlerCache = new LinkedHashMap<>();
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;
}Retrofit维护了一个method对应的Map，这里将method都封装成一个MethodHandler类（可以当作是委托类）；调用代理类，其实就是调用MethodHandler的invoke;所以具体的实现逻辑都在MethodHandler中；
（二）MethodHanlder
1）MethodHandler类：
final class MethodHandler<T> {
// MethodHandler持有一个retrofit对象
private final Retrofit retrofit;
// 类似于Volley中的 Request ，包含了HTTP请求的Url、Header信息，MediaType、Method以及RequestAction数组
private final RequestFactory requestFactory;
// HTTP请求返回数据的类型
private final CallAdapter<T> callAdapter;
// 对返回数据进行转换的类型转换器
private final Converter<ResponseBody, T> responseConverter;
private MethodHandler(Retrofit retrofit, RequestFactory requestFactory,
CallAdapter<T> callAdapter, Converter<ResponseBody, T> responseConverter) {
this.retrofit = retrofit;
this.requestFactory = requestFactory;
this.callAdapter = callAdapter;
this.responseConverter = responseConverter;
}
// 每一次请求的最终具体调用的函数
Object invoke(Object... args) {
// 可以发现最终是调用callAdapter的adapt函数
// 并且将相应的请求事务封装成一个OkHttpCall类进行处理
return callAdapter.adapt(new OkHttpCall<>(retrofit, requestFactory, responseConverter, args));
}
// 调用该静态类创建一个MethodHandler实例
@SuppressWarnings("unchecked")
static MethodHandler<?> create(Retrofit retrofit, Method method) {
// 创建CallAdapter
CallAdapter<Object> callAdapter = (CallAdapter<Object>) createCallAdapter(method, retrofit);
// 根据callAdapter来获取相应的返回类型
Type responseType = callAdapter.responseType();
// 创建结果类型转换器
Converter<ResponseBody, Object> responseConverter =
(Converter<ResponseBody, Object>) createResponseConverter(method, retrofit, responseType);
// 创建RequestFactory
RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
return new MethodHandler<>(retrofit, requestFactory, callAdapter, responseConverter);
}
// 创建相应的CallAdapter
private static CallAdapter<?> createCallAdapter(Method method, Retrofit retrofit) {
// 这个method即为service中自定义的一个方法，一般返回都是泛型类
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.");
}
// 获取Method上对应的注解即（GET这些）
Annotation[] annotations = method.getAnnotations();
try {
// 根据注解来获取相应的Adapter
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来实现的；
private static Converter<ResponseBody, ?> createResponseConverter(Method method,
Retrofit retrofit, Type responseType) {
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.responseConverter(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是系统为定义的每一个Service中的method中创建的一个具体执行类，通过调用其invoke函数，来执行具体的请求的逻辑；
它主要包含四个变量：
Retrofit: MethodHandler持有一个retrofit对象
private final Retrofit retrofit;
RequestFactory: 类似于Volley中的 Request ，包含了HTTP请求的Url、Header信息，MediaType、Method以及RequestAction数组
private final RequestFactory requestFactory;
CallAdapter: HTTP请求返回数据的类型
private final CallAdapter<T> callAdapter;
ResponseConverter: 对返回数据进行转换的类型转换器
private final Converter<ResponseBody, T> responseConverter;
具体来看每个变量的创建；
2）Retrofit#callAdapter:
private final List<CallAdapter.Factory> adapterFactories;
public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
/**
* Returns the {@link CallAdapter} for {@code returnType} from the available {@linkplain
* #callAdapterFactories() factories} except {@code skipPast}.
*/
// 返回相关的可用的CallAdapter（除了指定跳过的skipPast）
public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");
int start = adapterFactories.indexOf(skipPast) + 1;
// 遍历adapterFactories中所有的Factory
for (int i = start, count = adapterFactories.size(); i < count; i++) {
CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
// 如果找到，则返回该Adapter
if (adapter != null) {
return adapter;
}
}
// 如果获取不到相应的CallAdapter，则抛出异常
StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
.append(returnType)
.append(". Tried:");
for (int i = start, count = adapterFactories.size(); i < count; i++) {
builder.append("\\n * ").append(adapterFactories.get(i).getClass().getName());
}
if (skipPast != null) {
builder.append("\\nSkipped:");
for (int i = 0; i < start; i++) {
builder.append("\\n * ").append(adapterFactories.get(i).getClass().getName());
}
}
throw new IllegalArgumentException(builder.toString());
}RetroFit中有一个adapterFactories保存了所有CallAdapter.Factory,通过遍历这些factory来获取相应符合的CallAdapter;
先来看adapterFactories都保存了哪些Factory；从Retrofit创建开始
（三）Retrofit的创建
private final OkHttpClient client;
private final BaseUrl baseUrl;
private final List<Converter.Factory> converterFactories;
private final List<CallAdapter.Factory> adapterFactories;
private final Executor callbackExecutor;
private final boolean validateEagerly;
private Retrofit(OkHttpClient client, BaseUrl baseUrl, List<Converter.Factory> converterFactories,
List<CallAdapter.Factory> adapterFactories, Executor callbackExecutor,
boolean validateEagerly) {
this.client = client;
this.baseUrl = baseUrl;
this.converterFactories = converterFactories;
this.adapterFactories = adapterFactories;
this.callbackExecutor = callbackExecutor;
this.validateEagerly = validateEagerly;
}
/** Create the {@link Retrofit} instances. */
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
// 默认使用OkhttpClient
OkHttpClient client = this.client;
if (client == null) {
client = new OkHttpClient();
}
// 向adapterFactories添加了一个默认的CallAdapterFactory
// 如果前面add了CallAdpterfactory（如RxJavaCallAdapterFactory），则可以看到默认的Factory会添加到用户指定的Factory后面
// 则在遍历的时候，会优先遍历用户指定的Factory
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(client, baseUrl, converterFactories, adapterFactories, callbackExecutor,
validateEagerly);
}
/**
* 用户添加自定义的CallAdapterFactory
*/
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
adapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}用户可以根据自己需要来添加自定义的CallAdapterFactory，这里来看系统默认的CallAdapterFactory；
Platform.get()是根据系统不同来创建不同的运行环境，比如是再Android上还是Java上运行时由区别的，如下所示：
1）Platform:
class Platform {
private static final Platform PLATFORM = findPlatform();
static Platform get() {
return PLATFORM;
}
private static Platform findPlatform() {
// 如果是Android系统
try {
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0) {
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
// 如果是Java系统
try {
Class.forName("java.util.Optional");
return new Java8();
} catch (ClassNotFoundException ignored) {
}
// 如果是其他系统
return new Platform();
}
static class Android extends Platform {
// 创建默认的CallAdapterFactory过程
@Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
if (callbackExecutor == null) {
// 如果没有指定callbackExecutor，或者为null，则新创建一个MainThreadExecutor
callbackExecutor = new MainThreadExecutor();
}
return new ExecutorCallAdapterFactory(callbackExecutor);
}
// 该Executor的主要工作逻辑就是调用主线程的Looper来创建一个对应的Handler
// 执行execute就是操作Handler进行post事件（Runnable）
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
}
}可以看到对应不同的系统平台，Retrofit提供了不同的Platform版本； 默认的CallAdapterFactory是个ExecutorCallAdapterFactory，它是通过callbackExecutor来创建的；
如果用户没有执行相应的callbackExecutor，系统或创建一个默认的MainThreadExecutor，该MainThreadExecutor的主要执行逻辑就是使用主线程的Handler来post Runnable消息；
然后Retrofit把ExecutorCallAdapterFactory实例添加到adapterFactories中；
2）继续前面MethodHandler的查找CallAdapter的逻辑：
CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
final class ExecutorCallAdapterFactory implements CallAdapter.Factory {
private final Executor callbackExecutor;
ExecutorCallAdapterFactory(Executor callbackExecutor) {
this.callbackExecutor = callbackExecutor;
}
@Override
public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
// 根据returnType获得具体的返回类型
if (Utils.getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
// 返回一个CallAdapter
return new CallAdapter<Call<?>>() {
@Override
public Type responseType() {
return responseType;
}
// 调用adapt返回一个ExecutorCallbackCall类
@Override
public <R> Call<R> adapt(Call<R> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}将前面所有的逻辑串在一起，使用动态代理创建的代理类使用的InvokeHandler，调用其invoke来实现一个具体的方法调用；委托类是系统自定义创建的MethodHandler，系统根据method来创建相应的MethodHandler;MethodHandler中持有对CallAdapter的引用，CallAdapter是通过相应的CallAdpterFactory来创建的，如果加入了自定义的比如RxJava，最终会添加到Retrofit中的一个factory链表中，系统通过扫描链表来获取合适的CallAdpterFactory来创建CallAdapter;
如果没有自定义CallAdapterFactory，则会默认生成一个CallAdapterFactory;通过这个默认的Factory会创建一个默认的CallAdapter；
代理类的方法实现，是通过InvokeHandler的invoke来实现的；在系统定义的Invokehandler中进而调用MethodHandler的invoke函数，该invoke函数会继续调用CallAdpter的adapt,由上知，最终返回一个ExecutorCallbackCall类；
继续来看ExecutorCallbackCall类：
3）ExecutorCallbackCall类：
final class ExecutorCallAdapterFactory implements CallAdapter.Factory {
static final class ExecutorCallbackCall<T> implements Call<T> {
private final Executor callbackExecutor;
private final Call<T> delegate;
// 注意这里的Call传递进来的是一个封装好的OkHttpCall类
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
@Override public void enqueue(Callback<T> callback) {
delegate.enqueue(new ExecutorCallback<>(callbackExecutor, callback));
}
@Override public Response<T> execute() throws IOException {
return delegate.execute();
}
@Override public void cancel() {
delegate.cancel();
}
@SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
@Override public Call<T> clone() {
return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
}
}
static final class ExecutorCallback<T> implements Callback<T> {
private final Executor callbackExecutor;
private final Callback<T> delegate;
ExecutorCallback(Executor callbackExecutor, Callback<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
@Override public void onResponse(final Response<T> response, final Retrofit retrofit) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
delegate.onResponse(response, retrofit);
}
});
}
@Override public void onFailure(final Throwable t) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
delegate.onFailure(t);
}
});
}
}
}可以看出来ExecutorCallbackCall也是一个代理类，它的委托类是OkHttpCall；所以使用默认的CallAdapterFactory返回的是一个封装了OkHttpCall的一个Call类，其具体的类型是ExecutorCallbackCall；
4）OkHttpCall:
final class OkHttpCall<T> implements Call<T> {
private final Retrofit retrofit;
private final RequestFactory requestFactory;
private final Converter<ResponseBody, T> responseConverter;
private final Object[] args;
private volatile com.squareup.okhttp.Call rawCall;
private boolean executed; // Guarded by this.
private volatile boolean canceled;
OkHttpCall(Retrofit retrofit, RequestFactory requestFactory,
Converter<ResponseBody, T> responseConverter, Object[] args) {
this.retrofit = retrofit;
this.requestFactory = requestFactory;
this.responseConverter = responseConverter;
this.args = args;
}
@SuppressWarnings("CloneDoesntCallSuperClone")
// We are a final type & this saves clearing state.
@Override
public OkHttpCall<T> clone() {
return new OkHttpCall<>(retrofit, requestFactory, responseConverter, args);
}
}来看enqueue操作；在用户代码中：
call.enqueue(new Callback<UserInfo>() {
@Override
public void onResponse(Response<UserInfo> response, Retrofit retrofit) {
UserInfo data = response.body();
LogUtils.i("Call Result:" + data.m);
}
@Override
public void onFailure(Throwable t) {
LogUtils.e(t.toString());
}
});由前面知这里的Call对应的是一个ExecutorCallbackCall，来看起enqueue操作：
5）ExecutorCallbackCall#enqueue:
@Override
public void enqueue(Callback<T> callback) {
delegate.enqueue(new ExecutorCallback<>(callbackExecutor, callback));
}delegate对应的即是OkHttpCall,先来看其enqueue传入的参数： ExecutorCallback
static final class ExecutorCallback<T> implements Callback<T> {
private final Executor callbackExecutor;
private final Callback<T> delegate;
ExecutorCallback(Executor callbackExecutor, Callback<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
@Override
public void onResponse(final Response<T> response, final Retrofit retrofit) {
callbackExecutor.execute(new Runnable() {
@Override
public void run() {
delegate.onResponse(response, retrofit);
}
});
}
@Override
public void onFailure(final Throwable t) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
delegate.onFailure(t);
}
});
}
}ExecutorCallback也是一个代理类，用来封装用户定义的Callback，即类内部的变量delegate；callbackExecutor是查找Platform过程中new Android时创建的，其execute的逻辑较为简单，就是使用主线程对应的Handler来将Runnable事件post出去；可以看到，这里最终的响应都会在主线程中，而且调用用户自定义的onResponse和onFailure;
ExecutorCallback的主要作用就是封装Callback，将Callback的响应切换到主线程中；
6）继续来看对应的OkHttpCall的enqueue操作：
@Override
public void enqueue(final Callback<T> callback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed");
executed = true;
}
// 注意okHttp的call和retrofit的Call是不同
com.squareup.okhttp.Call rawCall;
try {
// 创建一个okhttp类型的Call
rawCall = createRawCall();
} catch (Throwable t) {
callback.onFailure(t);
return;
}
// 如果取消
if (canceled) {
rawCall.cancel();
}
this.rawCall = rawCall;
// 将Call中事务全部委托给okHttp来操作
// 调用okHttp的enqueue，使用okHttp的Callback来封装retrofit中的Callback
rawCall.enqueue(new com.squareup.okhttp.Callback() {
// 请求失败的响应
private void callFailure(Throwable e) {
try {
callback.onFailure(e);
} catch (Throwable t) {
t.printStackTrace();
}
}
// 请求成功的响应
private void callSuccess(Response<T> response) {
try {
callback.onResponse(response, retrofit);
} catch (Throwable t) {
t.printStackTrace();
}
}
@Override
public void onFailure(Request request, IOException e) {
callFailure(e);
}
@Override
public void onResponse(com.squareup.okhttp.Response rawResponse) {
Response<T> response;
try {
// 获得结果，并且解析结果
response = parseResponse(rawResponse);
} catch (Throwable e) {
callFailure(e);
return;
}
callSuccess(response);
}
});
}OkHttpCall是对OkHttp里面的Call的封装，将所有的操作都委托给该Call进行操作；这里主要的是通过retrofit的call来创建一个okHttp的Call类；这里通过createRawCall来创建：
private com.squareup.okhttp.Call createRawCall() {
return retrofit.client().newCall(requestFactory.create(args));
}这里是通过okHttpClient来创建的一个Call；首先来看 requestFactory是如何根据args参数来创建一个相应的Call的；
先来看requestFactory，它是MethodHandler中创建传递过来的；
RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
（四）RequestFactory：
final class RequestFactoryParser {
private final Method method;
static RequestFactory parse(Method method, Type responseType, Retrofit retrofit) {
RequestFactoryParser parser = new RequestFactoryParser(method);
// Method对应的注解这里解析
parser.parseMethodAnnotations(responseType);
parser.parseParameters(retrofit);
// 创建一个RequestFactory
return parser.toRequestFactory(retrofit.baseUrl());
}
private RequestFactoryParser(Method method) {
this.method = method;
}
}RequestFactoryParser主要是根据method对应的注解及返回类型进行相应解析，得出相应的解析结果，然后创建一个RequestFactory来保存所有解析后结果，供创建OkHttpCall来使用。
<一>parseMethodAnnotations：
1）RequestFactoryParser#parseMethodAnnotations：
// 这里是对注解进行解析的核心代码
// 根据注解类型的不同（即请求类型类型的不同进行相应解析）
// 这里也对应的retrofit的基本用法
private void parseMethodAnnotations(Type responseType) {
for (Annotation annotation : method.getAnnotations()) {
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(method, "HEAD method must use Void as response type.");
}
} 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 HTTP) {
HTTP http = (HTTP) annotation;
parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
} else if (annotation instanceof Headers) {
// 只有Headers是通过parseHeaders来解析的
String[] headersToParse = ((Headers) annotation).value();
if (headersToParse.length == 0) {
throw methodError(method, "@Headers annotation is empty.");
}
headers = parseHeaders(headersToParse);
} else if (annotation instanceof Multipart) {
// 可以看到Multipart和FormUrlEncoded不能同时定义
if (isFormEncoded) {
throw methodError(method, "Only one encoding annotation is allowed.");
}
isMultipart = true;
} else if (annotation instanceof FormUrlEncoded) {
if (isMultipart) {
throw methodError(method, "Only one encoding annotation is allowed.");
}
isFormEncoded = true;
}
}
if (httpMethod == null) {
throw methodError(method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).");
}
// 如果不存在实体，但是用户定义为isMultipart或者isFormEncoded类型，则会抛出异常
if (!hasBody) {
if (isMultipart) {
throw methodError(method,
"Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
}
if (isFormEncoded) {
throw methodError(method,
"FormUrlEncoded can only be specified on HTTP methods with request body "
+ "(e.g., @POST).");
}
}
}这里是对注解进行解析的核心代码 ，根据注解类型的不同（即请求类型类型的不同） 进行相应解析，这里也对应的retrofit的基本用法；
可以看到除了headers使用的parseheader进行解析外，其他都是通过 parseHttpMethodAndPath进行解析的；这里来重点分析下parseHttpMethodAndPath；
2）parseHttpMethodAndPath：
// 这个函数只是先做了一个前期判断
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
if (this.httpMethod != null) {
throw methodError(method, "Only one HTTP method is allowed. Found: %s and %s.",
this.httpMethod, httpMethod);
}
// 对应"GET","POST"等
this.httpMethod = httpMethod;
// 标注有没有实体
this.hasBody = hasBody;
// 注解值为空直接返回
if (value.isEmpty()) {
return;
}
// 判断URL是否已经有查询字符串query string
// Get the relative URL path and existing query string, if present.
int question = value.indexOf('?');
if (question != -1 && question < value.length() - 1) {
// 保证URL的查询字符串中没有{...}之类的字符
// Ensure the query string does not have any named parameters.
String queryParams = value.substring(question + 1);
Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
if (queryParamMatcher.find()) {
throw methodError(method, "URL query string \\"%s\\" must not have replace block. "
+ "For dynamic query parameters use @Query.", queryParams);
}
}
// 具体的解析继续由parsePathParameters来完成
this.relativeUrl = value;
this.relativeUrlParamNames = parsePathParameters(value);
}这个函数仅是做了一个简单的前期判断，将method对应的请求类型（httpMethod） ，注解值（relativeUrl），以及是否包含实体信息（hasBody）赋值给该RequestFactoryParser;
来看POST和GET的简单调用实例：
parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
继续来看解析函数parsePathParameters :
private static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
private static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
private static final Pattern PARAM_URL_REGEX = Pattern.compile("\\\\{(" + PARAM + ")\\\\}");
/**
* Gets the set of unique path parameters used in the given URI. If a parameter is used twice
* in the URI, it will only show up once in the set.
*/
// 检测出路径中所有{..}的字段，如{user}等，添加到一个Set中（因此不会重复添加）
static Set<String> parsePathParameters(String path) {
Matcher m = PARAM_URL_REGEX.matcher(path);
Set<String> patterns = new LinkedHashSet<>();
while (m.find()) {
patterns.add(m.group(1));
}
return patterns;
}这一步仅是根据正则表达式获取URL中所有{…}类型的数据，添加到patterns这个Set中，然后返回给RequestFactoryParser，对relativeUrlParamNames进行赋值；
第一步解析完毕，来到第二步parseP
以上是关于Retrofit源码解析的主要内容，如果未能解决你的问题，请参考以下文章