RxJava结合Retrofit实现的网络请求(Observable被观察者和 Subscriber观察者)

1.1、先导入依赖：    compile 'io.reactivex:rxjava:1.0.14'
                   compile 'io.reactivex:rxandroid:1.0.1'
1.2、简单理解：

  a.是一个异步操作，在子线程更改数据，在主线程做更新操作。

  b.被观察者是事件的产生方相当于子线程，观察者是消费者相当于主线程；
  他们是通过订略的方式进行连接。

  c.观察者 与 被观察者
观察者：Subscriber
    一般作用于 V层，负责接收 被观察者 传递过来的信息

被观察者：Observable 
    一般作用于 M层，负责发送 信息给 观察者

一、MainActivity的主方法

public class MainActivity extends AppCompatActivity {

    private TextView tv;

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

        tv = (TextView) findViewById(R.id.main_tv);
        /**
         * 初始化 观察者
         */
        Subscriber<String> subscriber = new Subscriber<String>() {

            /**
             * 完成回调方法
             */
            @Override
            public void onCompleted() {

            }

            /**
             * 错误回调方法
             * @param e
             */
            @Override
            public void onError(Throwable e) {

            }

            /**
             * 接收并处理回调方法
             * @param s
             */
            @Override
            public void onNext(String s) {
                tv.setText(s);
            }
        };

        OkHttps.getData(subscriber);

    }
}

二、被观察者的方法

/**
 * 网络请求类
 */
public class OkHttps {

    private static final String TAG="okhttps";

    /**
     * 网络请求网址
     */
    private static final String PATHS="http://api.expoon.com/AppNews/getNewsList/";

    public static void getData(final Subscriber subscriber){

        /**
         * 实例化 Retrofit对象
         * 构建者方法创建对象 链表式创建方法
         */
        /**
         * 添加 拦截器
         */
        OkHttpClient client = new OkHttpClient.Builder().addNetworkInterceptor(new iii()).build();

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(PATHS)
                .client(client)
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        /**
         * 实例化 接口对象
         */
        DataService dataService = retrofit.create(DataService.class);

        /**
         * 调用 接口中的方法
         * 请求网络 并返回Call集合
         */
        Call<RsBean> data = dataService.getData();

        /**
         * 开始请求 将数据放入集合
         */
        data.enqueue(new Callback<RsBean>() {
            @Override
            public void onResponse(Call<RsBean> call, final Response<RsBean> response) {
                Log.i(TAG, "onResponse: "+response.body().toString());
                /**
                 * 创建 被观察者
                 * 其作用发送消息给观察者
                 */
                Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        /**
                         * 发送消息给观察者
                         */
                        subscriber.onNext(response.body().toString());
                        subscriber.onCompleted();
                    }
                });

                /**
                 * 绑定 观察者 与 被观察者
                 */
                observable.subscribe(subscriber);
            }

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

            }
        });

    }

    //设置插值器（拦截器）
    static class iii implements Interceptor {
        @Override
        public okhttp3.Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Headers headers = request.headers();
            for (int i = 0; i < headers.size(); i++) {
                String name = headers.name(i);
                String value = headers.value(i);
                Log.i(TAG, "intercept: " + "name=" + name + "  " + value);

            }
            okhttp3.Response response = chain.proceed(request);
            return response;
        }


    }
}