写个hello world了解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入门继续学习中～～～～～～～～
