1 简述
A type-safe HTTP client for Android and Java.
Retrofit 是基于RESTful风格的 HTTP 网络请求框架的封装。它的底层仍然基于OkHttp实现，算是OkHttp在Android上使用的改良。
// 这是一个例子
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
GitHubService service = retrofit.create(GitHubService.class);
Call<List<Repo>> repos = service.listRepos("halloayu");
repos.enqueue(new Callback<List<Repo>>() {
@Override
public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
Log.e("Main", response.body().get(0).toString());
}
@Override
public void onFailure(Call<List<Repo>> call, Throwable t) {
}
});
2 为什么会有Retrofit框架
OkHttp是安卓官方认证的网络请求框架，非常强大，但是它也有不少缺点，如下。
- OkHtt配置网络请求是非常繁琐的，尤其是配置复杂网络请求body、请求头、参数的时候。
- 数据解析过程需要用户手动拿到ResponseBody进行解析，难以复用。
- 无法自动进行线程切换。
- 万一我们存在嵌套网络请求，就会陷入“回调地狱”。
所以为了解决这些缺点，让网络请求在Android开发上易用，诞生了Retrofit框架，它本质上就也就是在OkHttp上套了层“壳子”，里面的请求还是基于OkHttp实现。
同时Retrofit设计的目的有两个方面。
- 请求前
- 可以统一配置网络请求头
- 可以很方便得复用Request，或创建request
- 请求后
- 子线程需切换到UI线程，便于界面刷新
- 返回数据可以解析为Java Bean，方便使用
3 主要封装的点
retrofit封装OkHttp主要是以下几点：
- build模式创建网络请求基本配置
- 用注解类组合HTTP网络请求
- 提供
Gson解析返回的json数据 - Executor完成线程切换
它请求实现的核心在于“注解”、“动态代理”、“反射”。
4 注解
Http有8种网络请求：GET、POST、PUT、DELETE、PATCH、HEAD、OPTIONS、HTTP
Retrofit通过20多个注解的组合实现了这几种请求。
5 动态代理
熟悉设计模式的都知道，代理模式的思想是通过一个“代理商”，让”用户“通过它处理难以处理的”事情“。
在最上面Retrofit的使用例子中，先是通过建造者模式创建了一个retrofit实例，然后走GitHubService service = retrofit.create(GitHubService.class)，这里面就是一个动态代码，我们来具体看看做了什么。
public <T> T create(final Class<T> service) {
// 验证接口
validateServiceInterface(service);
// 动态代理
return (T)
Proxy.newProxyInstance(
service.getClassLoader(),
new Class<?>[] {service},
new InvocationHandler() {
private final Platform platform = Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override
public @Nullable 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);
}
args = args != null ? args : emptyArgs;
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args);
}
});
}
从代码中我们可以看出，它代理了传入接口类中的所有接口方法，当我们调，service.listRepos("halloayu")，就会走InvocationHandler中的invoke方法。
// 从缓存中拿，没拿到，ServiceMethod进行处理
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;
}
ServiceMethod就像是一个中央处理器，传入Retrofit对象和Method对象，调用各个接口和解析器，最终生成一个Request，包含api 的域名、path、http请求方法、请求头、是否有body、是否是multipart等等。最后返回一个Call对象，Call接口的默认实现是OkHttpCall，它默认使用OkHttp3作为底层http请求client。
@Override
final @Nullable ReturnT invoke(Object[] args) {
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
// 使用适配器去转换返回数据
return adapt(call, args);
}
使用Java动态代理的目的就要拦截被调用的Java方法，然后解析这个Java方法的注解，最后生成Request由OkHttp发送。
// 异步请求源码
@Override
public void enqueue(final Callback<T> callback) {
Objects.requireNonNull(callback, "callback == null");
...
call.enqueue(
new okhttp3.Callback() {
@Override
public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
try {
// 解析返回数据，里面用我们配置的GSON解析
response = parseResponse(rawResponse);
} catch (Throwable e) {
throwIfFatal(e);
callFailure(e);
return;
}
try {
// 先走我们定义适配器转换数据，然后走自定义callback
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
throwIfFatal(t);
t.printStackTrace(); // TODO this is not great
}
}
@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) {
throwIfFatal(t);
t.printStackTrace(); // TODO this is not great
}
}
});
}
6 线程切换
Retrofit实现子线程到主线程的切换也是基于Handler。
static final class Android extends Platform {
Android() {
super(Build.VERSION.SDK_INT >= 24);
}
@Override
public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Nullable
@Override
Object invokeDefaultMethod(
Method method, Class<?> declaringClass, Object object, Object... args) throws Throwable {
if (Build.VERSION.SDK_INT < 26) {
throw new UnsupportedOperationException(
"Calling default methods on API 24 and 25 is not supported");
}
return super.invokeDefaultMethod(method, declaringClass, object, args);
}
static final class MainThreadExecutor implements Executor {
// Handler
private final Handler handler = new Handler(Looper.getMainLooper());
@Override
public void execute(Runnable r) {
handler.post(r);
}
}
}
请求后，先走默认的线程切换适配器DefaultCallAdapterFactory，然后走自定义的callback。
@Override
public void enqueue(final Callback<T> callback) {
Objects.requireNonNull(callback, "callback == null");
// 切换线程
delegate.enqueue(
new Callback<T>() {
@Override
public void onResponse(Call<T> call, final Response<T> response) {
callbackExecutor.execute(
() -> {
if (delegate.isCanceled()) {
// Emulate OkHttp's behavior of throwing/delivering an IOException on
// cancellation.
callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
} else {
callback.onResponse(ExecutorCallbackCall.this, response);
}
});
}
@Override
public void onFailure(Call<T> call, final Throwable t) {
callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));
}
});
}
7 总结
Retrofit的源码十分优秀，用注解的形式组合HTTP请求，通过代理接口，处理请求的逻辑，最后再执行请求。里面也大量使用反射，工厂方法，抽象接口来实现低耦合和高扩展，非常值得一读的开源框架！
