这篇主要分析一下retrofit源码,分析的切入点就是从使用流程开始。
使用方式
* Retrofit retrofit = new Retrofit.Builder()
* .baseUrl("https://api.example.com/")
* .addConverterFactory(GsonConverterFactory.create())
* .build();
*
* MyApi api = retrofit.create(MyApi.class);
* * Response <User> user = api.getUser().execute();
首先是创建Retrofit实例，和okhttp一样依然使用builder方式创建，那我们就看看builder这个retrofit内部类干了什么。
首先看builder的注释：
Build a new {@link Retrofit}.
Calling {@link #baseUrl} is required before calling {@link #build()}. All other methods
are optional.
大概意思是说通过这个内部类去创建一个Retrofit，而且baseurl是必须的，还得在build()方法之前调用，其他的方法都是可选的，根据你自己的需求你想加就加。
new Retrofit.Builder()这一句，这个是创建了一个builder内部类。我们看它的构造方法：
private final Platform platform;
Builder(Platform platform) {
this.platform = platform;
}
public Builder() {
this(Platform.get());
}
恩，看到了，我们调用的是无参数的构造方法，然后无参的又调用了一个有参的，传递了一个叫 Platform的一个类。为了一步步明白，我们就看看这个类是干嘛的，Platform.get()这个方法获取了这个对象，说明是一个单例对象：
class Platform {
private static final Platform PLATFORM = findPlatform();
static Platform get() {
return PLATFORM;
}
}
啊呀呀，果不其然，定义了一个静态，final的对象，而且是提前通过一个findPlatform()方法获取好了。那我们就追究进去：
class Platform {
private static Platform findPlatform() {
try {
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0) {
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName("java.util.Optional");
return new Java8();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}
哦~~，作为一个android开发者，只看前三句就可以了，直接创建了一个Android对象返回了，这是个什么动动？不急，继续贴代码：
static class Android extends Platform {
@IgnoreJRERequirement // Guarded by API check.
@Override boolean isDefaultMethod(Method method) {
if (Build.VERSION.SDK_INT < 24) {
return false;
}
return method.isDefault();
}
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
if (callbackExecutor == null) throw new AssertionError();
return new ExecutorCallAdapterFactory(callbackExecutor);
}
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
}
自己看吧，它是个什么？就是上面Platform的一个子类，这里面有三个方法：
- 第一个，重点在
method.isDfault()，返回一个boolean值，这个方法是java 8新加入的方法，判断传进来的方法是不是一个default方法，default修饰的方法是定义在接口中的可以带有方法体的方法，用于在接口中增加新的方法的时候不至于让其他的实现类都改动。所以这里要判断，如果你写了一个那样的方法，retrofit是不允许的，retrofit只要你定义普通的接口方法。 - 第二个方法 是返回默认的结果回调线程，这个在你自己不设置的时候，retrofit默认用这个。我们看到MainThreadExecutor是paltform的一个内部类，她里面创建了一个关联主线程looper的handler。
- 第三个方法是返回默认的一个适配器。关于适配器这块我们专门讲后续。
下面继续看Builder类的baseurl()
public Builder baseUrl(String baseUrl) {
checkNotNull(baseUrl, "baseUrl == null");
return baseUrl(HttpUrl.get(baseUrl));
}
public Builder baseUrl(HttpUrl baseUrl) {
checkNotNull(baseUrl, "baseUrl == null");
List<String> pathSegments = baseUrl.pathSegments();
if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
}
this.baseUrl = baseUrl;
return this;
}
这个方法就是创建了一个HttpUrl对象，赋值给了build类的一个成员变量，没什么。
再看build(),这个方法是最后创建出Retrofit对象的：
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);
}
}
好了，我们看一下吧，首先判断baseurl，callfactory是真正用来发起请求的，retrofit默认是用的okhttpClient，你也可以设置自己的okhttpClient:
/**
* The HTTP client used for requests.
* <p>
* This is a convenience method for calling {@link #callFactory}.
*/
public Builder client(OkHttpClient client) {
return callFactory(checkNotNull(client, "client == null"));
}
看到没，这个builder类里面的client方法就可以设置你自己http client。
接下来是设置结果响应的线程，如果为空，那么就用平台自己默认设置的，platform.defaultCallbackExecutor()这个方法就是返回Android平台Retrofit自己写好的在主线程。
接下来是创建了一个适配器的副本几集合，并且在这个副本集合中添加了Retrofit默认的一个适配器。
接着又创建了一个转换器的副本集合，并且添加了一个内置的转换器。
最后调用retrofit的构造方法:
new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly)
将http client，url，转换集合，适配器集合，回调线程等传入。unmodifiableList()方法功能是将集合设置为只读的。
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的构造方法，什么都没干，就是把builder中的一些参数保存了。
总结：
好了，关于retrofit第一篇就到这里了。大汗淋漓的写了一大篇幅，发现好像什么都没说，什么都没写，好吧，道行太浅了。
