Rxjava2-响应式编程

Rxjava2-响应式编程

基于ObServer(观察者)设计模式 + 异步处理

观察者模式：

​ 在一个事件源上有一系列的观察者，当事件源触发某一个事件时，会向所有观察者传递信号，具体的观察者会做出具体的响应。

别名：

• ​ObServer（观察者模式）
• Listener（监听器）
• Hook(钩子函数)
• Callback(回调函数)
  

Rxjava2

Observable 是一个事件源，会产生各种各样的事件。

订阅者Observer和消费者Consumer在Observable 产生新的事件时会同步/异步触发对应的动作。

在pom.xml中加入

<!-- https://mvnrepository.com/artifact/io.reactivex.rxjava2/rxjava -->
<dependency>
    <groupId>io.reactivex.rxjava2</groupId>
    <artifactId>rxjava</artifactId>
    <version>2.2.18</version>
</dependency>

常规写法：

package demo;

import io.reactivex.*;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

/**
 * @program: demo
 * @description: Rxjava入门学习
 * @author: liushao
 * @create: 2020-03-12 11:12
 **/
public class Rxdemo {
     
    public static void main(String[] args) {
     

        /**
         *  声明一个产生String类型事件的事件源对象 Observable observable
         */
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
     

            @Override

            /**
             * 事件源对象产生具体事件由此方法指定
             * emitter 事件产生器
             */
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
     
                emitter.onNext("2020-03-12");
                emitter.onNext("编写");
                emitter.onNext("第一个响应式编程demo");
            }
        });

        /**
         * 创建一个消费者consumer 来消费事件
         */
        Consumer<String> consumer = new Consumer<String>() {
     
            @Override
            public void accept(String s) throws Exception {
     
                System.out.println(Thread.currentThread().getName() + " == consumer == "+ s);
            }
        };

        //同步消费
        observable.subscribe(consumer);
        //异步消费 使用observeOn 指定一个新的线程来执行consumer
        observable.observeOn(Schedulers.newThread()).subscribe(consumer);

        Observer<String> observer = new Observer<String>() {
     
            @Override
            public void onSubscribe(Disposable disposable) {
     

            }

            @Override
            public void onNext(String s) {
     
                System.out.println(Thread.currentThread().getName() + " == observer == "+ s);
            }

            @Override
            public void onError(Throwable throwable) {
     

            }

            @Override
            public void onComplete() {
     

            }
        };

        //同步订阅
        observable.subscribe(observer);
        //异步订阅 使用observeOn 指定一个新的线程来执行observer
        observable.observeOn(Schedulers.newThread()).subscribe(observer);
    }
}

链式编程写法：

package demo;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

/**
 * @program: demo
 * @description: Rxjava入门学习 链式编程写法
 * @author: liushao
 * @create: 2020-03-12 11:12
 **/
public class Rxdemo1 {
     
    public static void main(String[] args) {
     

        /**
         *  声明一个产生String类型事件的事件源对象 Observable observable
         */
        Observable.create(new ObservableOnSubscribe<String>() {
     

            @Override

            /**
             * 事件源对象产生具体事件由此方法指定
             * emitter 事件产生器
             */
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
     
                emitter.onNext("2020-03-12");
                emitter.onNext("编写");
                emitter.onNext("第一个响应式编程demo");
            }
        }).subscribe(new Consumer<String>() {
     
            @Override
            public void accept(String s) throws Exception {
     
                System.out.println(Thread.currentThread().getName() + " == consumer == "+ s);
            }
        });
    }
}