写个hello world了解Rxjava

目录

• 什么是Rxjava？
  • 在微服务中的优点
• 上手使用
  • 引入依赖
  • 浅谈分析Rxjava中的被观察者，观察者

spring boot 项目中使用Rxjava2

什么是Rxjava？

来自百度百科的解释

RxJava - JVM响应式扩展Reactive Extensions 用于使用Java VM的可观察序列编写异步和基于事件的程序的库。

ReactiveX是一个通过使用可观察序列来编写异步和基于事件的程序的库。

它扩展了观察者模式以支持数据和/或事件序列，并增加了运算符，使您可以声明性地组合序列，同时抽象出对低级线程，同步，线程安全性，并发数据结构和非线程等事物的关注阻塞I / O。

在微服务中的优点

隔离每个服务，即使单个服务的响应失败了，也不会影响整个请求的响应。

上手使用

引入依赖

Rxjava 的版本：https://mvnrepository.com/artifact/io.reactivex.rxjava2/rxjava

本次采用最新的2.2.2版本

<dependency>

    <groupId>io.reactivex.rxjava2</groupId>

    <artifactId>rxjava</artifactId>

    <version>2.2.2</version>

</dependency>

在spring boot中引入依赖后就可以使用Rxjava了，下面通过写一组hello world来看看Rxjava的基本原理。

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.annotations.NonNull;
import io.reactivex.functions.Consumer;

public class Test {
    public static void main(String[] args) {
        //first
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> observableEmitter) throws Exception {
                observableEmitter.onNext("Hello World");
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println(s);
            }
        });
        //second
        System.out.println("------------------------------------");
        Observable.just("hello world").subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                System.out.println(s);
            }
        });
        //third
        System.out.println("------------------------------------");
        Observable.just("hello world").subscribe(System.out :: println);
    }
}

输出信息：

Rxjava 使用三步走

• 创建被观察者（Observable）
• 创建观察者（Observer）
• 订阅（subscribe）

浅谈分析Rxjava中的被观察者，观察者

第一种写法通过create来创建一个观察者，而第二种第三种直接通过just方法来快速创建一个观察者

Observable.create(new ObservableOnSubscribe<String>() {})
Observable.just()

查看源码：

//create方法
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
//just方法
public static <T> Observable<T> just(T item) {
    ObjectHelper.requireNonNull(item, "The item is null");
    return RxJavaPlugins.onAssembly(new ObservableJust(item));
}
显而易见两者方法最终的实现都是一样的，只不过是哪个写法更简洁点；本次只是入门级的了解，更深层次的源码研究放到之后。

从源码来看subscribe()方法，可以看出有多个重载方法。下面我们具体说下Observable相关的内容

上面的“hello world”案例是通过subscribe(Constumer<? super T> onNext)这个重载方法写的，下面是通过

subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)，

subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable>两种写法

subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)方法：
Observable.just("hello world!")
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                //首先执行该方法，也就是onNext
                System.out.println(s);
                //当抛出异常时会走到onError方法，action方法不会再执行
                //throw new Exception("error");
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                //当onNext发生异常时，此方法才会被执行
                System.out.println(throwable.getMessage());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //该方法是执行onNext之后执行的
                System.out.println("onComplete");
            }
        });

subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable>方法
Observable.just("hello world!")
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println(s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                System.out.println(throwable.getMessage());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                System.out.println("onComplete");
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                System.out.println("onSubscribe");
            }
        });
打印结果：
onSubscribe
hello world !
onComplete

因为我们使用的Rxjava2的版本，所以我们需要使用Observer作为观察对象，我们针对上面的写法，再次优化

Observable.just("hello world!")
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable disposable) {
                System.out.println("onSubscribe");
            }

            @Override
            public void onNext(@NonNull String s) {
                System.out.println("onNext");
            }

            @Override
            public void onError(@NonNull Throwable throwable) {
                System.out.println("onError");
            }

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        });
打印信息：
onSubscribe
onNext - > hello world!
onComplete

所以，通过上面的几种“hello world”的写法，我们知道被观察者，观察者，subscribe()三者缺一不可，

只有使用了订阅（也就是subscribe（）方法），被观察才会发送数据

～～～～～～～Rxjava入门继续学习中～～～～～～～～