Retrofit网络通信库简单封装使用

Retrofit 这个网络库相信用过的都能体会到它的强大，这个库本身已经封装的很优雅了，注解使用起来也很方便，这里我再对这个库封装是为了方便公司接口使用而进行的。注意，这里没有使用Rxjava转换，用的是Gson转换，因为公司项目并没有导入Rxjava，所以都用Gson来处理。

源代码地址：https://github.com/Rukey7/RetrofitSample

一般公司的接口返回的数据都有一个固定格式，举个简单例子：

{
"data": {.... },
"msg": "获取数据成功",
"status": "1"
}

这里的字段，status：返回为请求是否成功；msg：描述信息；data：返回的具体请求数据，可能是一个实体或一个列表，上面返回的是一个实体。返回列表的格式如下：

{
"data": [
{.... },
{.... }
],
"msg": "获取数据成功",
"status": "1"
}

一. Retrofit的使用

具体格式有了，下面就开始编写Api接口了。首先定义一个统一格式的返回实体，对照上面的Json格式如下：

public class BaseResponse {

private String status;
private String msg;
private Object data;

public Object getData() {
return data;
}

public void setData(Object data) {
this.data = data;
}

public String getStatus() {
return status;
}

public void setStatus(String status) {
this.status = status;
}

public String getMsg() {
return msg;
}

public void setMsg(String msg) {
this.msg = msg;
}

@Override
public String toString() {
return "BaseResponse{" +
"status='" + status + '\'' +
", msg='" + msg + '\'' +
", data=" + data +
'}';
}
}

这里需要注意的是data字段要用Object不能用String，我用Gson再将String数据解析为实体时会报错，不知道是不是我写的问题，我用fastjson就没问题，所以这里用Object类型。

下面定义两个请求接口，一个返回实体，一个返回列表：

public interface IUserService {

@GET("user/your")
Call<BaseResponse> user(@Query("id") int id);

@GET("users/your/list")
Call<BaseResponse> userList(@Query("param") String param);
}

来看一下我们正常使用流程，比如获取user信息接口：

public void userInfo() {
// 创建Retrofit
Retrofit retrofit = new Retrofit.Builder()
.addConverterFactory(GsonConverterFactory.create())
.baseUrl("https://api.yoururl.com/")
.build();
// 创建IUserService
IUserService userService = retrofit.create(IUserService.class);
// 创建请求
Call<BaseResponse> call = userService.user(10086);
// 执行请求
call.enqueue(new Callback<BaseResponse>() {
@Override
public void onResponse(Call<BaseResponse> call, Response<BaseResponse> response) {
Gson gson = new Gson();
try {
BaseResponse body = response.body();
// 先判断状态值
if (body.getStatus().equals("1")) {
// 将Object对象转化为json字符串
String jsonData = gson.toJson(body.getData());
// 将json字符串转化为对象实体
UserInfo info = gson.fromJson(jsonData, UserInfo.class);
// 判断解析是否成功
if (info == null) {
onFailure(call, new Throwable("对象解析失败"));
} else {
// 获取到数据，开始处理数据
}
} else {
onFailure(call, new Throwable(body.getMsg()));
}
} catch (Exception e) {
onFailure(call, e);
}
}

@Override
public void onFailure(Call<BaseResponse> call, Throwable t) {
// 失败处理
}
});
}

整个代码调用算是正常流程，这里面肯定有很多冗余代码可以提取出来，看下怎么封装让接口使用更简单，下面开始对接口进行封装。

二. 封装接口

首先来把Gson数据处理的功能封装成一个帮助类：

public final class GsonHelper {

private static Gson sGson = new Gson();
private static JsonParser sJsonParser = new JsonParser();

/**
* 将json数据转化为实体数据
* @param jsonData json字符串
* @param entityClass 类型
* @return 实体
*/
public static <T> T convertEntity(String jsonData, Class<T> entityClass) {
T entity = null;
try {
entity = sGson.fromJson(jsonData.toString(), entityClass);
} catch (JsonSyntaxException e) {
e.printStackTrace();
}
return entity;
}

/**
* 将json数据转化为实体列表数据
* @param jsonData json字符串
* @param entityClass 类型
* @return 实体列表
*/
public static <T> List<T> convertEntities(String jsonData, Class<T> entityClass) {
List<T> entities = new ArrayList<>();
try {
JsonArray jsonArray = sJsonParser.parse(jsonData).getAsJsonArray();
for (JsonElement element : jsonArray) {
entities.add(sGson.fromJson(element, entityClass));
}
} catch (JsonSyntaxException e) {
e.printStackTrace();
}
return entities;
}

/**
* 将 Object 对象转为 String
* @param jsonObject json对象
* @return json字符串
*/
public static String object2JsonStr(Object jsonObject) {
return sGson.toJson(jsonObject);
}
}

功能还是比较清晰的，主要就是对泛型的处理，分别提供了转换实体和实体列表两个主要方法，用来转化Gson数据还是很方便的。

接下来对CallBack<BaseResponse>也进行一层封装，如下：

/**
* 对CallBack进行封装
*/
public abstract class RequestCallBack implements Callback<BaseResponse> {

// 请求成功是的状态值
private static final String RESPONSE_SUCC = "1";
// 请求失败是的状态值
private static final String RESPONSE_FAIL = "-1";

// 测试用
public static boolean mIsList = false;

@Override
public void onResponse(Call<BaseResponse> call, Response<BaseResponse> response) {
BaseResponse body = response.body();
_handleResponse(body);
}

@Override
public void onFailure(Call<BaseResponse> call, Throwable t) {
t.printStackTrace();
onError(t.getMessage());
}

/**
* 处理应答
* @param response 应答实体
*/
private void _handleResponse(BaseResponse response) {
try {
if (RESPONSE_SUCC.equals(response.getStatus())) {
// 请求成功才处理数据
onDataObtain(GsonHelper.object2JsonStr(response.getData()));
} else {
onError(response.getMsg());
}
} catch (Exception e) {
if (e.getMessage() == null) {
onError("thread exiting with uncaught exception");
} else {
onError(e.getMessage());
}
}
}

/**
* 获取json数据
* @param jsonData json字符串
* @return
*/
protected abstract void onDataObtain(String jsonData);

/**
* 获取错误数据
* @param errMsg 错误数据
*/
protected abstract void onError(String errMsg);
}

这里主要工作是从BaseResponse实体中提取出data数据，并转换为json字符串格式传给上层进一步处理，这里也对异常情况进行了初步处理。当然，可能根据实际需要对BaseResponse数据进行更加细致的处理，这个就看实际需求来处理了。
下面自定义个监听器用来获取我们需要的数据：

/**
* 请求监听器
*/
public interface OnRequestListener<T> {

/**
* 获取请求实体数据
* @param entity 实体
*/
void onResponse(T entity);

/**
* 请求失败
* @param errorMsg 异常数据
*/
void onFailure(String errorMsg);
}

这个没什么好说明的，就是有个泛型处理，等下用到就知道了。

现在只差一个功能模块，就是把Call请求、Gson数据和OnRequestListener监听器关联起来，下面是这个功能模块的代码：

/**
* 请求处理的通用模块
*/
public final class ServiceHelper {

private ServiceHelper() {
throw new RuntimeException("ServiceHelper cannot be initialized!");
}

/**
* 获取单个实体的处理操作
*
* @param call        请求
* @param entityClass 实体类型
* @param listener    监听器
*/
public static <T> void callEntity(Call<BaseResponse> call, final Class<T> entityClass,
final OnRequestListener<T> listener) {
call.enqueue(new RequestCallBack() {
@Override
protected void onDataObtain(String jsonData) {
T info = GsonHelper.convertEntity(jsonData, entityClass);
if (info == null) {
if (listener != null) {
listener.onFailure("对象解析失败");
}
} else {
if (listener != null) {
listener.onResponse(info);
}
}
}

@Override
protected void onError(String errMsg) {
if (listener != null) {
listener.onFailure(errMsg);
}
}
});
}

/**
* 获取复数实体的处理操作
*
* @param call        请求
* @param entityClass 实体类型
* @param listener    监听器
*/
public static <T> void callEntities(Call<BaseResponse> call, final Class<T> entityClass,
final OnRequestListener<List<T>> listener) {
call.enqueue(new RequestCallBack() {
@Override
protected void onDataObtain(String jsonData) {
List<T> infos = GsonHelper.convertEntities(jsonData, entityClass);
if (infos.size() == 0) {
if (listener != null) {
listener.onFailure("对象解析失败");
}
} else {
if (listener != null) {
listener.onResponse(infos);
}
}
}

@Override
protected void onError(String errMsg) {
if (listener != null) {
listener.onFailure(errMsg);
}
}
});
}
}

这里提供两个方法，一个用来获取单个实体，一个用来获取实体列表，还是很清晰的。这里同样对泛型进行了处理，并把前面几样东西都关联了起来，所有功能都通过这里进入来处理，包括执行请求->解析对象->调用监听回调。

该写的都写好了，下面就看怎么调用了，比如我们要使用获取单个用户信息接口，可以这样写：

/**
* 获取单个实体
* @param id 参数
* @param listener 请求监听
* @return 通信回调接口，用来取消通信
*/
public static Call userInfo(int id, OnRequestListener<UserInfo> listener) {
Call<BaseResponse> call = sUserService.user(id);
ServiceHelper.callEntity(call, UserInfo.class, listener);
return call;
}

获取用户列表接口这样写：

/**
* 获取实体列表
* @param param 参数
* @param listener 请求监听
* @return 通信回调接口，用来取消通信
*/
public static Call userList(String param, OnRequestListener<List<UserInfo>> listener) {
Call<BaseResponse> call = sUserService.userList(param);
ServiceHelper.callEntities(call, UserInfo.class, listener);
return call;
}

可以看到整个实际只要两行代码：生成一个call请求；使用ServiceHelper执行请求并解析数据。没了！还是很方便的有木有。

写的有点晕，有兴趣看下代码估计更好理解- -,其它的网络缓存和请求取消控制管理看具体业务怎么处理再加上去。