RxJava2 + Retrofit2 + Okhttp3

首先导入包：

    compile 'io.reactivex.rxjava2:rxjava:2.0.7'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'
    compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
    compile 'com.google.code.gson:gson:2.8.2'

package com.example.fly.myapplication.Rx.API;

import java.util.TreeMap;
import io.reactivex.Observable;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.http.Field;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.POST;

public interface ApiService {

    @FormUrlEncoded
    @POST("/xxx/ee")
    Observable<ResponseBody> login(@FieldMap TreeMap<String,String> map);

    @FormUrlEncoded
    @POST("/xxx/ee")
    Call<ResponseBody> post(@Field("userId") String userId);

    @GET("/xxx/ee")
    Observable<ResponseBody> register(@QueryMap TreeMap<String,String> map);

}

package com.example.fly.myapplication.Rx;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import com.example.fly.baselibrary.utils.useful.LogUtil;
import com.example.fly.myapplication.R;
import com.example.fly.myapplication.Rx.API.ApiService;

import java.util.TreeMap;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;

public class RxBaseActivity extends AppCompatActivity {
    private static final String TAG = RxBaseActivity.class.getSimpleName();
    private Disposable subscribe;

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

        // 最简单的同步线程中使用的案例
        Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> e) throws Exception {
                e.onNext("你好");
//                e.onError(new Throwable());
                LogUtil.e(TAG,"subscribe   当前线程 = " + Thread.currentThread().getName());
            }
        })
                .subscribeOn(Schedulers.newThread())   // 上游（被观察者）的线程
                .observeOn(Schedulers.newThread())     // 下游 （观察者）的线程
                .subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {    // 永远的主线程
                LogUtil.e(TAG,"onSubscribe   当前线程 = " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Object o) {
                LogUtil.e(TAG,"onNext   当前线程 = " + Thread.currentThread().getName() + "  值 = " + o);
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.e(TAG,"onError 当前线程 = " + Thread.currentThread().getName() + "  值 = " + e);
            }

            @Override
            public void onComplete() {
                LogUtil.e(TAG,"onComplete   当前线程 = " + Thread.currentThread().getName());
            }
        });

        initRequest();
        request();
        getRequest();
    }

    private void request() {
        ApiService apiService = new Retrofit.Builder()
                .baseUrl("http://xxx.cc.com/")
                .build()
                .create(ApiService.class);
        Call<ResponseBody> post = apiService.post("111111");
        post.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try{
                    ResponseBody body = response.body();
                    assert body != null;
                    LogUtil.e(TAG," 接口返回值= " + body.string().trim());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {

            }
        });
    }

    // RxJava的网络请求
    private void initRequest() {
        ApiService apiService = new Retrofit.Builder()
                .baseUrl("http://xxx.cc.com/")
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())     // RxJava结合网络请求必须加的
                .build()
                .create(ApiService.class);

        TreeMap<String,String> map = new TreeMap<>();
        map.put("userId","111111");
        Observable<ResponseBody> login = apiService.login(map);
        subscribe = login.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<ResponseBody>() {
                    @Override
                    public void accept(ResponseBody responseBody) throws Exception {
                        String trim = responseBody.string().trim();
                        LogUtil.e(TAG, " 接口返回参数 = " + trim);
                    }
                });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (subscribe != null && !subscribe.isDisposed()) {
            subscribe.dispose();  // 防止内存泄露
        }
    }

    public void getRequest() {
        ApiService apiService = new Retrofit.Builder()
                .baseUrl("http://xxx.cc.com/")
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build()
                .create(ApiService.class);

        TreeMap<String, String> map = new TreeMap<>();
        map.put("userId","111111");
        Observable<ResponseBody> register = apiService.register(map);
        register.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<ResponseBody>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(ResponseBody responseBody) {
                        try {
                            String trim = responseBody.string().trim();
                            LogUtil.e(TAG,"接口返回数据trim = " + trim);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

}