retrofit+mvp+okhttp+rxjava封装

首先是retrofit和okhttp的封装：

因为retrofit的底层就是用okhttp请求网络的，所以可以通过就是设置okhttp的连接超时，缓存，日志等，将它加入到retrofit中。

具体代码：

import android.content.Context;
import android.util.Log;

import com.jakewharton.retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import com.seehealth.easynet.http.RetrofitService;
import com.seehealth.easynet.http.ServiceConfig;

//import org.simpleframework.xml.Serializer;
//import org.simpleframework.xml.convert.AnnotationStrategy;
//import org.simpleframework.xml.core.Persister;
//import org.simpleframework.xml.strategy.Strategy;

import java.io.File;
import java.util.concurrent.TimeUnit;

import okhttp3.Cache;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
import retrofit2.converter.scalars.ScalarsConverterFactory;
//import retrofit2.converter.simplexml.SimpleXmlConverterFactory;

/**
 * Created by ljj on 2017/9/29.
 */

public class RetrofitManager {

    private volatile static RetrofitManager retrofitManager;
    private RetrofitService retrofitService;

//    private static Strategy strategy = new AnnotationStrategy();
//    private static Serializer serializer = new Persister(strategy);

    private RetrofitManager(Context context) {
        OkHttpClient okHttpClient = initOkHttpClient(context);
        Retrofit retrofit = initRetrofit(okHttpClient);
        retrofitService = retrofit.create(RetrofitService.class);
    }

    public static RetrofitManager getInstance(Context context) {
        if (retrofitManager == null) {
            synchronized (RetrofitManager.class) {
                if (retrofitManager == null) {
                    retrofitManager = new RetrofitManager(context);
                }
            }
        }
        return retrofitManager;
    }

    public RetrofitService getRetrofitService() {
        return retrofitService;
    }

    /**
     * 初始化okhttp
     *
     * @param context
     * @return
     */
    private OkHttpClient initOkHttpClient(Context context) {
        //新建一个文件用来缓存网络请求
        File cacheDirectory = new File(context.getCacheDir().getAbsolutePath() + "responses");
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(ServiceConfig.TIMEOUT, TimeUnit.SECONDS)//设置连接超时
                .readTimeout(ServiceConfig.TIMEOUT, TimeUnit.SECONDS)//设置从主机读信息超时
                .writeTimeout(ServiceConfig.TIMEOUT, TimeUnit.SECONDS)//设置写信息超时
                .retryOnConnectionFailure(true)///如果连接失败,尝试重连
                .cache(new Cache(cacheDirectory, 10 * 1024 * 1024))//设置缓存文件
                .addInterceptor(initInterceptor())//设置okhttp拦截器，这样做的好处是可以为你的每一个retrofit2的网络请求都增加相同的head头信息，而不用每一个请求都写头信息
                .addInterceptor(initLogInterceptor())//打印日志
                .build();
        return okHttpClient;
    }

    /**
     * 初始化http拦截器
     *
     * @return
     */
    private Interceptor initInterceptor() {
        BasicParamsInterceptor builder = new BasicParamsInterceptor.Builder()
//                .addHeaderParam("Content-Type", "text/xml; charset=utf-8")// 对于SOAP 1.1， 如果是soap1.2 应是Content-Type: application/soap+xml; charset=utf-8
                .build();
        return builder;
    }

    /**
     * 初始化日志信息
     *
     * @return
     */
    private Interceptor initLogInterceptor() {
        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                Log.i("TTT", "请求参数:" + message);
            }
        });
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        return interceptor;
    }

    /***
     * 初始化Retrofit
     */
    private Retrofit initRetrofit(OkHttpClient client) {
        Retrofit retrofit = new Retrofit.Builder()
                .client(client)//设置 HTTP Client  用于请求的连接
//                .addConverterFactory(SimpleXmlConverterFactory.create(serializer))//解析xml
                .addConverterFactory(ScalarsConverterFactory.create())//如果网络访问返回的字符串，而不是json数据格式，要使用下面的转换器
                .addConverterFactory(GsonConverterFactory.create())//如果网络访问返回的是json字符串，使用gson转换器
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//此处顺序不能和上面对调，否则不能同时兼容普通字符串和Json格式字符串  为了支持rxjava,需要添加下面这个把 Retrofit 转成RxJava可用的适配类
                .baseUrl(ServiceConfig.BASE_URL)
                .build();
        return retrofit;
    }

}

接着是初步封装mvp层，已登入为例子:

我的目录结构，一个model对应一个presenter对应多个view

因为presenter都会接收到model返回来的结果，所以我将它单独写成了一个父类IPresenter:

public interface IPresenter {
    void success(int code, Object result);

    void error(int code, String result);
}

每个Presenter接口类都继承IPresenter：

public interface IAccountPresenter extends IPresenter {
    /**
     * 登入
     *
     * @param userName
     * @param password
     */
    void login(String userName, String password); }

一般写法是

 rService.login(userName, password)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Object>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        
                    }

                    @Override
                    public void onNext(Object o) {

                    }

                    @Override
                    public void onError(Throwable t) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

封装后写法：

 rService.login(userName, password)
                .compose(new RxFlowableTransformer())
                .subscribe(new IRxSubscribler(basePresenter, HttpInterfaceCode.LOGIN_SUC));

我的model实现类：

/**
 * 用户具体实现类
 * Created by 1 on 2018/1/24.
 */

public class AccountModelImpl implements IAccountModel {
    private RetrofitService rService;
    private IPresenter basePresenter;

    public AccountModelImpl(RetrofitManager retrofitManager, IPresenter basePresenter) {
        rService = retrofitManager.getRetrofitService();
        this.basePresenter = basePresenter;
    }

    @Override
    public void login(String userName, String password) {
        rService.login(userName, password)
                .compose(new RxFlowableTransformer())
                .subscribe(new IRxSubscribler(basePresenter, HttpInterfaceCode.LOGIN_SUC));
    }

    @Override
    public void register(AccountBean account) {
        rService.register(account)
                .compose(new RxFlowableTransformer())
                .subscribe(new IRxSubscribler(basePresenter, HttpInterfaceCode.REGISTER_SUC));
    }

    @Override
    public void forgetPassword(AccountBean accountBean) {
        rService.forgetPw(accountBean)
                .compose(new RxFlowableTransformer())
                .subscribe(new IRxSubscribler(basePresenter, HttpInterfaceCode.FORGET_PW_SUC));
    }
}

因为我将Ipresenter放到了 model类中，所以结果直接回调到了presenter的实现类中success和error方法中；

RxFlowableTransformer类很简单，就是封装了线程而已：

public final class RxFlowableTransformer implements FlowableTransformer {
    @Override
    public Publisher apply(Flowable upstream) {
        return upstream.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

}

接着看IRxSubscribler类，有两个参数，一个是iPresenter引用，还有一个是接口回调成功值(如值为20，则接口回调失败会返回-20)；

public class IRxSubscribler<T> extends RxSubscribler<T> {
    private IPresenter basePresenter;
    private int interfaceCode;

    public IRxSubscribler(IPresenter basePresenter, int interfaceCode) {
        this.basePresenter = basePresenter;
        this.interfaceCode = interfaceCode;
    }

    @Override
    public void success(Object o) {
        basePresenter.success(interfaceCode, o);
    }

    @Override
    public void error(String result) {
        basePresenter.error(-interfaceCode, result);
    }
}

这里只是进行了回调操作，接着去RxSubscribler类

public abstract class RxSubscribler<T> implements Subscriber<T> {
    @Override
    public final void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE);
    }

    @Override
    public final void onNext(T o) {
        checkIsSucc(o);
    }

    @Override
    public final void onError(Throwable t) {

        if (t instanceof SocketTimeoutException) {
            error("服务器连接超时");
        } else if (t instanceof ConnectException) {
            error("服务器链接失败");
        } else if (t instanceof TimeoutException) {
            error("网络超时");
        } else if (t instanceof UnknownHostException) {
            error("未知主机错误");
        } else {
            error("未知错误");
            t.printStackTrace();
        }
    }

    @Override
    public final void onComplete() {

    }

    public abstract void success(T o);

    public abstract void error(String result);

    private void checkIsSucc(T o) {
        if (o instanceof BaseResponse) {
            BaseResponse response = (BaseResponse) o;
            String errorMessage = "未知错误";
            switch (response.getCode()) {
                case HttpInterfaceCode.NET_REUQEST_OK:
                    success(o);
                    return;
                case HttpInterfaceCode.NET_REQUEST_ERROR:
                    errorMessage = "请求错误";
                    break;
                case HttpInterfaceCode.NET_REQUEST_REJECT:
                    errorMessage = "请求被拒绝";
                    break;
                case HttpInterfaceCode.NET_REQUEST_UNFOUND:
                    errorMessage = "请求未响应";
                    break;
                case HttpInterfaceCode.NET_SERVICE_ERROR:
                    errorMessage = "服务器错误";
                    break;
                case HttpInterfaceCode.NET_NUKNOWN_ERROR:
                    errorMessage = "未知错误";
                    break;
            }
            error(errorMessage);
        }

    }
}

流程大概就是这样。源码会在以后发布到github上