Android简单实用的MVP框架

作者: 因为我的心 | 来源:发表于2020-04-20 19:01 被阅读0次

一、前言

MVP模式是Android目前一个非常流行的框架，相信很多人在项目中或多或少的使用过它，相比经典的MVC，MVP更加适用于Android应用的开发，在这里我们就不再对它们之前的差别进行详细分析了，相信大部分人都已经非常的了解了，现在让我们单刀直入的写一个实用的MVP框架吧。由于本人能力水平有限，并且也是我第一次写博客，有不正确的地方还望大家多指正或者有更好的想法我们多交流，毕竟增强自身本领才是硬道理嘛。

二、一张图

image

依赖jar包：

  //okhttp3
    implementation 'com.squareup.okhttp3:okhttp:3.10.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:3.10.0'

    //retrofit2
    implementation 'com.squareup.retrofit2:retrofit:2.4.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.4.0'
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.4.0'

    //fastjson使用
    implementation 'com.alibaba:fastjson:1.2.55'

    //rxjava2
    implementation 'io.reactivex.rxjava2:rxjava:2.1.12'
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

三、类介绍

Model：框架中的模型超类，负责提供数据；

View：框架中的视图超类，负责UI展示；

Presenter：程序中的逻辑超类，负责处理具体事务；

BaseMvp：用于创建Model、View和Presenter；

BasePresenter：所有Presenter层的抽象类，负责Model、View层的引用和销毁；

BaseMvpActivity：Activity基类，具体的实现Model、View的绑定，我们自己的Activity可直接继承于此类或者自行实现BaseActivity继承于此类；

BaseMvpFragment：Fragment基类，具体作用和BaseMvpActivity相同。

面向对象的原则告诉我们要针对接口编程，不要针对实现编程，所谓的针对接口编程不一定都是写一个类，并用implement来实现这个接口，而是泛指实现某个超类型的某个方法，这个超类型可以是类也可以是接口。秉承着这样的原则，我们设计出Mode、View、Presenter接口来充当所有类的父类（超类型），而具体的实现则有子类或者抽象子类来实现，这也是为什么我们所写的都是接口和抽象类，因为我们具体的实现都在我们自己的Activity或Fragment中，就像上图中展示的一样，红框内的代码和下面的是完全解耦的，方便我们移植到不同的项目中。

四、代码解读

Model层

public interface Model {
}

Model接口，用于数据模型的获取，所有子Mode类都要实现这个接口

View层

public interface View {
    void showToast(String info);

    void showProgress();
}

View接口，所有视图类的父类，在接口中可以做一些基本的展示过程，比如Toast、Progress的显示，或者检查网络状态后的提醒，具体的实现由子类决定，子类也可以仍然是一个接口，继续拓展View的功能

Presenter层

public interface Presenter<M extends Model, V extends View> {
    /**
     * 注册Model层
     *
     * @param model
     */
    void registerModel(M model);

    /**
     * 注册View层
     *
     * @param view
     */
    void registerView(V view);

    /**
     * 获取View
     *
     * @return
     */
    V getView();

    /**
     * 销毁动作（如Activity、Fragment的卸载）
     */
    void destroy();
}

这里的Presenter接口可能和想象的不太一样，可以看到这里面没有具体的业务逻辑方法，而是一些注册Mode和View层的抽象方法，在这里我们也可以获取传过来的View和Model，实际上这个接口更像是一个具有setter和getter的类。

到这里，我们MVP框架的Model、View和Presenter层都出现了，但我们不可能在项目中直接implement来使用它们，因为那样会产生太多重复性的代码，并且不够简洁，我们还需要一些抽象类来实现一些公共的方法，最起码让Activity和Fragment能拿过来直接使用才能达到我们预期的目标。

BasePresenter

public abstract class BasePresenter<M extends Model, V extends View> implements Presenter<M, V> {
    /**
     * 使用弱引用来防止内存泄漏
     */
    private WeakReference<V> wrf;
    protected M model;

    @Override
    public void registerModel(M model) {
        this.model = model;
    }

    @Override
    public void registerView(V view) {
        wrf = new WeakReference<V>(view);
    }

    @Override
    public V getView() {
        return wrf == null ? null : wrf.get();
    }

    /**
     * 在Activity或Fragment卸载时调用View结束的方法
     */
    @Override
    public void destroy() {
        if (wrf != null) {
            wrf.clear();
            wrf = null;
        }
        onViewDestroy();
    }

    protected abstract void onViewDestroy();
}

BasePresenter是我们要直接继承使用的Presenter层父类，它实现了Presenter接口中的抽象方法，并且为了防止内存泄漏，我们View层的引用要使用弱引用。在MVP模式中，内存泄漏的主要原因是由于当前View层（如Activity或者Fragment）在卸载时，Model层中仍有业务没有结束（如子线程未完成、网络请求超时等），而这里的Presenter层中拥有Mode层和View层的引用，所以Presenter层也暂时无法释放，最终导致View的引用也没有释放，我们的Activity或者Fragment就算时销毁了，GC也无法回收它们，因为还有引用在指向它们呢。
我们也不必非要使用弱引用来维护View层，其实在View层卸载时，只要主动让指向View的引用为空，也可以让Activity或者Fragment顺利回收，而且在View卸载时我们也可以选择是否停止当前Model层的业务，在BasePresenter类中，我们也同样实现了这个逻辑，就是destroy()方法，它通过调用onViewDestroy()来让具体实现这个方法的类来完成相应的业务逻辑。
在这里，我们仍然没有看到于项目有关的业务逻辑，这就对了，因为我们写的是一个MVP模式的框架，不是自己去写一个MVP模式的具体项目。

BaseMvp

public interface BaseMvp<M extends Model, V extends View, P extends BasePresenter> {
    M createModel();

    V createView();

    P createPresenter();
}

BaseMvp是用来创建Model、View和Presenter层的，我们的MVP框架只去调用它们，具体的实现由真正的View层来做

BaseMvpActivity

public abstract class BaseMvpActivity<M extends Model, V extends View, P extends BasePresenter> extends AppCompatActivity implements BaseMvp<M, V, P> {
    protected P presenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //创建Presenter
        presenter = createPresenter();
        if (presenter != null) {
            //将Model层注册到Presenter中
            presenter.registerModel(createModel());
            //将View层注册到Presenter中
            presenter.registerView(createView());
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (presenter != null) {
            //Activity销毁时的调用，让具体实现BasePresenter中onViewDestroy()方法做出决定
            presenter.destroy();
        }
    }
}

这是Activity基类（只是对我们MVP框架来说，我们完全可以在项目中再写一个BaseActivity来继承它，实现基类真正的功能），我们以后所写的Activity都要继承它，并实现它的抽象方法和BaseMvp中的接口。它的主要功能就是创建Model、View、Presenter层并注册。这里我们也看到了上面提到的BasePresenter中destroy()方法具体调用的地方，就是在Activity中的onDestroy()中。

BaseMvpFragment

public abstract class BaseMvpFragment<M extends Model, V extends View, P extends BasePresenter> extends Fragment implements BaseMvp<M, V, P> {
    protected P presenter;

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);

        presenter = createPresenter();
        if (presenter != null) {
            presenter.registerModel(createModel());
            presenter.registerView(createView());
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        if (presenter != null) {
            presenter.destroy();
        }
    }
}

这是Fragment基类，基本上和BaseMvpActivity类如出一辙，在这里就不再赘述了。

五、使用

好了，我们的MVP框架先到此为止，现在回过头来再看看刚开始的UML类图。红框中的类和接口我们都已经完成了，他们之间的关系也理清了，接口中定义了我们要做的事情，抽象类中为我们确定了Mode、View和Presenter彼此之间的联系，他们之间的该发生的不该发生的事情我们都已经搞定了，但这仅仅才刚开始，我们最终的目的是要使用他们。
我们先使用Activity，在UML类图中我们可以看到MainActivity的继承关系，其实它可以直接继承于BaseMvpActivity，我们这里是自己实现的BaseActivity然后再继承之，

项目中的Model和它的实现类

public interface MainModel extends Model {
    /**
     * 从网络获取数据
     *
     * @return
     */
    String getDataFromNet();

    /**
     * 停止请求
     */
    void stopRequest();
}

public class MainModelImpl implements MainModel {
    @Override
    public String getDataFromNet() {
        return "MVP 模式,into fragment";
    }

    @Override
    public void stopRequest() {
        Log.i("MainModelImpl", "stop request...");
    }
}

View和它的实现类

public interface MainView extends View {
    /**
     * 设置数据
     *
     * @param str
     */
    void setData(String str);
}
public class MainActivity extends BaseActivity<MainModel, MainView, MainPresenter> implements MainView {
    private TextView tvFirst;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        tvFirst = findViewById(R.id.tv_first);
        tvFirst.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(MainActivity.this, SecondActivity.class));
            }
        });
        init();
    }


    @Override
    public MainModel createModel() {
        return new MainModelImpl();
    }

    @Override
    public MainView createView() {
        return this;
    }

    @Override
    public MainPresenter createPresenter() {
        return new MainPresenter();
    }

    private void init() {
        if (presenter != null) {
            presenter.getData();
        }
    }

    @Override
    public void setData(String str) {
        tvFirst.setText(str);
    }
}

createModel()、createView()和createPresenter()实现了BaseMvpActivity中的抽象方法，真正返回了具体的M、V、P层

Presenter层

public class MainPresenter extends BasePresenter<MainModel, MainView> {
    public void getData() {//这里要注意判空（view和model可能为空）
        String dataFromNet = null;
        if (model != null) {
            dataFromNet = model.getDataFromNet();
        }
        if (getView() != null) {
            getView().setData(dataFromNet);
        }
    }

    @Override
    protected void onViewDestroy() {//销毁Activity时的操作，可以停止当前的model
        if (model != null) {
            model.stopRequest();
        }
    }
}

Presenter层没有实现接口，而是继承了BasePresenter抽象类，在这个类中，我们可以通过getView()方法来获取VIew层，直接拿去model来获取Model层的实例，但这一切一定要注意判空。

六、结合RxJava及Retrofit使用

此框架结合RxJava和Retrofit会更加方便，Retrofit本身支持RxJava，所以我们只需要在Model层中返回Observable到Presenter中即可，在Presenter中等待网络请求的结束，并通知View层。看一下代码。

Model和它的实现类

public interface MainModel extends Model {
    /**
     * 从网络获取数据
     *
     * @return
     */
    Observable<List<User>> getDataFromNet();

    String getDataFromString();

    /**
     * 停止请求
     */
    void stopRequest();
}

interface GitHubService {
        @GET("user.json")
        Observable<List<User>> getUser();
    }

    @Override
    public Observable<List<User>> getDataFromNet() {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://www.icandemy.cn/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.createWithScheduler(new IoScheduler()))
                .build();
        GitHubService gitHubService = retrofit.create(GitHubService.class);
        return gitHubService.getUser();
    }

Presenter层

public void getData() {//这里要注意判空（view和model可能为空）
        if (model != null) {
            Observable<List<User>> observable = model.getDataFromNet();
            observable.observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<List<User>>() {
                @Override
                public void onSubscribe(Disposable d) {
                }

                @Override
                public void onNext(List<User> users) {
                    if (getView() != null) {
                        getView().setData(new Gson().toJson(users));
                    }
                }

                @Override
                public void onError(Throwable e) {
                }

                @Override
                public void onComplete() {
                }
            });
        }
    }

Fragment的使用和Activity的使用是一样的，整个工程的代码已经放到GitHub上去了，想了解的可以看一下。

https://github.com/chengzhicao/SimpleMvp

总之，这是一个非常精简的MVP框架，可以很好的帮我们理解这个模式，虽然简陋了些，但麻雀虽小五脏俱全，大家可以自己进行扩展让他拥有更丰富的功能。

七、结合RxJava及Retrofit使用（放弃Model ）

gitee地址：https://gitee.com/luoyanyong/LessonStudy

1. MainActivity类：

public class MainActivity extends BaseMvpActivity< MainView, MainPresenter> implements MainView {
    private TextView tvFirst;
    private  Button btn;
    private  Button btn2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
         btn = findViewById(R.id.btn);
        btn2 = findViewById(R.id.btn2);
        tvFirst = findViewById(R.id.tv_first);
        init();
    }



    @Override
    public MainView createView() {
        return this;
    }

    @Override
    public MainPresenter createPresenter() {
        return new MainPresenter();
    }

    private void init() {
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (presenter != null) {
                    presenter.getData("mainActivity");
                }
            }
        });

        btn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(MainActivity.this, TwoActivity.class));
            }
        });
    }
    
    @Override
    public void onError(String message) {
    }
    
    @Override
    public void onSmsSuccess(String type, String value) {
      //  ToastUtils.showLong("type==="+type+": value===="+value);
        Log.d("LUO","type==="+type+": value===="+value);
    }

2. MainPresenter 类

public class MainPresenter extends BasePresenter<MainView> {
    private SuManHttpService suManHttpService;
    private ApiService apiService;

    public MainPresenter() {

        suManHttpService= new SuManHttpService();
//        if (getView() != null) {
//            getView().setData(dataFromNet);
//        }
    }

    public void getData(String type) {
        HashMap map = new HashMap();
        map.put("mobile","1561827XXXX");
        map.put("area_code","+86");
        suManHttpService.sendMsg(map).compose(RxSchedulers.compose()).subscribe(new HttpResponseObserver<BaseHttpResponse<SmsBean>>(){

            @Override
            public void success(BaseHttpResponse<SmsBean> smsBeanBaseHttpResponse) {
                try {

                    if (smsBeanBaseHttpResponse!=null){
                        if (getView() != null) {
                            String msg = smsBeanBaseHttpResponse.msg;
                            getView().onSmsSuccess(type ,msg);
                        }

                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void error(int code, String message) {
                try {
                    if (  getView()!=null){
                        getView().onError(message);
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        });
    }
}

3. SuManHttpService 类

public class SuManHttpService {
    /**
     * ApiService Api接口每一个接口
     */
    ApiService apiService;

    public SuManHttpService() {
        if (apiService==null){
            retrofit2.Retrofit retrofit = RetrofitHttp.provideRetrofit();
            //获取接口对象
            apiService = retrofit.create(ApiService.class);
        }
    }

    /**
     * 类转化请求体
     *
     * @param requestBean 所有请求参数封装的类
     * @return Okhttp需要的请求体
     */
    public static String creatRequestBody(BaseRequestBean requestBean) {
        // final String params = new Gson().toJson(requestBean);
        String jsonstr = new Gson().toJson(requestBean).replace("\\", "");
        // String json = "{\"param\":" + jsonstr + "}";
        //RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonstr);
        return jsonstr;
    }

    /**
     * 刷新客户端连接时间接口
     */
    public Observable<ResponseBody> login() {
        return apiService.login();
    }

    /**
     * 发送短信
     *
     * @param map
     */
    public Observable<BaseHttpResponse<SmsBean>> sendMsg(HashMap map) {
        return apiService.sendMsg(map);
    }
}

4. RxSchedulers类

public class RxSchedulers {

    public static ObservableTransformer compose() {
        return new ObservableTransformer(){
            @Override
            public ObservableSource apply(io.reactivex.Observable upstream) {
                return upstream.subscribeOn(io.reactivex.schedulers.Schedulers.io()).observeOn(io.reactivex.android.schedulers.AndroidSchedulers.mainThread());
            }
        };
    }
}

5. HttpResponseObserver类

 public abstract class HttpResponseObserver<T> implements Observer<T> {

    private static final int UNAUTHORIZED = 401;
    private static final int FORBIDDEN = 403;
    private static final int NOT_FOUND = 404;
    private static final int REQUEST_TIMEOUT = 408;
    private static final int INTERNAL_SERVER_ERROR = 500;
    private static final int BAD_GATEWAY = 502;
    private static final int SERVICE_UNAVAILABLE = 503;
    private static final int GATEWAY_TIMEOUT = 504;


    @Override
    public void onError(Throwable e) {
        String errorStr = "";
        //数据解析异常
//       if (e instanceof Exception) {
//           errorStr = e.getMessage();
//       }
//
        if (e instanceof HttpException) {
            HttpException httpException = (HttpException) e;
            switch (httpException.code()) {
                case UNAUTHORIZED:
                case FORBIDDEN:
                case NOT_FOUND:
                case REQUEST_TIMEOUT:
                case GATEWAY_TIMEOUT:
                case INTERNAL_SERVER_ERROR:
                case BAD_GATEWAY:
                case SERVICE_UNAVAILABLE:
                default:
                    errorStr = "网络错误,请检查网络并重试";
                    break;
            }
            error(-1,errorStr);
        } else if (e instanceof RuntimeException) {
            errorStr = "服务器异常，请稍后重试";
        } else if (e instanceof JsonParseException
                || e instanceof JSONException
                || e instanceof ParseException) {

            errorStr = "解析错误，请重试";
        } else if (e instanceof ConnectException) {
            errorStr = "连接失败，请检查网络并重试";
        }else if(e instanceof SocketTimeoutException){
            errorStr = "连接超时，请检查网络并重试";
        } else if (e instanceof javax.net.ssl.SSLHandshakeException) {
            errorStr = "证书验证失败，请重试";
        }else if(e instanceof HttpException){
            errorStr = "服务器异常，请重试";
        } else {
            errorStr = "请求失败，请检查网络并重试";
        }

        error(-1,errorStr);
    }

    @Override
    public void onNext(T data) {
        try {

            String requestParameter = HttpInterceptor.getRequestParameter();
            String responseParameter = HttpInterceptor.getResponseParameter();
//            Log.d("LUO","========"+requestParameter);
//            Log.d("LUO","========"+responseParameter);
            if (data instanceof BaseResponse) {
                //基础数据
                BaseResponse baseResponse = (BaseResponse) data;
                //对于所有的网络请求，1-成功 : -0,失败
                int state = baseResponse.getResponseState();
                // state=1.code=11.token失效
                int responseCode = baseResponse.getResponseCode();
                String message = baseResponse.getResponseMsg()==null?"":baseResponse.getResponseMsg();
                if (state == 1) {
                    success(data);
                } else {
                    error(state, message);
                }
            }else {
                JSONObject jsonObject = (JSONObject) data;
                int state = jsonObject.getIntValue("state");
                int code = jsonObject.getIntValue("code");
                String msg = jsonObject.getString("msg")==null?"":jsonObject.getString("msg");
                if (state==1){
                    success(data);
                }else {
                    error(state, msg);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public abstract void success(T t);
    public abstract void error(int code, String message);
    @Override
    public void onComplete() {
    }

    @Override
    public void onSubscribe(Disposable d) {
    }


}

6. BaseHttpResponse

public class BaseHttpResponse< T extends BaseResponseBean> implements BaseResponse {

    /**
     * 返回结果的状态值(1:成功,0:失败)
     */
    public int state;
    /**
     * 返回结果code
     */
    public int code;
    /**
     * 返回数据
     */
    public T data;
    /**
     * 信息描述
     */
    public String msg;
    /**
     * 返回的token
     */
    public String token;


    @Override
    public int getResponseState() {
        return state;
    }

    @Override
    public String getResponseMsg() {
        return msg;
    }

    @Override
    public int getResponseCode() {
        return code;
    }
}

7. BaseResponse 类

public interface BaseResponse {

    /**
     * 获取返回码
     */
    int getResponseState();


    /**
     * code返回码
     */
    int getResponseCode();

    /**
     *
     * 获取返回的提示信息
     */
    String getResponseMsg();
}

8. BaseHttpListResponse类

public class BaseHttpListResponse<T extends BaseResponseBean> implements BaseResponse {

    /**
     * 返回结果的状态值(1:成功,0:失败)
     */
    public int state;
    /**
     * 返回结果code
     */
    public int code;
    /**
     * 返回数据
     */
    public List<T> data;
    /**
     * 信息描述
     */
    public String msg;
    /**
     * 返回的token
     */
    public String token;

    @Override
    public int getResponseState() {
        return state;
    }

    @Override
    public String getResponseMsg() {
        return msg;
    }

    @Override
    public int getResponseCode() {
        return code;
    }
}

9.SuManHttpService 类

public class SuManHttpService {
    /**
     * ApiService Api接口每一个接口
     */
    ApiService apiService;

    public SuManHttpService() {
        if (apiService==null){
            retrofit2.Retrofit retrofit = RetrofitHttp.provideRetrofit();
            //获取接口对象
            apiService = retrofit.create(ApiService.class);
        }
    }

    /**
     * 类转化请求体
     *
     * @param requestBean 所有请求参数封装的类
     * @return Okhttp需要的请求体
     */
    public static String creatRequestBody(BaseRequestBean requestBean) {
        // final String params = new Gson().toJson(requestBean);
        String jsonstr = new Gson().toJson(requestBean).replace("\\", "");
        // String json = "{\"param\":" + jsonstr + "}";
        //RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonstr);
        return jsonstr;
    }

    /**
     * 刷新客户端连接时间接口
     */
    public Observable<ResponseBody> login() {
        return apiService.login();
    }

    /**
     * 发送短信
     *
     * @param map
     */
    public Observable<BaseHttpResponse<SmsBean>> sendMsg(HashMap map) {
        return apiService.sendMsg(map);
    }

}

10.RetrofitHttp 类

/**
 * Created by cyb on 2018/11/21.
 * 创建请求对象
 */
public class RetrofitHttp {
    private static int CONNECT_TIMEOUT = 60;
    private static int READ_TIMEOUT = 60;
    private static int WRITE_TIMEOUT =60;
    private static  OkHttpClient okHttpClient;
    private static retrofit2.Retrofit retrofit;
    private  static HttpInterceptor httpInterceptor;

    /**
     * 添加应用拦截器interceptor
     * @param interceptor
     * @return
     */
    public static OkHttpClient provideOkHttpClient(HttpInterceptor interceptor){
        HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
       httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

        if (okHttpClient==null){
            okHttpClient =  new OkHttpClient.Builder().
                    connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS).
                    readTimeout(READ_TIMEOUT, TimeUnit.SECONDS).
                    writeTimeout(WRITE_TIMEOUT, TimeUnit.SECONDS).
                    //添加拦截器
                    addInterceptor(interceptor).
                    retryOnConnectionFailure(true).
                    build();
        }

        return okHttpClient;
    }
    public static retrofit2.Retrofit provideRetrofit(){
        //拦截器
        if (httpInterceptor==null){
            httpInterceptor = new HttpInterceptor();
        }
        //请求
        if (retrofit==null){
            retrofit =   new retrofit2.Retrofit.Builder()
                    .baseUrl(BuildConfig.BASE_URL)
                    .client(provideOkHttpClient(httpInterceptor))
                    //添加数据解析
                    .addConverterFactory(GsonConverterFactory.create())
                    //支持RXJava返回
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .build();
        }

       return retrofit;
    }
}

11.HttpInterceptor 拦截器

/**
 * @author by lyy on 2019/9/12.
 *  okhttp  拦截器，主要功能为添加请求头,统一记录日志等等统一行为
 */
public class HttpInterceptor implements Interceptor {
    private static final Charset UTF8 = Charset.forName("UTF-8");

    private static String requestValue;
    private static String reponseValue;


    @Override
    public Response intercept(Chain chain) throws IOException {
        //请求token
//        String token = SPUtils.getInstance(SPConstant.TOKEN).getString(SPConstant.TOKEN);

        Request request = chain.request();
       // LogUtils.d( "device_id="+BaseApplication.device);
        //添加请求头
       Request updateRequest = request.newBuilder().header("token", "111")
               .addHeader("device_id", "88888")
               .addHeader("deviceType", "Android")
               .addHeader("screenSize", ScreenUtils.getAppScreenWidth()+"x"+ScreenUtils.getAppScreenHeight())
               .addHeader("version",BuildConfig.VERSION_NAME)
               .build();

        Response response =  chain.proceed(updateRequest);





        if(BuildConfig.DEBUG){
            //添加打印服务器返回的数据
            ResponseBody responseBody = response.body();
            long contentLength = responseBody.contentLength();
            BufferedSource source = responseBody.source();
            source.request(Integer.MAX_VALUE); // Buffer the entire body.
            Buffer buffer = source.buffer();

            LogUtils.d("请求参数："+ response.toString()+"\n"+"主体："+getRequestInfo(request)+"\n"+"返回数据："+getResponseInfo(response)+"\n"+updateRequest.headers());
            requestValue =  response.toString();
            reponseValue = getResponseInfo(response);
//            if (contentLength != 0) {
//                String msg = buffer.clone().readString(Charset.forName("UTF-8"));
//                LogUtils.d("请求参数："+response.toString()+"\n"+"返回数据："+msg+"\n"+updateRequest.headers());
//            }else {
//                LogUtils.d("请求参数："+response.toString());
//            }
        }

        return response;
    }


    /**
     *
     * @return
     */
    public static String getRequestParameter(){

        return requestValue;
    }
    public static String getResponseParameter(){

        return reponseValue;
    }
    /**
     * 打印请求消息
     *
     * @param request 请求的对象
     */
    private String getRequestInfo(Request request) {
        String str = "";
        if (request == null) {
            return str;
        }
        RequestBody requestBody = request.body();
        if (requestBody == null) {
            return str;
        }
        try {
            Buffer bufferedSink = new Buffer();
            requestBody.writeTo(bufferedSink);
            Charset charset = Charset.forName("utf-8");
            str = bufferedSink.readString(charset);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 打印返回消息
     *
     * @param response 返回的对象
     */
    private String getResponseInfo(Response response) {
        String str = "";
        if (response == null || !response.isSuccessful()) {
            return str;
        }
        ResponseBody responseBody = response.body();
        long contentLength = responseBody.contentLength();
        BufferedSource source = responseBody.source();
        try {
            source.request(Long.MAX_VALUE); // Buffer the entire body.
        } catch (IOException e) {
            e.printStackTrace();
        }
        Buffer buffer = source.buffer();
        Charset charset = Charset.forName("utf-8");
        if (contentLength != 0) {
            str = buffer.clone().readString(charset);
        }
        return str;
    }
}

链接：https://www.jianshu.com/p/51c4681f7f94