接着上一章继续分析上一章主要简单说了一下基本使用和注解，这一章，我们主要看源码，废话不多说了，直接上。先上一张图 从网络上拿来的
前面一章说了一下Retrofit的简单使用https://www.cnblogs.com/huangjialin/p/9492182.html
//创建retrofit
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(url) //设置baseURl
.addConverterFactory(ScalarsConverterFactory.create()) //增加返回值为String的支持
.addConverterFactory(GsonConverterFactory.create())
.build();
ApiService apiService = retrofit.create(ApiService.class);
Call<SwitchTest> call = apiService.getInformation();
call.enqueue(new Callback<SwitchTest>() {
@Override
public void onResponse(Call<SwitchTest> call, Response<SwitchTest> response) {
Log.d("huangjialin", "---onResponse----" + response.body().getMessage());
} @Override
public void onFailure(Call<SwitchTest> call, Throwable t) {
Log.d("huangjialin", "--- 失败----" ); }
});
我们看一下new Retrofit.Builder()源码是怎么走的
public Builder() {
this(Platform.get());
}
class Platform {
private static final Platform PLATFORM = findPlatform();
static Platform get() {
return PLATFORM;
}
private static Platform findPlatform() {
try {
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != ) {
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("java.util.Optional");
return new Java8();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}
//—————省略若干代码—————-
}
从代码中可以看出来，Builder后先是调用this(Platform.get());然后在调用findPlatform()方法，在findPlatform()方法中主要进行平台的判断，不同的平台返回不同的线程池。在最新的几个版本中去掉了iOS平台的判断。
好了，回过头来我们接着看build()方法是怎么执行的
public Retrofit build() {
if (baseUrl == null) { //从这里这里知道baseUrl一定不能为空，也就是说必须要设置，否则会抛异常
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory; //如果需要对OkHttpClient进行设置，则可以构建OkHttpClient对象，然后调用callFactory方法将设置好的OkHttpClient传进去。
if (callFactory == null) {
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor(); //将回调传递到主线程
}
// adapterFactories主要用于存储对Call进行转化的对象
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
//主要用于存储数据转换后的对象
List<Converter.Factory> converterFactories =
new ArrayList<>( + 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);
//将retrofit对象返回来
return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}
上面做的注释很清晰，也就是说build()后，我们可以拿到这个Retrofit这个对象，接着ApiService apiService = retrofit.create(ApiService.class);我们看看这句代码的源码是怎么走的
public <T> T create(final Class<T> service) {
//这里主要是进行一些判断验证，比如说我们这里定义的ApiService，这个只能定义为interfaces类型，而不能定义为class类型。并且interfaces不能被扩展
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 (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);
}
});
}
当进行一系列验证判断以后，Proxy.newProxyInstance来拿到一个动态代理，同时实现invoke()方法。通过当我们调用接口中的方法时，比如说调用登陆接口 Call<LoginModel> login(@Body Login login);，
这个时候就会调用InvocationHandler中的invoke方法，invoke()方法中有三个参数，第一个就是代理对象，第二个就是所调用的方法，比如说调用登陆接口，这个方法就是login，第三个就是方法参数了。
接着我们找到loadServiceMethod(method)我们看看是怎么执行的。
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;
}
loadServiceMethod这个方法，首先进行一下判断，也就是说先从缓存中获取，看看缓存中有没有这个请求方法，如果有的话，那就直接返回，没有的话，通过new ServiceMethod.Builder<>(this, method).build();
来构建，然后在保存起来。我们看看build()中的源码
public ServiceMethod build() {
//调用了createCallAdapter方法，它最终会得到我们在构建Retrofit调用build方法时adapterFactories添加的对象的get方法
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?");
}
//这里面通过遍历来拿到我们适合的Converter的转化对象，由于retrofit可以调用addConverterFactory添加多个，如Gson
responseConverter = createResponseConverter();
//这里主要是通过遍历拿到请求请求方法，如GET POST ,PUT这些
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);
}
//这里获取到我们接口上面的参数注解比如说@Query @QueryMap这些
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.");
}
//返回ServiceMethod对象
return new ServiceMethod<>(this);
}
上面这个方法主要目的就是为了拿到ServiceMethod对象。回过头来，我们继续看retrofit的create()方法
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
当拿到serviceMethod对象以后，接着就执行new OkHttpCall();来得到okHttpCall，并且最后返回serviceMethod.adapt(okHttpCall)，我们进入OkHttpCall()对象看看
final class OkHttpCall<T> implements Call<T> {
//------省略若干代码--------
@Override public synchronized Request request() {
okhttp3.Call call = rawCall;
if (call != null) {
return call.request();
}
if (creationFailure != null) {
if (creationFailure instanceof IOException) {
throw new RuntimeException("Unable to create request.", creationFailure);
} else if (creationFailure instanceof RuntimeException) {
throw (RuntimeException) creationFailure;
} else {
throw (Error) creationFailure;
}
}
try {
return (rawCall = createRawCall()).request();
} catch (RuntimeException | Error e) {
throwIfFatal(e); // Do not assign a fatal error to creationFailure.
creationFailure = e;
throw e;
} catch (IOException e) {
creationFailure = e;
throw new RuntimeException("Unable to create request.", e);
}
}
@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();
}
}
});
}
// --------省略若干代码---------
到这里，基本很明了，看过我前面的okhttp源码解析的朋友，这里就会觉得很熟悉了，这里通过实现 Call接口，然后通过request()和enqueue()这两个方法，然后将请求的结果回调回来，从而实现网络通信。
当然，这里只是retrofit一些基本的流程在源码中是这样走的，如果说要非常非常详细的源码，这不是一两篇文章能写完的，光retrofit就可以写出一本书了，当然，目前的水平，还没有达到那个地步，慢慢来。