RxJava基础知识

前言:之前一直有听过RxJava，但是从来没去用过也没了解过，所以打算全面了解学习下这个比较流行前言的框架，本篇主要是讲解RxJava的基础知识，记录一下api使用，以后查看方便。

解释：RxJava 是一个 基于事件流、实现异步操作的库.

特点：由于 RxJava的使用方式是：基于事件流的链式调用，所以使得 RxJava： 逻辑简洁、实现优雅、使用简单。更重要的是，随着程序逻辑的复杂性提高，它依然能够保持简洁 & 优雅

原理介绍：

角色	作用	对比
被观察者（Observable）	产生事件的源头	顾客产生事件要吃饭，点菜
观察者（Observer）	接收事件处理	厨房接受顾客点的菜
订阅(Subscribe)	连接被观察者和观察者的桥梁	服务员把顾客点的菜给厨房
事件(Event)	被观察者和观察者之间的媒介	菜式

即RxJava原理可总结为：被观察者 （Observable） 通过 订阅（Subscribe） 按顺序发送事件 给观察者 （Observer）， 观察者（Observer） 按顺序接收事件 & 作出对应的响应动

1.首先怎么创建一个被观察者 & 生产事件，最简单的实现：

//创建了一个Observable被观察者通过e.onNext(1);e.onNext(2);e.onNext(3);来发送事件1，2，3

Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        })
        
 //也可以通过其他方式来创建，下篇文章我会详细讲解下具体的api来创建被观察者       
 //组合方式
 Observable.mergeArray(
                Observable.intervalRange(0,3,1,1,TimeUnit.SECONDS),
                Observable.intervalRange(3,3,1,1,TimeUnit.SECONDS),
                Observable.intervalRange(6,3,1,1,TimeUnit.SECONDS),
                Observable.intervalRange(6,3,1,1,TimeUnit.SECONDS)).subscribe(new Consumer() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.d(TAG, "接收到了事件"+ aLong);
            }
        })
//just(T...)：直接将传入的参数依次发送出来 
Observable.just(1,2,3,4).reduce(new BiFunction() {
            @Override
            public Integer apply(Integer integer, Integer integer2) throws Exception {
                Log.e(TAG, "本次计算的数据是： "+integer2 +"  乘 "+ integer);
                return integer*integer2;
            }
        })        
        

2.创建观察者（observer）来接受响应事件,具体的也是有很多api

//方式一：使用直接new observer接口的方式，
new Observer() {
            //该方法是在observer接收事件之前，最先回调回来的
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG,"onSubscribe 线程: "+Thread.currentThread().getName());
            }
              //该方法是在被观察者发送onNext事件时，接收的事件回调，做出响应
            @Override
            public void onNext(String s) {
                Log.d(TAG,"onNext 线程: "+Thread.currentThread().getName());

            }
              //该方法是在被观察者发送onError事件时，接收的事件回调，做出响应
            @Override
            public void onError(Throwable e) {
                Log.d(TAG,"onError 线程: "+Thread.currentThread().getName());
            }
              //该方法是在被观察者发送onComplete事件时，接收的事件回调，做出响应
            @Override
            public void onComplete() {
                Log.d(TAG,"onComplete 线程: "+Thread.currentThread().getName());
            }
        })

//方式二:使用直接new Consumer接口的方式，
new Consumer() {
             //accept是接收回调的事件响应
           @Override
           public void accept(Integer integer) throws Exception {
               Log.d(TAG,"结果： "+integer);
           }
       })
       

3.订阅(subscribe)链接被观察者和观察者之间的桥梁

observable.subscribe(observer);

4.基于上面的知识点我们下面来具体创建一个工程来编写下具体的代码

4.1.首先在app的build.gradle文件中加入如下依赖：

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

4.2.创建一个Activity类，来编写代码

/**
 * wuminjian 2018.4.27
 */
public class MainTwoActivity extends Activity {
    public static final String TAG = "MainTwoActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.layout_dianzhan11111);
        AppSettings.getInstance(MainTwoActivity.this);

        testRxJava();
    }

    private void testRxJava() {
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                //在这个方法里面开始向外发射事件
                e.onNext("hello");
                e.onNext("RxJava");
                e.onComplete();
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(String s) {
                Log.d(TAG,"接收结果："+s);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }
}

打印结果

04-26 19:58:53.100 11189-11189/? D/MainTwoActivity: 开始采用subscribe连接
04-26 19:58:53.100 11189-11189/? D/MainTwoActivity: 接收结果：hello
04-26 19:58:53.100 11189-11189/? D/MainTwoActivity: 接收结果：RxJava
04-26 19:58:53.100 11189-11189/? D/MainTwoActivity: 对Complete事件作出响应

看以上代码RxJava代码是不是一条链式下来的模式，结构很清晰，优雅。以上主要介绍下RxJava的基本知识和具体简单的使用，下篇文章将介绍下具体的api使用详解。