反应式编程(Reactive)

一、反应式编程概述

        异步非阻塞架构，具有低延迟、高吞吐量工作负载的特性

        Srping Reactive官网：Spring | Reactive

        反应式宣言：反应式宣言

   

二、Reactor Stream 反应式流

1、Reactive Stream、Reactor与Webflux三者的关系

        Reactor Stream 是反应式编程的规范 （https://www.reactive-streams.org/）        

        Reactor是规范的具体实现

        WebFlux是以Reactor为基础的Web应用的反应编程式框架

2、Reactive Stream核心思想以及异步流处理模式

核心思想是让发布者（Publisher）和订阅者（Subscriber）之间进行异步流处理，以实现非阻塞的响应式应用程序

Producer ->SubScriber模式

Producer ->Processer->SubScriber 模式

3、Reactor Stream API详解

public static interface Publisher<T> {
    //发布者与订阅者建立关系
    public void subscribe(Subscriber<? super T> subscriber);
}

public static interface Subscriber<T> {
    //建立关系时
    public void onSubscribe(Subscription subscription);
    //接收数据
    public void onNext(T item);
        
    public void onError(Throwable throwable);

    public void onComplete();
}

public static interface Subscription {
    //请求n条数据
    public void request(long n);
    //取消数据
    public void cancel();
}

public static interface Processor<T,R> extends Subscriber<T>, Publisher<R> {
//即是发布者也是订阅者
}

三、Reactive Stream消息订阅模式实现

  3.1 Producer -> SubScriber模式

//模式1 Producer->Subscriber

public class ReactiveStreamDemo {
    public static void main(String[] args) throws InterruptedException {
        //1、创建一个发布者
        SubmissionPublisher publisher = new SubmissionPublisher();

        //2、创建一个订阅者
        Flow.Subscriber<String> subscriber = new Flow.Subscriber<String>(){
            Flow.Subscription subscription;
            @Override
            public void onSubscribe(Flow.Subscription subscription) {
                System.out.println("onSubscribe 建立订阅关系");
                this.subscription = subscription;
                //第一此需求
                subscription.request(1);
            }

            @Override
            public void onNext(String item) {
                System.out.println("onNext 接受数据:" + item);
                //业务处理
                //背压
                this.subscription.request(1);
            }

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

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        };

        //3.建立订阅关系
        publisher.subscribe(subscriber);

        //4.发送数据
        for(int i=0;i<5;i++){
            publisher.submit("发送数据,NO:"+i);
        }


        Thread.currentThread().join(1000);
    }
}

 3.2 Producer ->Processer->SubScriber模式

//模式2：Publisher->Processer->Subscriber

//创建Processer
public class ReactiveProcessor extends SubmissionPublisher<String> implements Flow.Processor<String,String> {
    private Flow.Subscription subscription;
    @Override
    public void onSubscribe(Flow.Subscription subscription) {
        System.out.println("producer与processor 建立定于关系");
        this.subscription = subscription;
        this.subscription.request(1);
    }

    @Override
    public void onNext(String item) {
        System.out.println("processor 接受数据："+item);
        //中间处理
        this.submit(item.toUpperCase());//将数据发给订阅者
        //背压实现的核心
        this.subscription.request(1);

    }

    @Override
    public void onError(Throwable throwable) {
        System.out.println("processor 异常："+throwable.getLocalizedMessage());
        this.subscription.cancel();
    }

    @Override
    public void onComplete() {
        System.out.println("onComplete");

    }
}

public class ReactiveStream4ProcessorDemo {
    public static void main(String[] args) throws InterruptedException {
        //1、创建一个发布者
        SubmissionPublisher publisher = new SubmissionPublisher();
        //2、创建一个处理器
        ReactiveProcessor processor = new ReactiveProcessor();
        //3、发布者与处理器建立订阅关系
        publisher.subscribe(processor);

        //4、创建一个订阅者
        Flow.Subscriber<String> subscriber = new Flow.Subscriber<String>(){
            Flow.Subscription subscription;
            @Override
            public void onSubscribe(Flow.Subscription subscription) {
                System.out.println("processor与subscriber 建立订阅关系");
                this.subscription = subscription;
                //第一此需求
                subscription.request(1);
            }

            @Override
            public void onNext(String item) {
                System.out.println("subscriber 接受数据:" + item);
                //业务处理
                //背压
                this.subscription.request(1);
            }

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

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        };

        //5、中间处理器与订阅者建立关系
        processor.subscribe(subscriber);

        //6.发送数据
        for(int i=0;i<5;i++){
            publisher.submit("发送数据V2,NO:"+i);
        }


        Thread.currentThread().join(1000);
    }
}