Retrofit 2.5框架使用与源码分析

Retrofit 框架使用

请求内容与返回值

使用PostMan进行请求测试
请求：https://api.github.com/search/repositories?q=android

返回值：

Header:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AJwMe2by-1575109468105)(/assets/Retrofit.png)]

Body:

{
"total_count": 943593,
"incomplete_results": false,
"items": [
{
"id": 82128465,
"node_id": "MDEwOlJlcG9zaXRvcnk4MjEyODQ2NQ==",
"name": "Android",
"full_name": "open-android/Android",
"private": false,
"owner": {
"login": "open-android",
"id": 23095877,
"node_id": "MDQ6VXNlcjIzMDk1ODc3",
"avatar_url": "https://avatars2.githubusercontent.com/u/23095877?v=4",
//……
},
"html_url": "https://github.com/open-android/Android",
"description": "GitHub上最火的Android开源项目,所有开源项目都有详细资料和配套视频",
"fork": false,
"url": "https://api.github.com/repos/open-android/Android",
//……
},
{
"id": 12544093,
"node_id": "MDEwOlJlcG9zaXRvcnkxMjU0NDA5Mw==",
"name": "Android",
"full_name": "hmkcode/Android",
"private": false,
"owner": {
"login": "hmkcode",
"id": 3790597,
//……
},
//……
}
]
}

引入Retrofit依赖

implementation 'com.squareup.retrofit2:retrofit:2.5.0'
implementation 'com.squareup.retrofit2:converter-gson:2.5.0'

根据返回的请求结果定义Repository Bean类

返回的报文采用google.gson进行处理，金处理必要的值

public class RepoBean {

//用于表示Repo id
private int id;
//用于表示RepoName
private String name;

//用于表示完整名称
//Repository中json的返回值为 `full_name`，与定义的变量名不一致，使用注解`@SerializedName`进行标注
@SerializedName("full_name")
private String fullName;
//省略getter和setter
//……
}

根据返回的请求结果定义一次查询结果

public class SearchRepoBean {

//用于表示仓库数量
@SerializedName("total_count")
private int totalCount;
//用于表示是否为完整结果
private boolean incompleteResults;
//用于表示持有的所有的仓库类
private List<RepoBean>items;

//省略getter和setter
//……
}

定义网络请求API接口

public interface GithubService {
//@Get注解，表示以Get方法发送网络请求
//返回类型为Call<SearchRepoBean>，SearchRepoBean是接收数据的类，可以自定义
@GET("search/repositories")
Call<SearchRepoBean> getRepoInfo(@Query("q") String query);
}

初始化Retrofit实例，生成接口实现类

Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/") //设置网络请求的URL地址
.addConverterFactory(GsonConverterFactory.create()) //设置数据解析器
.build();

githubService = retrofit.create(GithubService.class);

进行网络请求

Call<SearchRepoBean> call = githubService.getRepoInfo("Android");
//同步请求方式
//call.request();
//异步请求方式
call.enqueue(new Callback<SearchRepoBean>() {
@Override
public void onResponse(Call<SearchRepoBean> call, Response<SearchRepoBean> response) {
//输出请求结果
// LogUtils.printInfo("搜索到的仓库的数量：" + response.body().getItems().size());
// List<RepoBean>repoBeans=new ArrayList<>();
// repoBeans.addAll(response.body().getItems());
// for (int i=repoBeans.size()-1;i>=0;i--){
// LogUtils.printInfo(repoBeans.get(i).getFullName());
// }
}

@Override
public void onFailure(Call<SearchRepoBean> call, Throwable t) {
}
});

将请求值的返回设为LiveData

将请求的返回值设为LiveData可以通过为Retrofit添加CallAdapterFactory来实现

public interface GithubService {
@GET("search/repositories")
LiveData<SearchRepoBean> getRepoInfo(@Query("q") String query);
}

自定义LiveDataCallAdapterFactory

public class LiveDataCallAdapterFactory extends CallAdapter.Factory {

@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {

//用于获取泛型的参数
Type observerType = getParameterUpperBound(0, (ParameterizedType) returnType);

Class<?> rawObserverType = getRawType(observerType);


LiveDataCallAdapter<Object> liveDataCallAdapter = new LiveDataCallAdapter<>(rawObserverType);

return liveDataCallAdapter;
}
}

自定义 LiveDataCallAdapter

public class LiveDataCallAdapter<R> implements CallAdapter<R, LiveData<SearchRepoBean>> {

private Type responseType;

public LiveDataCallAdapter(Type responseType){
this.responseType=responseType;
}

@Override
public Type responseType() {
return responseType;
}

@Override
public LiveData<SearchRepoBean> adapt(final Call<R> call) {

LiveData<SearchRepoBean>searchRepoBeanLiveData=new LiveData<SearchRepoBean>() {

@Override
protected void onActive() {
super.onActive();
call.enqueue(new Callback<R>() {
@Override
public void onResponse(Call<R> call, Response<R> response) {
postValue((SearchRepoBean) response.body());
}

@Override
public void onFailure(Call<R> call, Throwable t) {
LogUtils.printInfo("error");
}
});
}
};
//这里的return 即为下文中githubService.getRepoInfo("Android")调用的返回值
return searchRepoBeanLiveData;
}
}

为Retrofit实例添加CallAdapterFactory

Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(new LiveDataCallAdapterFactory())
.build();

调用方法

repoBeanLiveData = githubService.getRepoInfo("Android");
repoBeanLiveData.observe(GithubApiActivity.this, new Observer<SearchRepoBean>() {
@Override
public void onChanged(SearchRepoBean searchRepoBean) {
//输出结果
}
});

添加通用的响应实体

通过LiveDataCallAdapter 和LiveDataCallAdapterFactory 可以将返回的数据表示为LiveData数据形式，且只能对返回结果为SearchRepoBean类型的JSON字符串进行处理。如果是返回其他的实体则需要重新构造适配器。

定义一个通用的响应实体

public class ApiResponse<T> {

public ApiResponseSuccess<T> create(Response<T> response) {
if (response.isSuccessful()) {
return new ApiResponseSuccess<T>(response.body());
} else {
return null;
}
}

//用于表示返回成功的值
public static class ApiResponseSuccess<T> extends ApiResponse<T> {
/用于表示请求返回成功的内容，在本代码中是SearchRepoBean
private T body;

public ApiResponseSuccess(T body) {
this.body = body;
}

public T getBody() {
return body;
}
}
}

修改LiveDataCallAdapterFactory

public class LiveDataCallAdapterFactory extends CallAdapter.Factory {

@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
//用于获取泛型的参数
//return type为LiveData<ApiResponse<SearchRepoBean>>
//observerType为ApiResponse<SearchRepoBean>
Type observerType = getParameterUpperBound(0, (ParameterizedType) returnType);
//bodyType为SearchRepoBean
Type bodyType = getParameterUpperBound(0, (ParameterizedType) observerType);
LiveDataCallAdapter<Object> liveDataCallAdapter = new LiveDataCallAdapter<>(bodyType);

return liveDataCallAdapter;
}
}

修改LiveDataCallAdapter

public class LiveDataCallAdapter<R> implements CallAdapter<R,LiveData<ApiResponse<R>>> {

private Type responseType;

public LiveDataCallAdapter(Type responseType){
this.responseType=responseType;
}

@Override
public Type responseType() {
return responseType;
}

@Override
public LiveData<ApiResponse<R>> adapt(final Call<R> call) {
LiveData<ApiResponse<R>> result=new LiveData<ApiResponse<R>>() {
@Override
protected void onActive() {
super.onActive();
call.enqueue(new Callback<R>() {
@Override
public void onResponse(Call<R> call, Response<R> response) {
postValue(new ApiResponse<R>().create(response));
}

@Override
public void onFailure(Call<R> call, Throwable t) {
// LogUtils.printInfo("+++++!2312qwqweww31");
}
});
}
};
return result;
}
}

修改调用方法

repoBeanLiveData = githubService.getRepoInfo("Android");
repoBeanLiveData.observe(GithubApiActivity.this, new Observer<ApiResponse<SearchRepoBean>>() {
@Override
public void onChanged(ApiResponse<SearchRepoBean> searchRepoBeanApiResponse) {
SearchRepoBean searchRepoBean = (SearchRepoBean) ((ApiResponse.ApiResponseSuccess) searchRepoBeanApiResponse).getBody();
//输出结果
}
});

源码详解

Retrofit构建中的.baseUrl("https://api.github.com/")介绍

Retrofit源碼，Retrofit在源码中使用建造者模式进行实例化，将String类型的地址转换为OKhttp3中的HttpUrl类型

public final class Retrofit {

public static final class Builder {
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;
}
}
}

Retrofit构建中的.addConverterFactory(GsonConverterFactory.create())

通过.addConverterFactory()传入我们需要的ConverFactory，目的是将responseBody转换成我们的Bean类，在这里我们使用的是GsonConverterFactory

public Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}

Converter接口源码，核心是T convert(F value),将F类型的数据转换为T类型

public interface Converter<F, T> {
//将F类型的数据转换为T类型
@Nullable T convert(F value) throws IOException;

//根据数据类型创建Converter创建 Converter
abstract class Factory {
//将HTTP响应的body体转换成type,type是由CallAdapter 接口里面的responseType()函数返回的。
public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type,
Annotation[] annotations, Retrofit retrofit) {
return null;
}

//将API方法的输入参数使用注解@Body, @Part 和 @PartMap标记的类型，从type转换为RequestBody
public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
return null;
}
//将API方法的输入参数使用注解@Header, @HeaderMap, @Path, @Query 和 @QueryMap 标记的类型从type转换为String
public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
return null;
}

protected static Type getParameterUpperBound(int index, ParameterizedType type) {
return Utils.getParameterUpperBound(index, type);
}

protected static Class<?> getRawType(Type type) {
return Utils.getRawType(type);
}
}
}

Retrofit构建中的.addCallAdapterFactory(new LiveDataCallAdapterFactory())

用于添加数据适配器，在HttpServiceMethod实例生成的时候会调用

public final class Retrofit {
final List<CallAdapter.Factory> callAdapterFactories;
//…………
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
callAdapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
//…………
}

最终用来创建Service的代码retrofit.create(GithubService.class)

create()采用代理的方式进行创建，

public final class Retrofit {
//……
public <T> T create(final Class<T> service) {
//判断定义的接口服务是否可用
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(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 Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
// 如果是Object本身的方法，正常调用后返回
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
//如果是platform默认的方法，正常调用后返回
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
//解析我们定义的网络请求的方法
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});
}
//……
}

loadServiceMethod(Method method)源码解析,其实际上是HttpServiceMethod对象

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;
}

static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method)源码

abstract class ServiceMethod<T> {
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//RequestFactory负责解析接口并且生成Request
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

//…………
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}

abstract T invoke(Object[] args);
}

HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory)源码

//将一个接口方法转变为一个Http请求
final class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
//创建HTTP请求的CallAdapter，在下面有createCallAdapter()源码
CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method);
//……
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);

okhttp3.Call.Factory callFactory = retrofit.callFactory;
return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter);
}

private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
Retrofit retrofit, Method method) {
Type returnType = method.getGenericReturnType();
Annotation[] annotations = method.getAnnotations();
try {
//retrofit.callAdapter()返回 Retrofit实例化中.addCallAdapterFactory(new LiveDataCallAdapterFactory())添加的CallAdapter
return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create call adapter for %s", returnType);
}
}

//…………

private final RequestFactory requestFactory;
private final okhttp3.Call.Factory callFactory;
private final CallAdapter<ResponseT, ReturnT> callAdapter;
private final Converter<ResponseBody, ResponseT> responseConverter;

private HttpServiceMethod(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
CallAdapter<ResponseT, ReturnT> callAdapter,
Converter<ResponseBody, ResponseT> responseConverter) {
this.requestFactory = requestFactory;
this.callFactory = callFactory;
this.callAdapter = callAdapter;
this.responseConverter = responseConverter;
}

//代理调用的invoke最终会调用下面invoke方法
@Override ReturnT invoke(Object[] args) {
return callAdapter.adapt(
new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}
}


`call.enqueue(new Callback<SearchRepoBean>() {})`最终调用的方法是OkhttpCall中的`call.enqueue(new okhttp3.Callback() {})`

```java

final class OkHttpCall<T> implements Call<T> {

//……
@Override public void enqueue(final Callback<T> callback) {

//……
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
//……
try {
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
//……
}