上一篇分析了Retrofit的创建过程，也就是如下这段代码的内部实现：
Retrofit retrofit = new Retrofit.Builder()
* .baseUrl("https://api.example.com/")
* .addConverterFactory(GsonConverterFactory.create())
* .build();
这一篇分析创建接口对象的内部实现,也就是下面这段代码：
MyApi api = retrofit.create(MyApi.class);
就这一小行代码，首先我们看看create()方法干了什么，前方高能，我要贴代码了：
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);
}
return loadServiceMethod(method).invoke(args);
}
});
}
这个方法的前四行不需要解释了，就是校验接口和方法的合法性。` Proxy.newProxyInstance()这个方法返回了一个此接口的动态代理对象，也就是上面我们看到的api这个对象。
动态代理对象创建好了，我们进行第三步：
* Response<User> user = api.getUser().execute();
我们以后调用这个动态对象的所有方法的时候都会先走invoke()方法。这个方法中两个if判断，第一个是判断方法是否是object的方法，第二个是判断方法是否是java 8的default方法。重点是loadServiceMethod(method).invoke(args)这一句，车既然开到这了，那么继续往前开吧：
ServiceMethod<?> loadServiceMethod(Method method) {
ServiceMethod<?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}
这个方法中首先是通过method从缓存map中取出ServiceMethod,如果没有，那么就通过ServiceMethod.parseAnnotations(this, method)ServiceMethod的静态方法获取，你也许看到这一懵逼，说怎么不解释一下，对不起，我也不知道它是干啥的目前为止，从方法名字看说是解析注解，想知道干啥的，那我们一起继续往下看：
abstract class ServiceMethod<T> {
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method 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.");
}
return new HttpServiceMethod.Builder<Object, T>(retrofit, method).build();
}
abstract T invoke(@Nullable Object[] args);
}
好，到了ServiceMethod这个类了，一看，傻眼了，几乎啥也没干呀这，校验了方法返回类型，抛了两个异常之后，就又甩锅了，甩给HttpServiceMethod，这个类一看就是ServiceMethod的实现类，并且又是builder模式，这个类的注释如下：
Adapts an invocation of an interface method into an HTTP call.
大概的意思是将一个接口的方法调用转化成一个HTTP call
好，那我们就继续看这个类：
Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
}
这事HttpServiceMethod.Builder这个类的构造方法，保存了两个变量，没干别的，继续看build()方法:
HttpServiceMethod<ResponseT, ReturnT> build() {
requestFactory = RequestFactory.parseAnnotations(retrofit, method);
callAdapter = createCallAdapter();
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?");
}
responseConverter = createResponseConverter();
if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
throw methodError(method, "HEAD method must use Void as response type.");
}
return new HttpServiceMethod<>(this);
}
这里面干了不少事情，创建了适配器，转换器，这两个其实就是从我们retrofi那两个集合里面取出来的，我们开始设置的适配器和转换器都是存入这两个集合的，还获取了方法的返回类型。最好创建了一个HttpServiceMethod对象，下面是它的构造方法：
HttpServiceMethod(Builder<ResponseT, ReturnT> builder) {
requestFactory = builder.requestFactory;
callFactory = builder.retrofit.callFactory();
callAdapter = builder.callAdapter;
responseConverter = builder.responseConverter;
}
到这里loadServiceMethod(method).invoke(args)这段代码的前半部分loadServiceMethod(method)已经分析完了，到最后返回一个HttpServiceMethod对象，最后调用invoke方法这段我们看看干了什么,invoke()是HttpServiceMethod这个类的方法：
@Override ReturnT invoke(@Nullable Object[] args) {
return callAdapter.adapt(
new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}
callAdapter就是设置的适配器，我们看到我们分析的代码流程中没有设置，这个时候你是否还记得第一篇讲的在适配器集合中retrofit会默认给我们添加一个，所以callAdapter就是从集合中取出来的，retrofit默认添加的是ExecutorCallAdapterFactory这个适配器，所以现在我们就去看看它的adapt方法：
@Override public Call<Object> adapt(Call<Object> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
就是这个，没干什么，创建了一个ExecutorCallbackCall对象，我们看一下它的构造方法：
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
保存了两个参数，一个是Executor 回掉线程，一个是用于真正请求的call对象。
Response<User> user = api.getUser().execute();
上面所有的分析都是api.getuser()这个方法的过程，最后一步是.execute(),方法，这个方法就是ExecutorCallbackCall对象的方法:
@Override public Response<T> execute() throws IOException {
return delegate.execute();
}
最后调用了Call的execute()。到此基本整个流程就走完了。
总结：
retrofit这两篇主要是通过用法深入到源码了解整个流程。这其中还有很多细节，后续分析。
