Retrofit
Retrofit用到了动态代理；
1.在 retrofit.create(interface service).service是用户自定义的一个请求数据Url相关的接口（一下同称自定义请求数据接口），这个接口不能继承其他的接口。原因如下：
1.进入create方法可以看到第一行的代码如下：
public <T> T create(final Class<T> service) {
Utils.validateServiceInterface(service);
这个方法是检测当前这个类是否符合要求。跳进去，代码如下：
static <T> void validateServiceInterface(Class<T> service) {
if (!service.isInterface()) {
throw new IllegalArgumentException("API declarations must be interfaces.");
}
// Prevent API interfaces from extending other interfaces. This not only avoids a bug in
// Android (http://b.android.com/58753) but it forces composition of API declarations which is
// the recommended pattern.
if (service.getInterfaces().length > 0) {
throw new IllegalArgumentException("API interfaces must not extend other interfaces.");
}
}
由第一个if语句可知这个类一定要是一个interface，第二个if语句则限定这个接口不能实现其他的接口。
1.Converter.Factory 用于创建转换ResponseBody的Converter的工厂类
Converter<T, V> 用于将T转换为V 的转换类。convert方法定义了转换的逻辑以及返回了最终转换的结果。
最基本的用法
1. Retrofit retrofit = new Retrofit.Builder()
2. .baseUrl("http://www.baidu.com/")
3. .addConverterFactory(EpgHomePageConverterFactory.create())
4. // .addConverterFactory(GsonConverterFactory.create())
5. .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
6. .build(); //返回一个Retrofit的对象
7. GetResponseService responseService = retrofit.create(GetResponseService.class);
8. //通过动态代理获取调用对应的方法，结合CallAdapter以及ConverterFactory获取对应的Call对象。
Call<EpgHomePage> responseBodyCall = responseService.getResponse("xxxxx","xxxxx",1);
9. //调用Call的异步网络请求，请求网络并获取结果。
responseBodyCall.enqueue(new Callback<EpgHomePage>() {
@Override
public void onResponse(Response<EpgHomePage> response, Retrofit retrofit) {
Log.i(TAG, response.body().getAreaUrl() + "areaUrl");
}
@Override
public void onFailure(Throwable t) {
}
});
跟踪上面代码，探究Retrofit的工作流程：
-
new Retrofit.Builder()给Retrofit添加一个默认的转换工厂，用于转换网络请求的结果或者生成网络请求对象。
public Builder() {
// 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());
}
-
baseUrl("http:/www.baidu.com/xxxx/xxxx/")根据字符串参数，生成对应的HttpUrl。
3.第七句，调用retrofit.create(GetResponseService.class)方法通过动态代理模式生成一个GetResponseService的实例。
4 . loadMethodHandler(method) 用于加载interface中的方法，并构建对应的网络请求url，Converter以及CallAdapter。
static MethodHandler<?> create(Retrofit retrofit, Method method) {
CallAdapter<Object> callAdapter = (CallAdapter<Object>) createCallAdapter(method, retrofit);
Type responseType = callAdapter.responseType();
Converter<ResponseBody, Object> responseConverter =
(Converter<ResponseBody, Object>) createResponseConverter(method, retrofit, responseType);
//根据方法的返回类型以及注释，构成RequestFactory，继而得到Request对象。
RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
return new MethodHandler<>(retrofit, requestFactory, callAdapter, responseConverter);
}
5 . invoke(arg) 传入方法的参数，然后通过OkHttp结合requestFactory和arg调用网络请求，并且通过responseConverter将请求的结果转换成对应的T.
Object invoke(Object... args) {
return callAdapter.adapt(new OkHttpCall<>(retrofit, requestFactory, responseConverter, args));
}
6.请求网络的操作在第九句，Call<EpgHomePage> 其实是OkHttpCall对象，让我们来看看enqueue方法。
@Override public void enqueue(final Callback<T> callback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed");
executed = true;
}
com.squareup.okhttp.Call rawCall;
try {
//获取一个Call对象 用于网络请求
rawCall = createRawCall();
} catch (Throwable t) {
callback.onFailure(t);
return;
}
if (canceled) {
rawCall.cancel();
}
this.rawCall = rawCall;
//执行网络请求，传入一个Okhttp的CallBack，回调函数中调用callback的方法，返回对应请求状态.
rawCall.enqueue(new com.squareup.okhttp.Callback() {
private void callFailure(Throwable e) {
try {
callback.onFailure(e);
} catch (Throwable t) {
t.printStackTrace();
}
}
private void callSuccess(Response<T> response) {
try {
callback.onResponse(response, retrofit);
} catch (Throwable t) {
t.printStackTrace();
}
}
@Override public void onFailure(Request request, IOException e) {
callFailure(e);
}
//关键 将请求结果转换成T类型。
@Override public void onResponse(com.squareup.okhttp.Response rawResponse) {
Response<T> response;
try {
response = parseResponse(rawResponse);
} catch (Throwable e) {
callFailure(e);
return;
}
callSuccess(response);
}
});
}
- response = parseResponse(rawResponse);
跳进parseResponse(rawResponse)看看是如何实现转换的。代码如下：
private Response<T> parseResponse(com.squareup.okhttp.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
// Remove the body's source (the only stateful object) so we can pass the response along.
rawResponse = rawResponse.newBuilder()
.body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
.build();
int code = rawResponse.code();
//请求失败
if (code < 200 || code >= 300) {
try {
// Buffer the entire body to avoid future I/O.
ResponseBody bufferedBody = Utils.readBodyToBytesIfNecessary(rawBody);
return Response.error(bufferedBody, rawResponse);
} finally {
closeQuietly(rawBody);
}
}
//请求成功
if (code == 204 || code == 205) {
return Response.success(null, rawResponse);
}
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
//通过调用ResponseCoverter的converter方法转换。
T body = responseConverter.convert(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
// If the underlying source threw an exception, propagate that rather than indicating it was
// a runtime exception.
catchingBody.throwIfCaught();
throw e;
}
}
通过以上源码跟踪分析：
总结 ：
- Converter.Factory<F,T>用于在最后请求的时候，将请求得到的结果转换成F之后再转换成泛型T.
- CallAdapter.Factory 决定了网络请求Call适配器，底层依然是OkhttpCall，不过可以通过自定义Call在OkHttpCall的基础上进行拓展。对应于自定一点的service的接口返回值类型。
Converter.Factory的方法返回CallAdapter<T>。
CallAdapter<T>的Get方法返回 自定义的service的返回值类型，改类型封装了Call对象。responseType 对应于函数的返回值类型。 - 默认会设置HttpClient，也可以自己设置HttpClient。
- 采用动态代理模式完成请求接口的实例化以及函数调用。
- 但是在Retrofit2.0 ，不管请求是否可以转换成功，onResponse都会被调用，但是请求返回的结果不能转换成相应的对象，'response.body()'将返回null，所以记住要处理情况！！！！
边学习源码，边做的一些随笔，写下来之后有其他理解在不断完善，有不对的多多指教，欢迎交流。O(∩_∩)O哈！
