JavaFx使用RxJava套餐（九）
JavaFx从入门到入土系列
我们知道，在子线程中无法更新UI的，可以使用Platform.runLater(command);将执行的事件发往主线程更新UI。
那么问题来了，我们异步请求服务器怎么处理？
假设如下场景：在UI中显示服务上线进度
那么你的代码可能是这样
public class JavaFxDemo extends Application {
@Override
public void start(Stage stage) throws Exception {
// 定义一个标签，类似html中的span
Label label = new Label("hello world!");
// 将标签加入场景，场景类似 HTML中的 body， 将span放到body中
// 将场景放到stage中，类似HTML 中的将 body 放到 html标签里一样
stage.setScene(new Scene(label));
// 设置舞台的宽高标题
stage.setWidth(400);
stage.setHeight(100);
stage.setTitle("师姐，你好！");
stage.show();
new Thread(new Runnable() {
@Override
public void run() {
while (true){
try {
// http 同步请求获取服务上线进度
int info= HttpRequest.userClient.getUpInfo();
Platform.runLater(new Runnable() {
@Override
public void run() {
label.setText("上线服务完成："+info+" %");
}
});
if (info>=100){
break;
}
} catch (Exception e) {
e.printStackTrace();
label.setText("获取进度异常");
break;
}
}
}
}).start();
}
public static void main(String[] args) {
launch(args);
}
}
那么是否可以使用观察者模式来执行呢？这时就用到了RxJava全家桶系列了。
RxJava
首先引入依赖：2021年9月19日22:58:37 最新版 RxJava 2.x
<dependency>
<groupId>io.reactivex.rxjava2</groupId>
<artifactId>rxjava</artifactId>
<version>2.2.21</version>
</dependency>
那么代码就改成了下面这样
// 被观察者对象
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
while (true){
int info= HttpRequest.userClient.getUpInfo();
emitter.onNext(info);
if (info>=100){
emitter.onComplete();
break;
}
}
}
}).subscribeOn(Schedulers.io()) //在子线程发射
.observeOn(Schedulers.from(new Executor() {
@Override
public void execute(Runnable command) {
// 将线程执行发往主线程更新UI
Platform.runLater(command);
}
})) //在主线程接收执行更新UI
.subscribe(new Observer<Integer>() {// 观察对象
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
label.setText("上线服务完成："+integer+" %");
}
@Override
public void onError(Throwable e) {
label.setText("获取进度异常");
}
@Override
public void onComplete() {
}
});
你会疑问，代码变多了。
好吧，我们可以对观察者模式进行进一步封装：
new RxObservableUtils(new ByWatch() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
while (true) {
// http 同步请求获取服务上线进度
int info = HttpRequest.userClient.getUpInfo();
emitter.onNext(info);
if (info >= 100) {
emitter.onComplete();
break;
}
}
}
}).watch(new Watch() {
@Override
public void onNext(Object o) {
label.setText("上线服务完成：" + o + " %");
}
@Override
public void onError(Throwable e) {
e.printStackTrace();
label.setText("获取进度异常");
}
});
封装后代码易于理解，特别是要处理业务复杂时
import io.reactivex.Observable;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.schedulers.Schedulers;
import javafx.application.Platform;
import java.util.concurrent.Executor;
/**
* @author lingkang
* @date 2021/9/19 23:06
* @description
*/
public class RxObservableUtils<T> {
private Observable<T> observable;
public RxObservableUtils(ObservableOnSubscribe<T> subscribe, Watch<T> watch) {
Observable.create(subscribe)
.subscribeOn(Schedulers.io()) //在子线程中执行
.observeOn(Schedulers.from(new Executor() {
@Override
public void execute(Runnable command) {
// 将线程执行发往主线程更新UI
Platform.runLater(command);
}
}))//在主线程接收执行更新UI
.subscribe(watch);
}
public RxObservableUtils(ObservableOnSubscribe<T> subscribe, Observer<T> observer) {
Observable.create(subscribe)
.subscribeOn(Schedulers.io()) //在子线程中执行
.observeOn(Schedulers.from(new Executor() {
@Override
public void execute(Runnable command) {
// 将线程执行发往主线程更新UI
Platform.runLater(command);
}
}))//在主线程接收执行更新UI
.subscribe(observer);
}
public RxObservableUtils(ObservableOnSubscribe<T> subscribe) {
observable = Observable.create(subscribe)
.subscribeOn(Schedulers.io()) //在子线程中执行
.observeOn(Schedulers.from(new Executor() {
@Override
public void execute(Runnable command) {
// 将线程执行发往主线程更新UI
Platform.runLater(command);
}
}));//在主线程接收执行更新UI
}
public RxObservableUtils(ByWatch<T> byWatch) {
observable = Observable.create(byWatch)
.subscribeOn(Schedulers.io()) //在子线程中执行
.observeOn(Schedulers.from(new Executor() {
@Override
public void execute(Runnable command) {
// 将线程执行发往主线程更新UI
Platform.runLater(command);
}
}));//在主线程接收执行更新UI
}
public RxObservableUtils watch(Watch<T> w) {
observable.subscribe(w);
return this;
}
}
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
public class ByWatch<T> implements ObservableOnSubscribe<T> {
@Override
public void subscribe(ObservableEmitter<T> emitter) throws Exception {
}
}
继承后按需取用
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class Watch<T> extends toWatch<T> {
}
class toWatch<T> implements Observer<T> {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(T t) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
}