前言：Retrofit是基于OkHttp封装的一个网络请求框架，既然是OkHttp的上层框架，当然是解决了OkHttp在开发中的一些痛点。具体的来说：
- 使用过程中接口配置繁琐，OkHttp中每发起一个请求都要新建一个Request，当要配置复杂请求（body，请求头，参数）
时尤其复杂。 - 需要用户拿到responseBody后自己手动解析，解析工作应该是可以封装的。
- 无法适配自动进行线程切换。
- 嵌套网络请求会陷入“回调陷阱”
Retrofit基本使用
依赖：
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'//数据解析（可选）
implementation 'com.squareup.retrofit2:adapter-rxjava:2.9.0'//RxJava适配器（可选）
构建接口Service：
public interface ApiService {
@GET("users/{users}")
Call<UserBean> getUserData(@Path("users") String users);
}
使用：
static Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://gitee.com/api/v5/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
final ApiService service = retrofit.create(ApiService.class);
final Call<UserBean> result = service.getUserData("caoyangim");
result.enqueue(new Callback<UserBean>() {
public void onResponse(Call<UserBean> call, Response<UserBean> response) {
if (response.isSuccessful()){
System.out.println("success:"+response.body());
}
}
public void onFailure(Call<UserBean> call, Throwable throwable) {
System.out.println("ERROR:"+throwable.toString());
}
});
注解
- get
- post
- put
- delete
- patch
- head
- options
- http 通用注解，可以替换以上所有注解，其拥有method，path，hasbody三个属性
源码解析
构建Retrofit网络实例对象
在创建retrofit网络实例对象的时候用到了build建造者模式【一般 配置参数大于5个 & 参数可选 就要用build模式了】，代码如下：
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
//默认只支持OKHttpClient,不支持httpUrlConnection和httpClient
//不过你也可以自己构建一个HTTPClient，传给callFactory
if (callFactory == null) {
callFactory = new OkHttpClient();
}
//为线程切换准备了一个execute，可以点进去看，这个Executor在Android平台下其实就是Handler
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
/**
* 返回的excutor就是这个:
static final class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override
public void execute(Runnable r) {handler.post(r);}
}
**/
}
//网络请求适配工厂的集合，构造时传入的RxJavaCallAdapter会传到这里面来
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
//数据转换工厂的集合，传入的GsonAdapter到这里来
List<Converter.Factory> converterFactories =
new ArrayList<>(
1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
...
return new Retrofit(
callFactory,
baseUrl,
unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories),
callbackExecutor,
validateEagerly);
}
}
TIP:Retrofit在这里提供了一个统一的入口，所有需要的东西都通过build模式往里面加就行了，用的时候也是用retrofit.create()用，所以这里也用到了“外观(门面)模式”
retrofit.create()
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);
}
});
}
这里面用到了动态代理的技术，你传入一个带有获取数据方法的接口，这个方法帮你动态的生成一个代理类继承该接口，这样一来所有的获取数据的方法都走这里的invoke函数，就可以拦截调用函数的执行，从而将网络接口的参数配置归一化。
即你每次发起网络请求看似是走的自己定义的接口，实际上它是会走到这个方法中来的。
然后往下一般会走loadServiceMethod(method)方法，此方法的作用是解析传入的这个方法，主要是通过解析它的注解获取请求路径、传递参数等属性，返回的是一个ServiceMethod对象。
loadServiceMethod
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/HttpServiceMethod
image-20210221151029435.png
里面还有几个属性：
abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
...
private final RequestFactory requestFactory;
private final okhttp3.Call.Factory callFactory;
private final Converter<ResponseBody, ResponseT> responseConverter;
}
image-20210221151159987.png
retrofit构建了所有的网络请求共同的一些属性，而serviceMethod对应着某个单独的网络请求，其内部属性更加具体化。
请求数据-getUserData
因为用到了动态代理模式，所有不管你接口中写了什么自定义的请求方法，他都会被转到动态代理的类中来：即上面说到的loadServiceMethod():
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args);
loadServiceMethod中会走到parseAnnotations中,返回了一个ServiceMethod对象：
@Override
final @Nullable ReturnT invoke(Object[] args) {
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
return adapt(call, args);
}
@Override
protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
return callAdapter.adapt(call);
}
返回值的类型根据callAdapter来定，一般可以用defalultCallAdapter,RxJavaCallAdapter 或者也可以自定义callAdapter，只需重写adapt方法即可：收到的是call,根据自己的需求返回即可。
enqueue
enqueue最终是调用到了OkHttpCall.enqueue方法中来，在这里面实际上是用到了okhttp的相关方法，比如createRawCall()：
private okhttp3.Call createRawCall() throws IOException {
okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
返回的是okHttp3中的call，然后用这个call：
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) {
throwIfFatal(e);
callFailure(e);
return;
}
try {
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
}
}
});
这些都是okhttp3的用法，被封装到了retrofit中。
再在返回结果的时候用到callbackExecutor.execute来切换了线程，executor实际上是：
static final class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override
public void execute(Runnable r) {
handler.post(r);
}
}
设计模式
retrofit中用到了门面（外观）模式，建造者模式，代理模式（动态代理）等设计模式的思想。
retrofit中你可以通过很多组件式的方式使用，比如callAdapter的选择上，可以选择java8的，可以选择RxJava/RxJava2的，scala的方式来编码；获取数据后数据转换方面（convert）,可以使用gson ,jackson,moshi甚至xml的方式，都可以自己根据需求选择。这些可以自定义的来组合使用，即外观模式。
建造者模式和代理模式分别在业务代码和源码中可以体现出来。
网友评论