Retrofit+RxJava2的封装使用

公司上个项目用的是rxjava1.0,最近看了各种rxjava2.0的介绍，自己也摸索着来，所以打算封装一下，用到项目中，与时俱进嘛！先不多逼逼了，直截了当，上货......
先看一下关于怎么配置Retrofit，这个大家都差不多，就不多解释了。。。base_url直接换成自己公司服务器的地址就可以了
github地址：https://github.com/Veken/RxJava2Retrofit
1 封装

Retrofit配置类 
/**
 * Retrofit配置
 */
public class RetrofitConnect {
    private Retrofit retrofit;
    private Service service;
    /**
     * 网络请求超时时间毫秒
     */
    int DEFAULT_TIMEOUT = 20000;

    /**
     *   你们公司自己的服务器地址
     */
    public static String BASE_URL = "";

    private RetrofitConnect() {
       /* HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);*/

        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                try {
                    String text = URLDecoder.decode(message, "utf-8");
                    LogUtils.e("OKHttp-----", text);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                    LogUtils.e("OKHttp-----", message);
                }
            }
        });
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        File cacheFile = new File(Utils.getContext().getCacheDir(), "cache");
        Cache cache = new Cache(cacheFile, 1024 * 1024 * 100); //100Mb

        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .readTimeout(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS)
                .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS)
                .addInterceptor(interceptor)
                .addNetworkInterceptor(new HttpCacheInterceptor())
                .cache(cache)
                .build();

        Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").serializeNulls().create();

        retrofit = new Retrofit.Builder()
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .baseUrl(BASE_URL)
                .build();
        service = retrofit.create(Service.class);
    }

    //  创建单例
    private static class SingletonHolder {
        private static final RetrofitConnect INSTANCE = new RetrofitConnect();
    }
    public static Service getApiService() {
        return SingletonHolder.INSTANCE.service;
    }

    class HttpCacheInterceptor implements Interceptor {

        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            if (!NetworkUtils.isConnected()) {  //没网强制从缓存读取
                request = request.newBuilder()
                        .cacheControl(CacheControl.FORCE_CACHE)
                        .build();
                LogUtils.d("Okhttp", "no network");
            }


            Response originalResponse = chain.proceed(request);
            if (NetworkUtils.isConnected()) {
                //有网的时候读接口上的@Headers里的配置，你可以在这里进行统一的设置
                String cacheControl = request.cacheControl().toString();
                return originalResponse.newBuilder()
                        .header("Cache-Control", cacheControl)
                        .removeHeader("Pragma")
                        .build();
            } else {
                return originalResponse.newBuilder()
                        .header("Cache-Control", "public, only-if-cached, max-stale=2419200")
                        .removeHeader("Pragma")
                        .build();
            }
        }
    }
}

接下来第一步封装，把请求的一些网络线程等等封装在一个类SubScriberHandler里面
并且把post请求的参数进行sha加密，参数可以根据公司自己的要求，自己更改

public class SubScriberHandler {

    /**
     * @param o
     * @param <T>
     */
    public <T> void toSubscribe(Observable<T> o, DefaultObserver observer) {
        o.subscribeOn(Schedulers.io())      //网络耗时操作在io线程处理
                .unsubscribeOn(Schedulers.io()) //网络耗时操作在io线程处理
                .observeOn(AndroidSchedulers.mainThread())  //更新数据在主线程
                .subscribe(observer);
    }

    /**
     * 添加共同参数 SHA1加密
     * @param fields
     */
    public void handleFields(Map<String, Object> fields) {
        fields.put("appKey", "00001");
        fields.put("v", "1.0");
        String sessionId = SpConfig.getInstance().getString(Constants.SESSIONID_STRING);
        if(!TextUtils.isEmpty(sessionId))
            fields.put(Constants.SESSIONID_STRING, sessionId);

        String sha1 = null;
        try {
            sha1 = SHA1.SHA1(fields);
        } catch (DigestException e) {
            e.printStackTrace();
        }
        fields.put("sign", sha1);
    }
}

接下来是关于自定义的实现Observer的类DefalutObserver，同时也添加了一个加载数据时候的progressdialog，可以根据公司的需求更改成自己的progressdialog，我这只是简单的调用普通的。各位客官也可以自己看心情来封装

**
 * @author Veken
 */
public abstract class DefaultObserver<T extends BaseRespond> implements Observer<T>,ProgressCancelListener {
    private Context context;
    private boolean isAddInStop = false;
    private ProgressDialogHandler mProgressDialogHandler;
    //取消订阅
    private Disposable mDisposable;

    public DefaultObserver(Context context, boolean isShowLoading) {
        this.context = context;
        mProgressDialogHandler = new ProgressDialogHandler(context,this,true);
        if (isShowLoading) {
            showProgressDialog();
        }
    }

    private void showProgressDialog(){
        if (mProgressDialogHandler != null) {
            mProgressDialogHandler.obtainMessage(ProgressDialogHandler.SHOW_PROGRESS_DIALOG).sendToTarget();
        }
    }

    private void dismissProgressDialog(){
        if (mProgressDialogHandler != null) {
            mProgressDialogHandler.obtainMessage(ProgressDialogHandler.DISMISS_PROGRESS_DIALOG).sendToTarget();
            mProgressDialogHandler = null;
        }
    }

    @Override
    public void onSubscribe(Disposable d) {
        mDisposable =d;
    }

    @Override
    public void onNext(T response) {
        dismissProgressDialog();
        if (response.getResCode().equals("200")) {
            onSuccess(response);
        } else {
            onFail(response);
        }
    }


    @Override
    public void onError(Throwable e) {
        LogUtils.e("Retrofit", e.getMessage());
//        dismissProgress();
        dismissProgressDialog();
        if (e instanceof HttpException) {     //   HTTP错误
            onException(ExceptionReason.BAD_NETWORK);
        } else if (e instanceof ConnectException
                || e instanceof UnknownHostException) {   //   连接错误
            onException(ExceptionReason.CONNECT_ERROR);
        } else if (e instanceof InterruptedIOException) {   //  连接超时
            onException(ExceptionReason.CONNECT_TIMEOUT);
        } else if (e instanceof JsonParseException
                || e instanceof JSONException
                || e instanceof ParseException) {   //  解析错误
            onException(ExceptionReason.PARSE_ERROR);
        } else {
            onException(ExceptionReason.UNKNOWN_ERROR);
        }
    }

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

    /**
     * 请求成功
     *
     * @param response 服务器返回的数据
     */
    abstract public void onSuccess(T response);

    /**
     * 服务器返回数据，但响应码不为200
     *
     * @param response 服务器返回的数据
     */
    public void onFail(T response) {
        String message = response.getResDesc();
        if (TextUtils.isEmpty(message)) {
            ToastUtils.show(R.string.response_return_error);
        } else {
            ToastUtils.show(message);
        }
    }

    /**
     * 请求异常
     *
     * @param reason
     */
    public void onException(ExceptionReason reason) {
        switch (reason) {
            case CONNECT_ERROR:
                ToastUtils.show(R.string.connect_error, Toast.LENGTH_SHORT);
                break;

            case CONNECT_TIMEOUT:
                ToastUtils.show(R.string.connect_timeout, Toast.LENGTH_SHORT);
                break;

            case BAD_NETWORK:
                ToastUtils.show(R.string.bad_network, Toast.LENGTH_SHORT);
                break;

            case PARSE_ERROR:
                ToastUtils.show(R.string.parse_error, Toast.LENGTH_SHORT);
                break;

            case UNKNOWN_ERROR:
            default:
                ToastUtils.show(R.string.unknown_error, Toast.LENGTH_SHORT);
                break;
        }
    }

    /**
     * 请求网络失败原因
     */
    public enum ExceptionReason {
        /**
         * 解析数据失败
         */
        PARSE_ERROR,
        /**
         * 网络问题
         */
        BAD_NETWORK,
        /**
         * 连接错误
         */
        CONNECT_ERROR,
        /**
         * 连接超时
         */
        CONNECT_TIMEOUT,
        /**
         * 未知错误
         */
        UNKNOWN_ERROR,
    }

    /**
     * 取消ProgressDialog的时候，取消对observable的订阅，同时也取消了http请求
     */
    @Override
    public void onCancelProgress() {
        if (!mDisposable.isDisposed()) {
            mDisposable.dispose();
        }
    }
}

现在就是大家耳熟能详的Service类，这就没什么可说的，你要什么请求，就是什么，比如你要登录就写一个login的service，然后Map中装你需要请求的参数，以此类推。

/**
 * @author Veken
 */
public interface Service {


    /**
     * 登录的service
     * @param fields
     * @return
     */
    @FormUrlEncoded
    @POST(Constants.URLEND)
    Observable<LoginRespond> login(@FieldMap Map<String, Object> fields);

}

现在到了正儿八经的封装了，前面的都是开胃菜，配置都差不多，大同小异，到上真货的时候了

public class UserInfoRequest extends SubScriberHandler {

    private UserInfoBean userInfoBean;
    private Context context;

    public UserInfoRequest(Context context,UserInfoBean userInfoBean) {
        this.context = context;
        this.userInfoBean = userInfoBean;
    }

    public void login() {

        Map<String, Object> fields = new HashMap<>();
        //调用的接口方法，比如login方法
        fields.put("method", "user.login");
        //加密和传一些常用参数
        handleFields(fields);
        //需要传递的参数
        fields.put("phoneNo", userInfoBean.getPhoneNum());
        fields.put("password", userInfoBean.getPwd());
        //申请网络
        Observable observable = RetrofitConnect.getApiService().login(fields);
        toSubscribe(observable, new DefaultObserver(context,true) {
            //数据返回在onNext
            @Override
            public void onSuccess(BaseRespond response) {
            }

           //数据返回
            @Override
            public void onNext(@NonNull BaseRespond response) {
                //将结果封装在javabean的onSuccess方法里面
                userInfoBean.onSuccess(response);
            }

            @Override
            public void onError(Throwable e) {
                super.onError(e);
                userInfoBean.onError(e);
            }
        });
    }

}

2 调用
下面就是具体调用了，看一下在MainActivity中怎么简单的调用吧
实现UserInfoBean，这样可以在重写的方法中传入我们需要的参数，当然也可以不写一个bean，直接用String传也可以，但是习惯了bean，数据处理也在bean中，简单明了。
初始化你的UserInfoPresent网络请求
private UserInfoRequest userInfoRequest;
userInfoRequest= new UserInfoRequest(this,this);
如果没有实现bean的话，UserInfoPresent（）方法中的参数会报错，如果不想调用bean，可以自己简单的修改一下
剩下的就简单了，在自己想要请求网络的地方，调用 userInfoPresent.login();一句代码就可以了

public class MainActivity extends BaseActivity implements UserInfoBean {
    private Button btn;
    private UserInfoRequest userInfoRequest;
    private TextView tv;

    @Override
    protected int getLayoutId() {
        return R.layout.activity_main;
    }

    @Override
    protected void initData(Bundle savedInstanceState) {
    }

    @Override
    protected void initView() {
        btn = (Button) findViewById(R.id.btn);
        tv = (TextView) findViewById(R.id.tv);
        userInfoRequest= new UserInfoRequest(this,this);

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                userInfoRequest.login();
            }
        });
    }

    //传递的用户
    @Override
    public String getPhoneNum() {
        //根据需要，传递相应的数据
        return "登录账号";
    }

    //传递的密码
    @Override
    public String getPwd() {
        //根据需要，传递相应的数据
        return "登录密码";
    }

    //数据返回
    @Override
    public void onSuccess(Object object) {
        LoginRespond loginRespond = (LoginRespond) object;
        Log.d("登录信息:", loginRespond.getResDesc());
        tv.setText(loginRespond.getData().getTelphone());
    }

    @Override
    public void onError(Throwable e) {

    }
}

想必有老铁就问了，如果一个界面有多处需要请求网络的，那该怎么办呢？
因为我们是通过实现javabean的方法，java是单继承，多实现吗。这不就清楚了
当然你还可以直接使用

 Map<String, Object> fields = new HashMap<>();
        //调用的接口方法，比如login方法
        fields.put("method", "user.login");
        //加密和传一些常用参数
        handleFields(fields);
        //传递需要传递的参数
        fields.put("phoneNo", userInfoBean.getPhoneNum());
        fields.put("password", userInfoBean.getPwd());
        //申请网络
        Observable observable = RetrofitConnect.getApiService().login(fields);
        toSubscribe(observable, new DefaultObserver(context,true) {
            //数据返回在onNext
            @Override
            public void onSuccess(BaseRespond response) {
            }

            @Override
            public void onNext(@NonNull BaseRespond response) {
                userInfoBean.onSuccess(response);
            }

            @Override
            public void onError(Throwable e) {
                super.onError(e);
                userInfoBean.onError(e);
            }
        });

初始化UserInfoRequest，就可以了。
还有很多不足的地方，希望各位老爷批评指正，大家共同进步，自己项目实战过的，不是demo，所以可以直接拿来用，有什么问题，还烦请指教、、、
PS:没有用到太多的RxJava的操作符，刚接触，还不是很熟悉，还不会灵活运用，见谅！！！
在这里要感谢那些为我们分享贡献的前辈，感谢他们的辛勤耕耘，才有我们菜鸟的不断进步。
特此感谢：
用水管讲解rxjava和retroft使用的：http://www.jianshu.com/p/464fa025229e
以及这位前辈提供的demo参考：https://github.com/zhpanvip/Retrofit2