05）springcloud学习 熔断器 Hyxtrix 原理 rxjava Java响应式(反应式)编程

 

在介绍RxJava前，我们先聊聊响应式编程。那么什么是响应式编程呢？响应式编程是一种基于异步数据流概念的编程模式。
 数据流就像一条河：它可以被观测，被过滤，被操作，或者为新的消费者与另外一条流合并为一条新的流。

响应式编程的一个关键概念是事件。事件可以被等待，可以触发过程，也可以触发其它事件、

RxJava本质上是一个异步操作库，是一个能让你用极其简洁的逻辑去处理繁琐复杂任务的异步事件库。

RX 是一个使用可观察序列，来编写异步和基于事件的程序的库。它扩展了观察者模式以支持数据和/或事件序列，并添加允许您以声明方式将序列组合在一起的运算符，同时抽象出对诸如低级线程、同步、线程安全、并发数据结构和非 阻塞 I/O。

Hyxtrix 底层为什么要用RX

因为简洁、易用

rx流程
通过Observables创建事件流或数据流

通过操作符变换（转换、过滤、融合、聚合、条件、数学操作）数据流；

通过订阅执行（一种是在创建时就订阅，来一个处理一个，一种是先创建，发送数据，等最后一次订阅执行）

在RxJava中，一个实现了Observer接口的对象可以订阅 (subscribe) 一个Observable实例。订阅者(subscriber) 对 Observable 发出 (emit) 的任何数据或数据序列作出响应。这种模式简化了并发操作，因为它不需要阻塞等待Observable 发出的数据，而是创建了一个处于监听状态的观察者哨兵，哨兵在未来某个时刻响应Observable的通知。

在Rxjava中的事件回调方法

onSubscribe() 意思是当Observable被Observer 订阅的时候触发; 这个是官方说的Cold 方式

onNext() 迭代处理Observable发出的items，只要onCompleted 或onError触发就不再触发

onCompleted() 通知Observable已经完成处理，这个和onError() 是互斥的

onError() 事件异常时触发，触发以后整个流程终止

同时官方把把Observables分为hot 和cold

hot 是创建了Observable就开始发出items，后续再过来订阅这个的Observer收到的items可能不完整，所以想要完全消费，在创建Observable的时候就得订阅才能完整消费，类似于redis的发布订阅模式，发布的时候，你在线，你能消费，不在线永远不能消费；

cold 是先创建Observable，等到最后有订阅者了，Observable才会发出items，一个订阅消费一套，类似于kafka的广播模式，你什么时候来都可以从头消费（不要关注消息存储的时间）

查资料看的大牛写的代码，没接触过rxjava，看不懂...

RxjavaDemo.java

package com.wying.pesservice01.rxjava;

import org.junit.Test;
import rx.Notification;
import rx.Observable;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.functions.Func0;

/**
 * description:rxjava demo
 * date: 2022/1/11
 * author: gaom
 * version: 1.0
 */
public class RxjavaDemo {
    public static  void main(String[] args){
        new RxjavaDemo().demo();
    }

    /**
     * 模拟Hyxtrix的 run方法
     * @return
     * @throws Exception
     */
    protected String run() throws Exception {
        System.err.println(" run...并通过Observable.just包装成Observable");
        return "run success!";
    }
    private Observable<String> applyHystrixSemantics() {
        final Action1<String> markEmits = new Action1<String>() {
            @Override
            public void call(String r) {
                System.out.println("③ Observable doOnNext call, target: markEmits");
            }
        };
        final Action1<Notification<? super String>> setRequestContext = new Action1<Notification<? super String>>() {
            @Override
            public void call(Notification<? super String> rNotification) {
                System.out.println("③ Observable doOnEach call ,target:setRequestContext");
            }
        };
        return Observable.defer(new Func0<Observable<String>>() {
            @Override
            public Observable<String> call() {
                System.out.println("③ Observable is call ");
                return Observable.defer(new Func0<Observable<String>>() {
                    @Override
                    public Observable<String> call() {
                        System.out.println("④ Observable is call ");
                        return Observable.defer(new Func0<Observable<String>>() {
                            @Override
                            public Observable<String> call() {
                                try {
                                    System.out.println("⑤ Observable is call ");
                                    return  Observable.just(run());
                                } catch (Throwable ex) {
                                    return Observable.error(ex);
                                }
                            }
                        }).doOnSubscribe(new Action0() {
                            @Override
                            public void call() {
                                System.out.println("⑤ Observable doOnSubscribe is call 在 ⑤被订阅之前执行，一般用于修改、添加或者删除事件源的数据流");
                            }
                        });
                    }
                });
            }
        }).doOnTerminate(new Action0() {
            @Override
            public void call() {
                System.out.println("③ Observable doOnTerminate  is call ");
            }
        }).doOnNext(markEmits)
                .doOnEach(setRequestContext);
    }

    public void demo(){
        final Func0<Observable<String>> applyHystrixSemantics = new Func0<Observable<String>>() {
            @Override
            public Observable<String> call() {
                System.out.println("② Observable is call");
                return applyHystrixSemantics();
            }
        };
        final Action0 terminateCommandCleanup = new Action0() {

            @Override
            public void call() {
                System.out.println("② Observable doOnTerminate is call target:terminateCommandCleanup");
            }
        };
        final Action0 unsubscribeCommandCleanup = new Action0() {
            @Override
            public void call() {
                System.out.println("② Observable doOnUnsubscribe is call target:unsubscribeCommandCleanup");
            }
        };
        final Action0 fireOnCompletedHook = new Action0() {
            @Override
            public void call() {
                System.out.println("② Observable doOnCompleted  is call target:fireOnCompletedHook");
            }
        };
        System.out.println("demo execute");
        Observable defer= Observable.defer(new Func0<Observable<String>>() {

            @Override
            public Observable<String> call() {
                System.out.println("① Observable call");
                Observable<String> hystrixObservable =Observable.defer(applyHystrixSemantics);
                return hystrixObservable.doOnTerminate(terminateCommandCleanup)     // perform cleanup once (either on normal terminal state (this line), or unsubscribe (next line))
                        .doOnUnsubscribe(unsubscribeCommandCleanup) // perform cleanup once
                        .doOnCompleted(fireOnCompletedHook);
            }
        }).doOnCompleted(new Action0() {
            @Override
            public void call() {
                System.out.println("① Observable doOnCompleted is  call ");
            }
        }).doOnUnsubscribe(new Action0() {
            @Override
            public void call() {
                System.out.println("① Observable doOnUnsubscribe is call");
            }
        });
        //defer.toBlocking();
        //不通过toFuture 不会执行
        defer.toBlocking().toFuture();

    }
}

执行返回