背景

android开发过程中网络请求作为最重要的组成部分之一,然而对于大部分android开发者在网络请求上有太多疑惑,不知道如何去选型?通过原生的HttpClient、HttpUrlConnection封装?还是通过第三方框架再封装?笔者以为采用广泛被使用的第三方网络框架再封装为上策,因为这些网络框架如retrofit、okhttp、volley等是被全球android开发者维护着,无论在功能上、性能上、还是代码简洁性都相对于自己通过原生实现的给力.

目的

致力封装一个简洁、实用、易移植的网络框架模块.

正题

今天笔者就给大家基于retrofit + okhttp + gson 封装一个通用易懂的网络框架模块.

首先我们需要在gradle文件中将第三方依赖引入项目,代码如下：

dependencies {

// retrofit + okhttp + gson

compile 'com.squareup.retrofit2:retrofit:2.1.0'

compile 'com.squareup.okhttp3:okhttp:3.4.1'

compile 'com.google.code.gson:gson:2.7'

compile 'com.squareup.retrofit2:converter-gson:2.1.0'

}

接着开始我们的封装之路......

首先我们需要写一个参数常量类,用于定义一些常量,如请求Url地址、接口返回信息,代码如下：

/**

* @className: InterfaceParameters

* @classDescription: 参数配置

* @author: leibing

* @createTime: 2016/8/30

*/

public class InterfaceParameters {

// 请求URL

public final static String REQUEST_HTTP_URL = BuildConfig.API_URL;

// 接口返回结果名称

public final static String INFO = "info";

// 接口返回错误码

public final static String ERROR_CODE = "errorcode";

// 接口返回错误信息

public final static String ERROR_MSG = "errormsg";

}

然后写一个网络请求封装类JkApiRequest.class,采用单例的方式,配置网络请求参数以及返回网络请求api实例,代码如下：

/**

* @className:JkApiRequest

* @classDescription:网络请求

* @author: leibing

* @createTime: 2016/8/30

*/

public class JkApiRequest {

// sington

private static JkApiRequest instance;

// Retrofit object

private Retrofit retrofit;

/**

* Constructor

* @author leibing

* @createTime 2016/08/30

* @lastModify 2016/08/30

* @param

* @return

*/

private JkApiRequest(){

OkHttpClient client = new OkHttpClient.Builder()

.addInterceptor(new OkHttpInterceptor())

.build();

retrofit = new Retrofit.Builder()

.baseUrl(InterfaceParameters.REQUEST_HTTP_URL)

.addConverterFactory(JkApiConvertFactory.create())

.client(client)

.build();

}

/**

* sington

* @author leibing

* @createTime 2016/08/30

* @lastModify 2016/08/30

* @param

* @return

*/

public static JkApiRequest getInstance(){

if (instance == null){

instance = new JkApiRequest();

}

return instance;

}

/**

* create api instance

* @author leibing

* @createTime 2016/08/30

* @lastModify 2016/08/30

* @param service api class

* @return

*/

public T create(Class service) {

return retrofit.create(service);

}

}

上面代码有两个网络请求参数需要注意, OkHttpInterceptor 、JkApiConvertFactory.

OkHttpInterceptor 作为网络请求拦截器,可以拦截请求的数据以及响应的数据,有助于我们排查问题,而JkApiConvertFactory 是作为Convert工厂,这里我所做的就是解析返回来的数据,将数据进行Gson处理就是在这里面.

OkHttpInterceptor代码如下：

/**

* @className: OkHttpInterceptor

* @classDescription: Http拦截器

* @author: leibing

* @createTime: 2016/08/30

*/

public class OkHttpInterceptor implements Interceptor {

private static final Charset UTF8 = Charset.forName("UTF-8");

@Override

public Response intercept(Chain chain) throws IOException {

Request request = chain.request();

// 获得Connection，内部有route、socket、handshake、protocol方法

Connection connection = chain.connection();

// 如果Connection为null，返回HTTP_1_1，否则返回connection.protocol()

Protocol protocol = connection != null ? connection.protocol() : Protocol.HTTP_1_1;

// 比如: --> POST http://121.40.227.8:8088/api http/1.1

String requestStartMessage = "--> " + request.method() + ' ' + request.url() + ' ' + protocol;

System.out.println("ddddddddddddddddddd requestStartMessage = " + requestStartMessage);

// 打印 Response

Response response;

try {

response = chain.proceed(request);

} catch (Exception e) {

throw e;

}

ResponseBody responseBody = response.body();

long contentLength = responseBody.contentLength();

if (bodyEncoded(response.headers())) {

} else {

BufferedSource source = responseBody.source();

source.request(Long.MAX_VALUE); // Buffer the entire body.

Buffer buffer = source.buffer();

Charset charset = UTF8;

if (contentLength != 0) {

// 获取Response的body的字符串 并打印

System.out.println("ddddddddddddddddddddddddd response = " + buffer.clone().readString(charset));

}

}

return response;

}

private boolean bodyEncoded(Headers headers) {

String contentEncoding = headers.get("Content-Encoding");

return contentEncoding != null && !contentEncoding.equalsIgnoreCase("identity");

}

}

JkApiConvertFactory代码如下：

/**

* @className: JkApiConvertFactory

* @classDescription: this converter decode the response.

* @author: leibing

* @createTime: 2016/8/30

*/

public class JkApiConvertFactory extends Converter.Factory{

public static JkApiConvertFactory create() {

return create(new Gson());

}

public static JkApiConvertFactory create(Gson gson) {

return new JkApiConvertFactory(gson);

}

private JkApiConvertFactory(Gson gson) {

if (gson == null) throw new NullPointerException("gson == null");

}

@Override

public Converter responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {

return new GsonResponseBodyConverter<>(type);

}

final class GsonResponseBodyConverter implements Converter {

private final Type type;

GsonResponseBodyConverter(Type type) {

this.type = type;

}

@Override public T convert(ResponseBody value) throws IOException {

BaseResponse baseResponse;

String reString;

try {

reString = value.string();

// 解析Json数据返回TransData对象

TransData transData = TransUtil.getResponse(reString);

try {

if (transData.getErrorcode().equals("0") && !TextUtils.isEmpty(transData.getInfo())) {

baseResponse = new Gson().fromJson(transData.getInfo(), type);

baseResponse.setSuccess(transData.getErrorcode().equals("0"));

baseResponse.setInfo(transData.getInfo());

baseResponse.setInfo(transData.getInfo());

} else {

baseResponse = (BaseResponse) StringUtil.getObject(((Class) type).getName());

baseResponse.setSuccess(transData.getErrorcode().equals("0"));

baseResponse.setInfo(transData.getInfo());

baseResponse.setInfo(transData.getInfo());

}

return (T)baseResponse;

} catch (Exception e) {

e.printStackTrace();

}

} catch (Exception e) {

e.printStackTrace();

}

//从不返回一个空的Response.

baseResponse = (BaseResponse) StringUtil.getObject(((Class) type).getName());

try {

baseResponse.setSuccess(false);

//JkApiConvertFactory can not recognize the response!

baseResponse.setErrormsg("");

} catch (Exception e) {

e.printStackTrace();

} finally {

return (T)baseResponse;

}

}

}

}

接着我们写api接口,我这里是将对应的接口封装到对应的类中,这样当前api类中接口名称可以统一起来,请求api的方法也写入当前api类,这样做既能解耦又能减少在使用处的冗余代码,代码如下:

/**

* @className: ApiLogin

* @classDescription: 登陆api

* @author: leibing

* @createTime: 2016/8/12

*/

public class ApiLogin {

// api

private ApiStore mApiStore;

/**

* Constructor

* @author leibing

* @createTime 2016/08/30

* @lastModify 2016/08/30

* @param

* @return

*/

public ApiLogin() {

// 初始化api

mApiStore = JkApiRequest.getInstance().create(ApiStore.class);

}

/**

* 登录

* @author leibing

* @createTime 2016/08/30

* @lastModify 2016/08/30

* @param username 用户名

* @param password 密码

* @param callback 回调

* @return

*/

public void Login(String username, String password, ApiCallback callback){

Call mCall = mApiStore.login(URLEncoder.encode(username), password);

mCall.enqueue(new JkApiCallback(callback));

}

/**

* @interfaceName: ApiStore

* @interfaceDescription: 登录模块api接口

* @author: leibing

* @createTime: 2016/08/30

*/

private interface ApiStore {

@GET("app/User/Login")

Call login(

@Query("username") String username,

@Query("userpass") String userpass);

}

}

从上面代码我们看到ApiCallback和JkApiCallback两个回调接口,这两者区别在哪呢?观察仔细的童鞋会发现这个问题.ApiCallback接口是作为通用接口,而JkApiCallback是作为一个接口封装类,针对不同数据情景,做不同回调.

ApiCallback代码如下：

/**

* @className: ApiCallback

* @classDescription: Api回调

* @author: leibing

* @createTime: 2016/08/30

*/

public interface ApiCallback {

// 请求数据成功

void onSuccess(T response);

// 请求数据错误

void onError(String err_msg);

// 网络请求失败

void onFailure();

}

JkApiCallback代码如下：

public class JkApiCallback implements Callback {

// 回调

private ApiCallback mCallback;

/**

* Constructor

* @author leibing

* @createTime 2016/08/30

* @lastModify 2016/08/30

* @param mCallback 回调

* @return

*/

public JkApiCallback(ApiCallback mCallback){

this.mCallback = mCallback;

}

@Override

public void onResponse(Call call, Response response) {

if (mCallback == null){

throw new NullPointerException("mCallback == null");

}

if (response != null && response.body() != null){

if (((BaseResponse)response.body()).isSuccess()){

mCallback.onSuccess((T)response.body());

}else {

mCallback.onError(((BaseResponse) response.body()).getErrormsg());

}

}else {

mCallback.onFailure();

}

}

@Override

public void onFailure(Call call, Throwable t) {

if (mCallback == null){

throw new NullPointerException("mCallback == null");

}

mCallback.onFailure();

}

}

接下来我们写Response类,用于接收Gson解析回来的数据,这个只需写json数据信息里面的字段.代码如下：

/**

* @className: LoginResponse

* @classDescription: 获取登录返回的信息

* @author: leibing

* @createTime: 2016/08/30

*/

public class LoginResponse extends BaseResponse implements Serializable{

// 序列化UID 用于反序列化

private static final long serialVersionUID = 4863726647304575308L;

// token

public String accesstoken;

}

阅读仔细的童鞋会发现,在Convert工厂中Gson解析时,用到了一个BaseResponse,这个响应类是作为基类,就是服务端返回的固定json数据格式,因为每个项目返回的固定格式可能不一样,所以只需改这里,就能定制对应项目的网络框架.

BaseResponse代码如下：

/**

* @className: BaseResponse

* @classDescription: 网络请求返回对象公共抽象类

* @author: leibing

* @createTime: 2016/08/30

*/

public class BaseResponse implements Serializable {

// 序列化UID 用于反序列化

private static final long serialVersionUID = 234513596098152098L;

// 是否成功

private boolean isSuccess;

// 数据

public String info;

// 错误消息

public String errormsg;

public boolean isSuccess() {

return isSuccess;

}

public void setSuccess(boolean success) {

isSuccess = success;

}

public String getInfo() {

return info;

}

public void setInfo(String info) {

this.info = info;

}

public String getErrormsg() {

return errormsg;

}

public void setErrormsg(String errormsg) {

this.errormsg = errormsg;

}

}

一个简洁、实用、易移植的网络框架模块封装完毕.

如有疑问请联系,联系方式如下：