RxJava基础练习（1）

//概念解释
//1:被观察者,事件源:它决定什么时候触发事件以及触发怎样的事件
//2:观察者:它决定事件触发的时候将有怎样的行为
//3:订阅
private void method0() {

    //1:被观察者,事件源
    //概念解释:RxJava 使用 Observable.create() 方法来创建一个 Observable ，并为它定义事件触发规则
    Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("Hello");
            subscriber.onNext("World");
            subscriber.onNext("!");
            subscriber.onCompleted();
            subscriber.onError(new Throwable());
            Logger.d("被观察者-observable->call()->onCompleted()之后是否还有输出");
        }
    });

    /**
     * 可以看到，这里传入了一个 OnSubscribe 对象作为参数。
     * OnSubscribe 会被存储在返回的 Observable 对象中，它的作用相当于一个计划表，
     * 当Observable 被订阅的时候，OnSubscribe 的 call() 方法会自动被调用，事件序列就会依照设定依次触发
     * （对于上面的代码，就是观察者subscriber 将会被调用三次 onNext() 和一次 onCompleted()）。
     * 这样，由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。
     */
    //2:观察者
    Observer<String> observer = new Observer<String>() {
        @Override
        public void onCompleted() {
            Logger.d("观察者-observer:onCompleted()");
        }

        @Override
        public void onError(Throwable e) {
            Logger.d("观察者-observer:onError" + e.getMessage());
        }

        @Override
        public void onNext(String s) {
            Logger.d("观察者-observer:onNext():" + s);

// getException();//故意让程序出现异常,用于测试onError()方法的执行….
}
};

    //3:订阅--被观察者被观察者订阅
    observable.subscribe(observer);
}


//---------------------------------------1:快捷创建事件队列 Observable.just(T...)--------------------------------------------------------------

// create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法， RxJava 还提供了一些方法用来快捷创建事件队列，
// 例如just(T...): 将传入的参数依次发送出来.

//简化:观察者的创建,RxJava快捷创建事件队列的方法:just(T...):

/**
 * 简化:观察者的创建
 * {@link #method0()}
 */
private void method1() {


    //实现步骤
    //1:被观察者:
    //2:观察者:
    //3:订阅-被观察者被观察者订阅


    //1:被观察者:
    //just(T...): 将传入的参数依次发送出来
    Observable<String> observable = Observable.just("Hello", "World", "!");
    // 将会依次调用：
    // onNext("Hello");
    // onNext("World");
    // onNext("!");
    // onCompleted();


    //2:观察者:
    Observer<String> observer = new Observer<String>() {
        @Override
        public void onCompleted() {
            Logger.d("观察者-observer:onCompleted()");
        }

        @Override
        public void onError(Throwable e) {
            Logger.d("观察者-observer:onError()");
        }

        @Override
        public void onNext(String s) {
            Logger.d("观察者-observer:onNext():" + s);
            // getException();//故意让程序出现异常,用于测试onError()方法的执行....
        }
    };

    //3:订阅:被观察者被观察者订阅
    observable.subscribe(observer);
}


//---------------------------------------2:快捷创建事件队列 Observable.from(T[]) / from(Iterable<? extends T>--------------------------------------------------------------

/**
 * 简化:观察者的创建: RxJava快捷创建事件队列的方法:just(String[] array) 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来
 * {@link #method1()}
 */
private void method2() {

    //实现步骤
    //1:被观察者
    //2:观察者
    //3:订阅-被观察者被观察者订阅


    String[] array = new String[]{"Hello", "World", "!"};
    //1:被观察者:
    //just(String[] array) 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。
    Observable observable = Observable.from(array);
    // 将会依次调用：
    // onNext("Hello");
    // onNext("World");
    // onNext("!");
    // onCompleted();


    //2:观察者
    Observer observer = new Observer() {
        @Override
        public void onCompleted() {
            Logger.d("观察者-observer:onCompleted()");
        }

        @Override
        public void onError(Throwable e) {
            Logger.d("观察者-observer:onError()");
        }

        @Override
        public void onNext(Object o) {
            String str = (String) o;
            Logger.d("观察者-observer:onNext():" + str);
           // getException();//故意让程序出现异常,用于测试onError()方法的执行....
        }
    };

    //3:订阅: 被观察者被观察者订阅
    observable.subscribe(observer);

}

//---------------------------------------3: subscribe()支持不完整定义的回调--------------------------------------------------------------

/**
 * 对观察者的简化
 * {@link #method2()}
 * subscribe一个参数的不完整定义的回调
 * subscribe(final Action1<? super T> onNext)
 */
private void method3() {

    String[] array = new String[]{"Hello", "World", "!"};
    //1:被观察者
    Observable observable = Observable.from(array);

    //2:观察者
    Action1 onNextAction = new Action1() {
        @Override
        public void call(Object o) {
            String str = (String) o;
            Logger.d("观察者:call(Object o):" + str);
        }
    };

    //3:订阅-被观察者被观察者订阅
    //subscribe(final Action1<? super T> onNext)
    //自动创建 Subscriber ，并使用 onNextAction 来定义 onNext()
    observable.subscribe(onNextAction);
}

/**
 * 对观察者的简化
 * subscribe两个参数的不完整定义的回调
 * {@link #method3()}
 * subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError)
 */
private void method4() {

    //1:被观察者
    Observable observable = Observable.from(new String[]{"Hello", "World", "!"});

    //2:观察者
    Action1 onNextAction = new Action1() {
        @Override
        public void call(Object o) {
            String str = (String) o;
            Logger.d("观察者:onNextAction:call(Object o):o:" + str);
        }
    };


    Action1<Throwable> onErrorAction = new Action1<Throwable>() {
        @Override
        public void call(Throwable throwable) {
            Logger.d("观察者:onErrorAction:call(Throwable throwable):" + throwable.getMessage());
        }
    };


    //3:订阅
    //subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError)
    // 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()
    observable.subscribe(onNextAction, onErrorAction);


}

/**
 * subscribe三个参数的不完整定义的回调
 * subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete)
 */
private void method5() {
    //1:被观察者
    Observable observable = Observable.from(new String[]{"Hello", "World", "!"});


    //2:观察者
    Action1 onNextAction = new Action1() {
        @Override
        public void call(Object o) {
            String str = (String) o;
            Logger.d("观察者:onNextAction:call():s:" + str);
        }
    };


    Action1<Throwable> onErrorAction = new Action1<Throwable>() {
        @Override
        public void call(Throwable throwable) {
            Logger.d("观察者:onErrorAction:call(Throwable throwable):" + throwable.getMessage());
        }
    };


    Action0 onCompletedAction = new Action0() {
        @Override
        public void call() {
            Logger.d("观察者:onCompletedAction:call()");
        }
    };


    //3:订阅:被观察者被观察者订阅

    //subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete)
    // 自动创建 Subscriber ，并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()
    observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

}