（10）RxJava2+Retrofit2+OkHttp3系列（综合案例）

前面9篇博客我们已经分析过RxJava2，Retrofit2，OkHttp3的基本使用，这里提供一下9篇博客的地址。

1. RxJava2+Retrofit2+OkHttp3系列（RxJava2-1）
2. RxJava2+Retrofit2+OkHttp3系列（RxJava2-2）
3. RxJava2+Retrofit2+OkHttp3系列（RxJava2-3）
4. RxJava2+Retrofit2+OkHttp3系列（RxJava2-4）
5. RxJava2+Retrofit2+OkHttp3系列（RxJava2-5）
6. RxJava2+Retrofit2+OkHttp3系列（RxJava2-6）
7. RxJava2+Retrofit2+OkHttp3系列（RxJava2-7）
8. RxJava2+Retrofit2+OkHttp3系列（Retrofit2-1）
9. RxJava2+Retrofit2+OkHttp3系列（OkHttp3-1）

##正题

说明：由于项目中有其他代码，所以我就不上传代码了，这里将所以代码贴上外加注释，希望帮助大家理解。

###gradle配置

compile 'io.reactivex.rxjava2:rxjava:2.0.7'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

compile 'com.squareup.retrofit2:retrofit:2.1.0'
//这个库可以支持到rxjava2.X
compile 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'
//Retrofit现在只支持到rxjava1.XX
//compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'

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

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

###（2）MainActivity

//处理返回结果的Handler
private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            switch (msg.what) {
                case 1:
                    if (msg.obj instanceof ResultBean) {
                        ResultBean bean = (ResultBean) msg.obj;
                        Toast.makeText(MainActivity.this, bean.toString(), Toast.LENGTH_LONG).show();
                    }
                    break;
            }
        }
    };

//get请求
public void csdnGetBtn(View view) {
        Map<String, Integer> map = new HashMap<>();
        map.put("pno", 1);
        map.put("ps", 10);
        //callBack是处理结果的回调
        ObserverCallBack callBack = new ObserverCallBack<ResultBean>(this, mHandler);
        RxJava2Utils.getData(map, callBack);
    }

//post请求
public void csdnPostBtn(View view) {
        PostParamsBean bean = new PostParamsBean();
        bean.pno = 1;
        bean.ps = 10;

        ObserverCallBack callBack = new ObserverCallBack<ResultBean>(this, mHandler);
        RxJava2Utils.postData(bean, callBack);
    }

###（3）RxJava2Utils

public class RxJava2Utils {

	//获得Retrofit2Service对象
    private static final Retrofit2Service service = Retrofit2Utils.getRetrofit().create(Retrofit2Service.class);

    //get请求
    public static void getData(Map<String, Integer> map, Observer<ResultBean> observer) {
	    //使用RxJava切换线程处理返回结果
        setSubscribe2(service.getWxData(map), observer);
    }

    //post请求
    public static void postData(PostParamsBean bean, Observer<ResultBean> observer) {
        setSubscribe2(service.postWxData(bean), observer);
    }

    //Rxjava2.0
    public static <T> void setSubscribe2(Observable<T> observable, Observer<T> observer) {
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
    }
}

###（4）Retrofit2Utils

public class Retrofit2Utils {

    //服务器路径
    private static final String API_SERVER = "http://v.juhe.cn";

    private static OkHttpClient mOkHttpClient;
    private static Retrofit mRetrofit;

    /**
     * 获取Retrofit对象
     */
    public static Retrofit getRetrofit() {

        if (mRetrofit == null) {

            if (mOkHttpClient == null) {
                mOkHttpClient = OkHttp3Utils.getOkHttpClient();
            }

            mRetrofit = new Retrofit.Builder()
                    .baseUrl(API_SERVER)
                    //添加转化库，默认是Gson
                    .addConverterFactory(GsonConverterFactory.create())
                    //添加回调库，采用RxJava
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    //原生RxJava2.0不支持
                    //.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .client(mOkHttpClient)
                    .build();
        }
        return mRetrofit;
    }
}

###（5）Retrofit2Service

public interface Retrofit2Service {

    //http://v.juhe.cn/weixin/query?key=您申请的KEY

    @GET("/weixin/query")
    Observable<ResultBean> getWxData(@QueryMap Map<String, Integer> map);

    @POST("/weixin/query")
    Observable<ResultBean> postWxData(@Body PostParamsBean bean);
}

###（6）OkHttp3Utils

public class OkHttp3Utils {

    //设置缓存目录
    private static File cacheDirectory = new File(MyApplication.getInstance().getApplicationContext().getCacheDir().getAbsolutePath(), "MyCache");
    private static Cache cache = new Cache(cacheDirectory, 10 * 1024 * 1024);

    private static OkHttpClient mOkHttpClient;

    /**
     * 获取OkHttpClient对象
     */

    public static OkHttpClient getOkHttpClient() {
        if (mOkHttpClient == null) {
            mOkHttpClient = new OkHttpClient.Builder()
                    .connectTimeout(10, TimeUnit.SECONDS)
                    .readTimeout(10, TimeUnit.SECONDS)
                    .writeTimeout(10, TimeUnit.SECONDS)
                    .cache(cache)
                    .addInterceptor(new MyIntercepter())
                    //.cookieJar(new CookiesManager())
                    .build();
        }
        return mOkHttpClient;
    }

    //自定义拦截器
    private static class MyIntercepter implements Interceptor {

        @Override
        public Response intercept(Chain chain) throws IOException {

            Request oldRequest = chain.request();
            HttpUrl.Builder builder = oldRequest.url()
                    .newBuilder()
                    .scheme(oldRequest.url().scheme())
                    .host(oldRequest.url().host())
                    //公共参数
                    .addQueryParameter("key", "c2ada070f003865ea7bb07ae8c2498b7");

            Request newRequest = oldRequest.newBuilder()
                    .method(oldRequest.method(), oldRequest.body())
                    //.header("Content-Type", "application/json")
                    .url(builder.build())
                    .build();

            Response response = chain.proceed(newRequest);

            return response;
        }
    }

    //Cookie设置
    static HashMap<String, List<Cookie>> cookieStore = new HashMap<>();

    private static class CookiesManager implements CookieJar {

        @Override
        public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
            cookieStore.put(url.host(), cookies);
        }

        @Override
        public List<Cookie> loadForRequest(HttpUrl url) {
            List<Cookie> cookies = cookieStore.get(url.host());
            return cookies != null ? cookies : new ArrayList<Cookie>();
        }
    }
}

最后我们在看一下处理结果的回调

###（7）ObserverCallBack

public class ObserverCallBack<T> implements Observer<T> {

    private Disposable disposable;
    private Context mContext;
    private Handler mHandler;

    public ObserverCallBack(Context context, Handler handler) {
        this.mContext = context;
        this.mHandler = handler;
    }

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

    @Override
    public void onNext(T t) {
        Message msg = Message.obtain();
        msg.obj = t;
        msg.what = 1;
        mHandler.sendMessage(msg);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }

    public Disposable getDisposable() {
        return disposable;
    }
}

###（8）请求和处理结果的封装类

//请求封装类
public class PostParamsBean {

    //public int key;
    public int pno;
    public int ps;

}

//处理返回结果封装类
public class ResultBean {

    public String reason;
    public String error_code;
    public Result result;

    public static class Result {
        public int totalPage;
        public int ps;
        public int pno;

        public List<ResultList> list;
    }

    public static class ResultList {
        public String id;
        public String title;
        public String source;
        public String firstImg;
        public String mark;
        public String url;
    }

    @Override
    public String toString() {
        return "ResultBean{" +
                "reason='" + reason + '\'' +
                ", error_code='" + error_code + '\'' +
                ", result=" + result +
                '}';
    }
}

好啦，到此整个整个案例的代码就展示完全了，整个逻辑是：
请求–>RxJava–>Retrofit–>OkHttp–>CallBack处理