reactive streaming

Reactive Streaming : 可背压的异步数据流规范，，，是一套异步流式处理+ 背压（backpressure）机制的规范，，是一套接口标准：

Publisher
Subscriber
Subscription
Processor<T,R> : 数据转换器

消费者控制节奏：由Subscriber订阅者决定要多少数据，，，Publisher只能发被请求的数量，，通过中间的Subscription控制, 数据可以通过Processor进行转换过滤

基于Reactive Streaming 规范实现的有：

java9中的Flow
RxJava
spring webflux

等

接口：

java 复制代码

public interface Publisher<T> {


    void subscribe(Subscriber<? super T> subscriber);
}

java 复制代码

public interface Subscriber<T> {


    void onSubscribe(Subscription subscription);


    void onNext(T t);

    void onError(Throwable t);
    void onComplete();
}

java 复制代码

public interface Subscription {


    void request(long n);

    void cancel();
}

java 复制代码

public interface Processor<T,R> extends Subscriber<T>,Publisher<R>{



}

实现类：

java 复制代码

package com.cj;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

public class SimplePublisher implements Publisher<Integer>{

   private final int max;
   private Subscription subscription;

    public SimplePublisher(int max) {
        this.max = max;
    }


    @Override
    public void subscribe(Subscriber<? super Integer> subscriber) {
//        this.subscriber = subscriber

       Subscription subscription =  new SimpleSubscription(subscriber,max);
       subscriber.onSubscribe(subscription);

       this.subscription = subscription;
    }


    public void publish(long n){
            this.subscription.request(n);
    }



    static class SimpleSubscription implements Subscription{

        private final Subscriber<? super Integer> subscriber;

        private final int max;

        private AtomicLong requested = new AtomicLong(0);
        private AtomicInteger current = new AtomicInteger(1);

        SimpleSubscription(Subscriber<? super Integer> subscriber, int max) {
            this.subscriber = subscriber;
            this.max = max;
            start();
        }




        @Override
        public synchronized void request(long n) {
            requested.addAndGet(n);

            notify();
        }

        private void start(){
            new Thread(()->{

                synchronized (this){
                    while(true){

                        if (requested.get() == 0){
                            try {
                                wait();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }




                        requested.getAndDecrement();



                        subscriber.onNext(current.getAndIncrement());


                        if (current.get() > max){
                            subscriber.onComplete();
                            break;
                        }


                    }
                }


            }).start();
        }

        @Override
        public void cancel() {

        }
    }
}

java 复制代码

package com.cj;

public class SimpleSubscriber implements Subscriber<Integer>{

    private Subscription subscription;

    private int count = 0;
    @Override
    public void onSubscribe(Subscription subscription) {
        this.subscription = subscription;
    }

    @Override
    public void onNext(Integer item) {

        System.out.println("消费了:"+item);

        count++;

        if (count % 3 == 0){
            System.out.println("3的倍数。。。。。");
            subscription.request(3);
        }

    }

    @Override
    public void onError(Throwable t) {

    }

    @Override
    public void onComplete() {


        System.out.println("请求完了");
    }
}

java 复制代码

package com.cj;

import java.util.function.Function;

public class MyProcessor implements Processor<Integer,Integer>{
    Function<Integer,Integer> func = (a)->a*2;

    Subscription upStream;
    Subscriber<? super Integer> downStream;

    @Override
    public void subscribe(Subscriber<? super Integer> subscriber) {

        Subscription subscription = new Subscription() {
            @Override
            public void request(long n) {
                upStream.request(n);
            }

            @Override
            public void cancel() {
                upStream.cancel();
            }
        };

        this.downStream = subscriber;
        subscriber.onSubscribe(subscription);

    }

    @Override
    public void onSubscribe(Subscription subscription) {
        this.upStream = subscription;
    }

    @Override
    public void onNext(Integer item) {
        Integer mapped = func.apply(item);
        this.downStream.onNext(mapped);
    }

    @Override
    public void onError(Throwable t) {

    }

    @Override
    public void onComplete() {

    }
}

测试:

java 复制代码

public class Main {
    public static void main(String[] args) {


        SimplePublisher publisher = new SimplePublisher(10);

        MyProcessor myProcessor = new MyProcessor();
        SimpleSubscriber subscriber = new SimpleSubscriber();

        publisher.subscribe(myProcessor);
        myProcessor.subscribe(subscriber);

        publisher.publish(3);
    }
}