android http——网络请求二次封装的框架设计

android app中少不了要用到网络请求。网上已经有很多优秀的网络请求框架，谷歌推荐的okhttp、齐射并发的volley 、异步请求的asynchttp。

但是我要说的并不是重新设计网络请求框架，而是基于所有优秀网络请求框架进行的二次封装，成为一个为自己项目所用的网络请求。

不要问为什么这么做，只要你使用到了网络请求，不管有没有用第三方请求框架都必须为它（网络请求流程处理）再次设计一个简单易用的框架，我们把这个过程叫做网络请求的二次封装。

先来看看一个网络请求的流程：

1，get，post请求数据

请求数据需要url，如果是post请求还需要一个map集合在存储请求参数；

那么就可以把请求数据看作：

String url="http://192.168.1.1:8080/websservice/index/selectindex.action?";
Map<String,Object> parameters=new HashMap();
parameters.put("userinfo.name","admin");
parameters.put("userinfo.password","admins1");

这么一个数据结构。

2，发出请求

private void sendPostRequest(String url, Map<String, Object> params) {
//首先判断是否有网络
if (!NetWorkUtil.isNetworkConnected(mContext)) return;
HttpClient.post(Context, url, params, new HttpBack() {

@Override
public void onSuccess(int statusCode, byte[] responseBody) {
try {
String jsonSuccess = new String(responseBody, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
}
}

@Override
public void onFailure(int statusCode, byte[] responseBody, Message error) {
try {
String jsonFinal = new String(responseBody, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
}
}
});

这段代码只是模拟一个post网络请求，并且经过一系列的处理返回成功或者失败到相应的接口。

3，处理结果

拿到结果后 我们一般会根据服务器返回的固定字段来解析json数据：

//状态码
String TAG_STATUS_CODE = "statusCode";

//请求失败后的失败内容
String TAG_MESSAGE = "message";

//json对象
String TAG_OBJECT = "object";

//json集合
String TAG_OBJECTS = "objects";

通过和服务器返回数据相匹配来解析json并保存到相应的实体类中。

4，显示结果

当我们拿到处理后的结果后要发送给相应的页面用于显示。这时候的处理就“八仙过海各显神通”了。不过最常见的就是通过观察者模式，让结果进入发送者内，然后给所有观察者发送网络请求的处理结果。

这就是一个网络请求的大致流程。其中具体的网络请求网上就有很多优秀的处理框架了。我们也没有必要再去自己写，况且自己写的不一定完美。

所以，我们要做的就是既要用别人的框架也要将别人的框架和自己app的耦合性降到最低。

那么我们应该从什么地方入手呢？

先看一张图：



这就是大概的一个接口对接的示意图。

而我们要做的部分就是将红色框，即app内部请求和解析进行二次封装。

—————————————————分割线———————————————–

那么我要说的就是为网络请求流程处理设计的框架。

先来看一张我要讲的网络请求二次封装的框架结构示意图：



得到处理过的结果的ResponseResult类（也就是图中的ResponseSuccess等类）可以使用观察者模式向所有的观察者发出请求返回结果。

接下来我们就一步一步的实现这个二次封装的框架。等到成品出来后，各位看客就能感受到它的简单和易用是多么的强大。

1，准备工作

/**
* 请求的url
*/
public class RequestUrls {

public static final String IP = "http://192.168.1.1:8080/";//url
public static final String ROOT_URL = IP + "HttpService/";//项目名

/**
* 获取首页数据的URL
*/
public static final String GET_INDEX_CONTENT_URL = ROOT_URL + "index/selectIndexContent.action";

}

/**
* 服务器返回状态吗
*/
public class StatusCode {
/**
* 状态码:请求成功
*/
public static final int REQUEST_SUCCESS = 200;

/**
* 状态码：没有更多数据
*/
public static final int NOT_MORE_DATA = 201;

/**
* 状态码：服务器繁忙
*/
public static final int SERVER_BUSY = 300;

/**
* 状态码：未知错误
*/
public static final int SERVER_ERROR = 500;
}

还有MD5Util、Base64、NetWorkUtil；

这没有什么可说的。

2，生成默认参数和参数map实例

一般来说，一个网络请求必须带的几个参数：

1，app key；服务器与前端使用同一个名字来匹配。

2，时间戳；目的是为了控制这个请求在一个时间范围内有效。例如：两分钟。如果超过了两分钟，还在用这个请求请求服务器那就不会成功。

3，接口版本号；升级专用。前端app升级后为了兼容后台接口而定制的。

4，sign（md5加密）；这个加密方式每个人有每个人的做法。我的做法是将所有的请求参数加起来生成一个md5密文然后后台拿到我的请求参数后同样的方法生成一个md5密文然后匹配。

这些参数应该和服务器一起去协商定义。

那么有了这些写死的，每次请求都要有的参数我们就可以提前实例化一个map先把他们存起来。

/**
* 生成默认参数和参数map实例
*/
public class SignUtils {

public static final String KEY_SIGN = "sign";

public static final String KEY_PRIVATE = "key";

public static final String KEY_TIMESTAMP = "timestamp";

public static final String KEY_VERSION = "version";

public static String getSignMD5(Map<String, Object> param) {
Collection<String> keySet = param.keySet();
List<String> list = new ArrayList<>(keySet);

//对key键值按字典升序排序
Collections.sort(list);
String paramStr = "";
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equals(KEY_SIGN)) continue;
paramStr += list.get(i) + "=" + param.get(list.get(i)) + "&";
}
if (!TextUtils.isEmpty(paramStr))
paramStr = paramStr.substring(0, paramStr.length() - 1);
return MD5.MD5(paramStr);
}

public static Map<String, Object> getParameters() {
Map<String, Object> params = new HashMap<>();
params.put(KEY_PRIVATE, "alsfoxShop_plat");
params.put(KEY_VERSION,"1.01");
params.put(KEY_TIMESTAMP, System.currentTimeMillis());
return params;
}
}

3，定义网络请求方法接口

/**
* 该接口规定所有请求所需的常量和方法
*/
public interface IRequest {

//状态码
String TAG_STATUS_CODE = "statusCode";

//请求失败后的失败内容
String TAG_MESSAGE = "message";

//json对象
String TAG_OBJECT = "object";

//json集合
String TAG_OBJECTS = "objects";

//默认超时时间
int VALUE_DEFAULT_TIME_OUT = 20 * 1000;

/**
* 发送get请求
*/
void sendGetRequest(RequestAction action);

/**
* 发送post请求，包含多文件上传方式的传文件
*
* @param action 请求对象
*/
void sendPostRequest(RequestAction action);

/**
* 取消所有请求，可能中断请求
*/
void cancelAllRequests(boolean mayInterruptIfRunning);

/**
* 重新设置请求超时时间
*/
void setTimeOut(int value);

/**
* 下载文件
*/
void downloadFile(String url);
}

一般也就这些方法，如果有更多方法也没关系。

这个接口先放在这里，暂且最后在实现具体的方法。

4，请求参数封装

上面我说到，请求的参数无非包含rul还有参数的map集合。

这里我们也做一下封装。

/**
* 外界将请求的地址，请求结果的解析参照对象以及请求参数都保存到这个类中
*/
public class RequestContent {

/**
* 发送请求的路径
*/
private String requestUrl;

/**
* 请求结果的解析参照对象（服务器返回的数据类型）
*/
private Class<?> cls;

/**
* 请求参数，new出一个map对象，将默认的先添加进去
*/
private Map<String, Object> parameters = SignUtils.getParameters();

/**
* 外界传入参数的构造方法，没有返回结果的请求
*/
public RequestContent(String requestUrl) {
this.requestUrl = requestUrl;
}

/**
* 外界传入参数的构造方法，带返回结果的请求，需要传入一个对象依照它来解析数据
*/
public RequestContent(String requestUrl, Class<?> cls) {
this.requestUrl = requestUrl;
this.cls = cls;
}
//还有变量的get/set方法，这里就不贴出来了
……
}

需要注意的是，请求参数的封装中貌似多了一个class参数。其实这个参数也算是请求参数的一个。

这个参数的作用是当服务器返回了成功后的结果，json数据解析能够更具这个类来解析。

后面的代码就可以看出它的作用。

5，返回结果封装

/**
* 返回结果抽象类，工厂方法模式
*/
public abstract class ResponseResult {
//请求对象
protected RequestAction requestAction;
//状态码
protected int statusCode;
}

抽象类需要三个方法继承。成功，失败和所有。类似于try/catch/finally方法。

/**
* 成功得到服务器结果后，所有的参数进入这个方法;
*/
public class ResponseSuccess extends ResponseResult {

//服务器返回的内容
private Object content;

public Object getContent() {
return content;
}

public void setContent(Object content) {
this.content = content;
}

}

/**
* 失败得到服务器结果后，所有的参数进入这个方法
*/
public class ResponseFailure extends ResponseResult {

private String message;//错误信息

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}
}

/**
* 不管服务器的结果是成功还是失败，所有的参数进入这个方法
*/

public class ResponseComplete extends ResponseResult {

/**
* 不管成功或者失败都会进入的方法
* 类似于try/catch方法中的finally方法
*/

//服务器返回的内容
private Object content;
private String message;//错误信息

public Object getContent() {
return content;
}

public void setContent(Object content) {
this.content = content;
}

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}
}

这样一来，

成功的请求进ResponseSuccess；这个类中就包含了：对象，状态码和内容；

失败的请求进ResponseFailure；这个类中就包含了：对象，状态码和错误信息；

不管失败和成功都要进ResponseComplete；这个类中就包含了：对象，状态码、内容和错误信息；当然，它的参数会因为状态不同而出现null。

至于抽象类中的RequestAction 则是接下来要讲的。

6，发出请求的枚举

/**
* 发出请求的枚举
*/
public enum RequestAction {

/**
* 枚举中实例化一个请求对象，并传入请求的url，如果该请求有返回值则还需要传入解析参照对象
*/
GET_INDEX_CONTENT(new RequestContent(RequestUrls.GET_INDEX_CONTENT_URL, String.class)),;
/**
* 构造器中传入请求对象
*/
public RequestContent requestContent;

RequestAction(RequestContent requestContent) {
this.requestContent = requestContent;
}
}

通过带有构造器的枚举在每一个枚举中都实例化一个请求内容（RequestContent ）对象。

这样，当我们调用每一个枚举的时候都会得到一个RequestContent的对象，于此同时也就得到了RequestContent对象中的请求参数map集合实例（getParameters()）。

有了请求参数实例我们就可以不断的往里面添加参数。这样做的目的是把填写url，给json数据一个解析参照对象（String.class）以及实例化一个参数集合的工作都交给枚举来完成。

这样，我们只需要调用枚举，传入url和数据解析参照对象的class就能够得到参数集合，就能够发出请求。

7，继承网络请求接口的具体实现

/**
* 具体的请求方法
*/
public class Requester implements IRequest {

//因为这里继承了接口所以不能通过枚举来实现单例了
private static volatile IRequest instance = null;

public synchronized static IRequest getInstance() {
if (instance == null) {
synchronized (IRequest.class) {
if (instance == null) {
instance = new Requester();
}
}
}
return instance;
}

private EventBus eventBus;
private Gson gson;

private Requester() {
//eventbus是一个三方工具库，可以代替观察者模式发送网络请求返回结果。如果不会用这个工具库，可以百度，或者自己换成可以处理返回结果的代码；例如接口，例如观察者模式
eventBus = EventBus.getDefault();
//gson是一个三方json数据解析工具库。
gson = new Gson();
}

//解析成功的参数
private ResponseResult createResponseSuccess(int statusCode, String response, RequestAction requestAction) {
ResponseSuccess responseSuccess = null;
try {
JSONObject jsonObject = new JSONObject(response);
responseSuccess = new ResponseSuccess();
responseSuccess.setStatusCode(statusCode);
responseSuccess.setRequestAction(requestAction);
if (requestAction.getClass() == null) return responseSuccess;
if (jsonObject.has(TAG_OBJECT)) {//如果json数据中包含object，说明是一个对象
Object object = gson.fromJson(jsonObject.getString(TAG_OBJECT), requestAction.getClass());//这里用到的是gson的解析数据方法
responseSuccess.setContent(object);
} else if (jsonObject.has(TAG_OBJECTS)) {//如果json数据中包含objects，说明是一个对象集合
JSONArray array = jsonObject.getJSONArray(TAG_OBJECTS);
List<Object> data = new ArrayList<>();
for (int i = 0; i < array.length(); i++) {
data.add(gson.fromJson(array.getString(i), requestAction.getClass()));
}
responseSuccess.setContent(data);
}
} catch (Exception e) {
e.printStackTrace();
}

return responseSuccess;
}

//解析失败的参数
private ResponseResult createResponseFailure(int statusCode, String message, RequestAction requestAction) {
ResponseFailure responseFailure = new ResponseFailure();
responseFailure.setStatusCode(statusCode);
responseFailure.setMessage(message);
responseFailure.setRequestAction(requestAction);
return responseFailure;
}

//不管成功还是失败都进该方法进行解析
private ResponseResult createResponseComplete(int statusCode, String responseString, RequestAction requestAction) {
ResponseComplete responseComplete = new ResponseComplete();
responseComplete.setStatusCode(statusCode);
responseComplete.setMessage(responseString);
responseComplete.setRequestAction(requestAction);
return responseComplete;
}

/**
* post请求
*/
@Override
public void sendPostRequest(final RequestAction action) {
if (!NetWorkUtil.isNetworkConnected(UIAppliaction.getInstance())) return;
if (action.requestContent.getParameters() == null) {
HttpClient.get(action.requestContent.getRequestUrl(), httpBackState(action));
} else {
HttpClient.post(action.requestContent.getRequestUrl(), action.requestContent.getParameters(), httpBackState(action));
}
}

//服务器返回结果处理
private void httpBackState(final RequestAction action) {
//该方法是网络请求框架中的回调方法，这里只是模拟代码
new HttpBack() {
@Override
public void onSuccess(int statusCode, byte[] responseBody) {
try {
String jsonSuccess = new String(responseBody, "UTF-8");
ResponseResult success = createResponseSuccess(statusCode, jsonSuccess, action);
ResponseResult complete = createResponseComplete(statusCode, null, action);
//给发送了网络请求的类返回请求结果
eventBus.post(success);
eventBus.post(complete);
} catch (Exception e) {
e.printStackTrace();
}
}

@Override
public void onFailure(int statusCode, byte[] responseBody, String error) {
try {
ResponseResult failure = createResponseFailure(statusCode, error, action);
ResponseResult complete = createResponseComplete(statusCode, error, action);
//给发送了网络请求的类返回请求结果
eventBus.post(failure);
eventBus.post(complete);
} catch (Exception e) {
e.printStackTrace();
}
}
};
}

/**
* get请求
*/
@Override
public void sendGetRequest(final RequestAction action) {
sendPostRequest(action);
}

/**
* 取消所有请求
*
* @param mayInterruptIfRunning
*/
@Override
public void cancelAllRequests(boolean mayInterruptIfRunning) {
HttpClient.cancelAllRequests(mayInterruptIfRunning);
}

/**
* 设置超时时间
*
* @param value 毫秒
*/
@Override
public void setTimeOut(int value) {
HttpClient.setOutTime(value);
}

/**
* 下载文件
*
* @param url
*/
@Override
public void downloadFile(String url) {
//模拟下载文件
HttpClient.downloadFile(url, new HttpFileBack() {
@Override
public void onStart(int statusCode, byte[] responseBody) {

}

@Override
public void onOngoing(int statusCode, byte[] responseBody, double schedule) {

}

@Override
public void onError(int statusCode, byte[] responseBody, String message) {

}

});
}
}

其中HttpClient是模拟代码。它指你使用的一切网络请求框架。

因为框架的设计无法用具体代码表达出来，所以这里我选择使用模拟逻辑处理过程。

到这里，整个框架的设计就完成了。那么我们应该怎么去使用呢？

使用网络请求：

//使用方法
public void test() {
//实例化请求方法
IRequest request = Requester.getInstance();
//post请求

//通过枚举获得请求参数的map实例
Map<String, Object> params = RequestAction.GET_INDEX_CONTENT.requestContent.getParameters();
//添加参数
params.put("userinfo.name", "admin");
params.put("userinfo.pwd", "admins1");
//发送网络请求
request.sendPostRequest(RequestAction.GET_INDEX_CONTENT);

//get请求
request.sendGetRequest(RequestAction.GET_INDEX_CONTENT);
}

不管你在哪里提交网络请求，都只需要这么几行代码就搞定。

那么我们再来看如何添加新的rul：

首先在RequestUrls类中添加一个url：

public static final String GET_USER_CONTENT_URL = ROOT_URL + "index/selectIndexContent.action";

然后在RequestAction枚举中添加一个新枚举：

GET_USER_CONTENT(new RequestContent(RequestUrls.GET_USER_CONTENT_URL, UserInfoBean.class)),

这样，添加一个新的请求就完成了。

不管是提交请求，还是添加新请求都是几行代码就解决的问题。

那么我们如何去接收返回结果呢？

不管你是用的是eventbus.jar还是接口还是观察者模式得到返回结果后都可以这样处理：

//成功
public void onRequestSuccess(ResponseSuccess success) {
switch (success.getRequestAction()) {
case GET_INDEX_CONTENT:
success.getContent();//内容
success.getStatusCode();//返回码
success.getRequestAction();//请求枚举
success.getClass();//参照的解析类型
break;
}
}

//失败
public void onRequestFailure(ResponseFailure failure) {
switch (failure.getRequestAction()) {
case GET_INDEX_CONTENT:
failure.getMessage();//错误信息
failure.getStatusCode();//返回码
failure.getRequestAction();//请求枚举
failure.getClass();//参照的解析类型
break;
}
}

//所有
public void onRequestCompleted(ResponseComplete complete) {
switch (complete.getRequestAction()) {
case GET_INDEX_CONTENT:
//注意：解析的内容可能为null，因为成功或者失败都会进来
complete.getContent();//内容，可能为null
complete.getMessage();//错误信息，可能为null
complete.getStatusCode();//返回码
complete.getRequestAction();//请求枚举
complete.getClass();//参照的解析类型
break;
}
}

拿到结果后就可以自己处理一些逻辑了。

整个二次封装的流程就是这样。

这个二次封装的框架目的在于简化请求接收代码，并且留下接口（onSuccess,onFailure）以供第三方框架使用。

现在再返回来看这张图：



我们二次封装网络请求的目的就是做红色的框所做的工作。并且把整个网络请求流程分开来，解耦。

就像几个楔形：服务器<第三方框架<二次封装框架<数据请求；

这样才能构成一个完整的app网络请求流程。而且这样分为几个楔形，成功的达到了解耦的作用。

这样，不管你换哪个第三方请求框架，只要把第三方请求框架的onSuccess（）和onFailure（）方法给接上去就可以照常使用。

这也是二次封装网络请求而设计框架的最重要的目的。

这里写成博客以供大家前来学习。