Retrofit+okHttp3一步一步封装MVP

Retrofit+okHttp3一步一步封装MVP

Retrofit+okhttp3 是目前最流行的网络请求框架，本文主要说明MVP一步步封装，对于Retrofit不会过多讲解。MVP算是目前比较火的一想移动端的代码架构，采用Presenter隔离View层和Model层，解耦View层由于涉及过多逻辑而造成的代码臃肿，导致调试以及后期更改麻烦，下面开始一步一步搭建Retrofit+okHttp3封装MVP:

创建View基类接口，声明将来在View层的回调接口

public interface IMvpViewImpl<T extends CommonVo>  {

void requesting(); // 数据请求开始
void success(T data); // 请求成功
void fail(ErrorInfo errorInfo); // 请求失败

}

创建一个Presenter的抽象基类

/**
* Author   : luweicheng on 2018/1/19 0019 15:00
* E-mail   ：1769005961@qq.com
* GitHub   : https://github.com/luweicheng24 * funcation: presenter抽象基类
**/
public abstract class AbstactMvpPresenter<V extends IMvpViewImpl> {
protected HashMap<String,String> paramMap; // 参数map
private V mvpView;
// 关联View
public void attachView(V mvpView){
this.mvpView = mvpView;
paramMap = new HashMap<>();
}
// 与View接触绑定
public void detachView(){
this.mvpView = null;
}
// 获取View
public V getMvpView() {
return mvpView;
}
}

该类中的ParamMap是方便以后发送网络请求时的参数封装到map中，其中在Activity或者Fragment的创建时将Presenter与其关联，在界面销毁时设置传递到Presenter中的View为null，这样不会再Activity或者Fragment销毁时Presenter层仍然持有View的引用而导致内存泄漏。

创建抽象Activity实现View的接口，抽象一个创建Presenter的方法，方便子类实现各自的presenter，在onResume和onStop关联Presenter和去除关联。

/**
* Author   : luweicheng on 2018/1/19 0019 15:26
* E-mail   ：1769005961@qq.com
* GitHub   : https://github.com/luweicheng24 * funcation: Activity的抽象基类
**/
public abstract class AbstractMvpActivity<P extends AbstactMvpPresenter> extends AppCompatActivity implements IMvpViewImpl {
protected  P presenter;
@Override
protected void onResume() {
super.onResume();
presenter = createPresenter();
if(presenter==null){
throw new RuntimeException("present is null");
}
presenter.attachView(this)
}

@Override
protected void onStop() {
super.onStop();
if(presenter!=null){
presenter.detachView();
}
}

// 子类创建具体的Presenter
protected abstract P createPresenter();
}

MVP 的基本基类就编写完成，下面看一下如何封装一个适合项目的网络请求

先编写一个简单的网络接口，改接口是临时本地编写的一个ssm的后台项目，Controller代码如下：

/**
* Author   : luweicheng on 2018/1/22 0022 10:05
* E-mail   ：1769005961@qq.com
* GitHub   : https://github.com/luweicheng24 * funcation:
*/
@Controller
public class LoginController {

@RequestMapping("/login")
@ResponseBody()
public Map<String,Object> login(@RequestParam(value = "name",required=false) String name, @RequestParam(value = "password",required=false) String password) {
Map requestMap = new HashMap();
if (name != null && password != null ) {
requestMap.put("res_code",1);
requestMap.put("res_msg","登陆成功");
LoginParm parm = new LoginParm();
parm.setSex("男");
parm.setName(name);
parm.setAge("23");
requestMap.put("user",parm);
} else {
requestMap.put("res_code",1);
requestMap.put("res_msg","登陆成功");
}
return requestMap;
}

}

以上代码只是为了测试方便随意编写的一个Controller，数据返回格式为json。

移动端的接口代码，编写个基于post和get的两种http请求方式：

/**
* Author   : luweicheng on 2018/1/19 0019 16:20
* E-mail   ：1769005961@qq.com
* GitHub   : https://github.com/luweicheng24 * funcation: Retrofit接口类
**/
public interface ApiService {
//    retrofit 的get请求
@GET("/login")
Call<LoginVo> loginGet(@QueryMap HashMap<String,String> paramMap);
// retrofit的post请求
@FormUrlEncoded
@POST("/login")
Call<LoginVo> loginPost(@FieldMap HashMap<String,String> paramMap);
}

下面是编写ApiClient作为发起网络请求的客户端：

/**
* Author   : luweicheng on 2018/1/22 0022 09:41
* E-mail   ：1769005961@qq.com
* GitHub   : https://github.com/luweicheng24 * funcation: Api客户端
**/
public class ApiClient {
private ApiClient(){}
public static ApiClient client;
private static  ApiService apiService;
static {
Retrofit retrofit = new Retrofit
.Builder()
.baseUrl("http://192.168.1.35:8081/")
.client(new OkHttpClient())
.addConverterFactory( GsonConverterFactory.create())
.build();
apiService = retrofit.create(ApiService.class);
}
public static ApiService getApiService(){
if(client==null){
synchronized (ApiClient.class){
if(client==null){
client = new ApiClient();
}
}
}
return apiService;
}
}

这里先来看一下服务端返回的数据格式：

{"res_msg":"登陆成功",
"user":{"name":"123","age":"23","sex":"男"},
"res_code":1
}

以上数据格式也是现在基本所有服务器返回数据的基本格式，所以针对这种数据格式先来创建一个CommonParm：

public class CommonVo{
private int res_code;
private String res_msg;

public int getRes_code() {
return res_code;
}

public void setRes_code(int res_code) {
this.res_code = res_code;
}

public String getRes_msg() {
return res_msg;
}

public void setRes_msg(String res_msg) {
this.res_msg = res_msg;
}
}

再来编写一个具体的vo类，继承自CommonParam

public class LoginVo extends CommonVo{

/**
* user : {"name":"123","age":"23","sex":"男"}
*/

private UserBean user;

public UserBean getUser() {
return user;
}

public void setUser(UserBean user) {
this.user = user;
}

public static class UserBean {
/**
* name : 123
* age : 23
* sex : 男
*/

private String name;
private String age;
private String sex;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getAge() {
return age;
}

public void setAge(String age) {
this.age = age;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}

@Override
public String toString() {
return "UserBean{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", sex='" + sex + '\'' +
'}';
}
}

@Override
public String toString() {
return "LoginVo{" +
"user=" + user +
'}';
}
}

由于服务器返回的数据根据res_code会有不同的操作，所以本地封装一个ErrorInfo类来封装code和msg:

public class ErrorInfo {
private int errCode;
private String errMsg;
public ErrorInfo(int errCode, String errMsg) {
this.errCode = errCode;
this.errMsg = errMsg;
}
public int getErrCode() {
return errCode;
}

public void setErrCode(int errCode) {
this.errCode = errCode;
}

public String getErrMsg() {
return errMsg;
}

public void setErrMsg(String errMsg) {
this.errMsg = errMsg;
}

@Override
public String toString() {
return "ErrorInfo{" +
"errCode=" + errCode +
", errMsg='" + errMsg + '\'' +
'}';
}
}

在完成上面的编写后，就到了编写一个具体mvp流程了，如何进行一次封装的网络请求：

public class LoginModel {
//   登录
public void login(HashMap<String,String> paraMap, HttpCallBack customCallBack){
Call<LoginVo> call = ApiClient.getApiService().loginGet(paraMap);
call.enqueue(customCallBack);
}
}

HttpCallBack 是一个自定义的回调处理，实现了Retrofit的CallBack接口，在内部根据服务器返回的信息进行处理：

public class HttpCallBack<T extends CommonVo> implements Callback {
public static final int NET_ERROR = 10086;

public HttpCallBack(ResponseResultListener resultListener) {
this.resultListener = resultListener;
}
@Override
public void onResponse(Call call, Response response) {
T vo = (T) response.body();
//            根据code过滤数据
if (resultListener != null&&vo.getRes_code()==1) {
resultListener.success(vo);
} else {
resultListener.error(new ErrorInfo(vo.getRes_code(), vo.getRes_msg()));
}

}
@Override
public void onFailure(Call call, Throwable t) {
resultListener.error(new ErrorInfo(NET_ERROR, "网络异常"));
Log.e("net-error", "onFailure: " + t.getMessage());
}

private ResponseResultListener resultListener;

public void setResultListener(ResponseResultListener resultListener) {
this.resultListener = resultListener;
}
}

在Callback的两个回调接口中需要将该处的数据传递出去，所以利用一个接口回调将数据传递出去：

public interface ResponseResultListener<T extends CommonVo> {
//      正确返回数据（res_code！=1）
void success(T t);
//      返回数据有错
void error(ErrorInfo errorInfo);
}

接下来编写LoginActiivty：

public class LoginActivity extends AbstractMvpActivity<LoginPresenter> {
private EditText et_name, et_password;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
et_name = (EditText) findViewById(R.id.et_name);
et_password = (EditText) findViewById(R.id.et_passsword);
}

@Override
protected LoginPresenter createPresenter() {
return new LoginPresenter();
}

public void login(View view) {
if (TextUtils.isEmpty(et_name.getText()) && TextUtils.isEmpty(et_password.getText())) {
presenter.requestLogin(et_name.getText().toString(), et_password.getText().toString());
} else {
Toast.makeText(this, "用户名或者密码为空", Toast.LENGTH_SHORT).show();
}

}

@Override
public void requesting() {
System.out.println("数据请求中");
}

@Override
public void success(CommonVo data) {
((LoginVo) data).toString();
Toast.makeText(this, "登录成功"+((LoginVo) data).toString(), Toast.LENGTH_SHORT).show();

System.out.println("loginactivity" + ((LoginVo) data).toString());
}

@Override
public void fail(ErrorInfo errorInfo) {
Toast.makeText(this, "登录失败"+errorInfo.toString(), Toast.LENGTH_SHORT).show();
System.out.println("loginactivity" + errorInfo.toString());

}

}

该类只是继承AbstractMvpActivity规定Presenter的泛型，实现如下方法：

@Override
protected LoginPresenter createPresenter() {
return new LoginPresenter();
}

接下里就是具体的Presenter类的编写了：

public class LoginPresenter extends AbstactMvpPresenter<IMvpViewImpl> {
private IMvpViewImpl view;
private LoginModel loginModel;
public LoginPresenter(){
loginModel = new LoginModel();
}
//       请求登录
public void requestLogin(String name,String password){
view =  getMvpView();
if(view != null){
view.requesting();
}
paramMap.put("name",name);
paramMap.put("password",password);
loginModel.login(paramMap,new HttpCallBack(new ResponseResultListener<LoginVo>() {
@Override
public void success(LoginVo loginVo) {
view.success(loginVo);
}
@Override
public void error(ErrorInfo errorInfo) {
view.fail(errorInfo);
System.out.println(errorInfo.toString());
}
}));

}

}

Loginpresenter在创建的时候便会创建一个LoginModel，当View层调用Presenter时，Presenter调用Model层的数据请求，数据请求完成后将数据回调给View层。

Model层只做数据的存取操作：

public class LoginModel {
//   登录
public void login(HashMap<String,String> paraMap, HttpCallBack customCallBack){
Call<LoginVo> call = ApiClient.getApiService().loginGet(paraMap);
call.enqueue(customCallBack);
}
}

这样一个采用Retrofit+okhttp3搭建完整的MVP架构就算完成了，其中还有还需很大的优化，github源码下载，欢迎issue，star。