JDK9新特性 Reactive Stream 響應式流

?本篇主要講解 JDK9特性 Reactive Stream 響應式流，介紹 Reactive Stream是什么背壓是什么，以及JDK9中提供的關于Reactive Stream的接口和 2個使用案例包括如何使用Processor。

?1.Reactive Stream 概念

?Reactive Stream (響應式流/反應流) 是JDK9引入的一套標準，是一套基于發布/訂閱模式的數據處理規范。響應式流從2013年開始，作為提供非阻塞背壓的異步流處理標準的倡議。它旨在解決處理元素流的問題——如何將元素流從發布者傳遞到訂閱者，而不需要發布者阻塞，或訂閱者有無限制的緩沖區或丟棄。更確切地說，Reactive流目的是“找到最小的一組接口，方法和協議，用來描述必要的操作和實體以實現這樣的目標：以非阻塞背壓方式實現數據的異步流”。

?反應式流 (Reactive Stream) 規范誕生，定義了如下四個接口：

Subscription 接口定義了連接發布者和訂閱者的方法
Publisher<T> 接口定義了發布者的方法
Subscriber<T> 接口定義了訂閱者的方法
Processor<T,R> 接口定義了處理器

?Reactive Stream 規范誕生后，RxJava 從 RxJava 2 開始實現 Reactive Stream 規范，同時 Spring提供的Reactor 框架（WebFlux的基礎）等也相繼實現了 Reactive Stream 規范

?下圖展示了訂閱者和發布者之間的交互

Xnip20200225_131010.png

?2.背壓（back pressure）概念

?如果生產者發出的信息比消費者能夠處理消息最大量還要多，消費者可能會被迫一直在抓消息，耗費越來越多的資源，埋下潛在的崩潰風險。為了防止這一點，需要有一種機制使消費者可以通知生產者，降低消息的生成速度。生產者可以采用多種策略來實現這一要求，這種機制稱為背壓。

?簡單來說就是

背壓指的發布者和訂閱者之間的互動
訂閱者可以告訴發布者自己需要多少數據，可以調節數據流量，不會導致發布者發布數據過多導致數據浪費或壓垮訂閱者

?3.JDK9中 Reactive Stream規范的實現

?JDK9中Reactive Stream的實現規范通常被稱為 Flow API ，通過java.util.concurrent.Flow 和java.util.concurrent.SubmissionPublisher 類來實現響應式流

?在JDK9里Reactive Stream的主要接口聲明在Flow類里，Flow 類中定義了四個嵌套的靜態接口，用于建立流量控制的組件，發布者在其中生成一個或多個供訂閱者使用的數據項：

Publisher：數據項發布者、生產者
Subscriber：數據項訂閱者、消費者
Subscription：發布者與訂閱者之間的關系紐帶，訂閱令牌
Processor：數據處理器

Xnip20200225_132212.png

??3.1 發布者 Publisher

??Publisher 將數據流發布給注冊的 Subscriber。它通常使用 Executor 異步發布項目給訂閱者。 Publisher 需要確保每個訂閱的 Subscriber 方法嚴格按順序調用。

subscribe：訂閱者訂閱發布者

    @FunctionalInterface 
    public static interface Flow.Publisher<T> { 
      public void subscribe(Subscriber<? super T> subscriber); 
    }

??3.2 訂閱者 Subscriber

??Subscriber 訂閱 Publisher 的數據流，并接受回調。如果 Subscriber 沒有發出請求，就不會收到數據。對于給定訂閱合同（Subscription），調用 Subscriber 的方法是嚴格按順序的。

onSubscribe：發布者調用訂閱者的這個方法來異步傳遞訂閱，這個方法在 publisher.subscribe方法調用后被執行
onNext：發布者調用這個方法傳遞數據給訂閱者
onError：當 Publisher 或 Subscriber 遇到不可恢復的錯誤時調用此方法，之后不會再調用其他方法
onComplete：當數據已經發送完成，且沒有錯誤導致訂閱終止時，調用此方法，之后不再調用其他方法

??3.3 訂閱合同 Subscription

??Subscription 用于連接 Publisher 和 Subscriber。Subscriber 只有在請求時才會收到項目，并可以通過 Subscription 取消訂閱。Subscription 主要有兩個方法：

request：訂閱者調用此方法請求數據

cancel：訂閱者調用這個方法來取消訂閱，解除訂閱者與發布者之間的關系

  public static interface Flow.Subscription {
    public void request(long n);
    public void cancel();
  }

??3.4 處理器 Processor

??Processor 位于 Publisher 和 Subscriber 之間，用于做數據轉換。可以有多個 Processor 同時使用，組成一個處理鏈，鏈中最后一個處理器的處理結果發送給 Subscriber。JDK 沒有提供任何具體的處理器。處理器同時是訂閱者和發布者，接口的定義也是繼承了兩者即作為訂閱者也作為發布者，作為訂閱者接收數據，然后進行處理，處理完后作為發布者，再發布出去。

/**
 * A component that acts as both a Subscriber and Publisher.
 *
 * @param <T> the subscribed item type
 * @param <R> the published item type
 */
public static interface Processor<T,R> extends Subscriber<T>, Publisher<R> {
}

Xnip20200225_133449.png

?4.JDK9 中Reactive Stream（Flow API ）規范調用流程

?Publisher是能夠發出元素的發布者，Subscriber是接收元素并做出響應的訂閱者。當執行Publisher里的subscribe方法時，發布者會回調訂閱者的onSubscribe方法，這個方法中，通常訂閱者會借助傳入的Subscription向發布者請求n個數據。然后發布者通過不斷調用訂閱者的onNext方法向訂閱者發出最多n個數據。如果數據全部發完，則會調用onComplete告知訂閱者流已經發完；如果有錯誤發生，則通過onError發出錯誤數據，同樣也會終止流。

?其中，Subscription相當于是連接Publisher和Subscriber的“紐帶（合同）”。因為當發布者調用subscribe方法注冊訂閱者時，會通過訂閱者的回調方法onSubscribe傳入Subscription對象，之后訂閱者就可以使用這個Subscription對象的request方法向發布者“要”數據了。背壓機制正是基于此來實現的。

Xnip20200225_133733.png

?5.案例一響應式基礎使用案例

??5.1 以下代碼簡單演示了SubmissionPublisher 和這套發布-訂閱框架的基本使用方式：

??注意要使用JDK9以上的版本

/**
* @author johnny
* @create 2020-02-24 下午5:44
**/
@Slf4j
public class ReactiveStreamTest {


public static void main(String[] args) throws InterruptedException {


    //1.創建 生產者Publisher JDK9自帶的 實現了Publisher接口
    SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();

    //2.創建 訂閱者 Subscriber，需要自己去實現內部方法

    Flow.Subscriber<Integer> subscriber = new Flow.Subscriber<>() {

        private Flow.Subscription subscription;

        @Override
        public void onSubscribe(Flow.Subscription subscription) {
            this.subscription = subscription;
            System.out.println("訂閱成功。。");
            subscription.request(1);
            System.out.println("訂閱方法里請求一個數據");
        }

        @Override
        public void onNext(Integer item) {
            log.info("【onNext 接受到數據 item : {}】 ", item);
            subscription.request(1);
        }

        @Override
        public void onError(Throwable throwable) {
            log.info("【onError 出現異?！?);
            subscription.cancel();
        }

        @Override
        public void onComplete() {
            log.info("【onComplete 所有數據接收完成】");
        }
    };

    //3。發布者和訂閱者 建立訂閱關系 就是回調訂閱者的onSubscribe方法傳入訂閱合同
    publisher.subscribe(subscriber);


    //4.發布者 生成數據
    for (int i = 1; i <= 5; i++) {
        log.info("【生產數據 {} 】", i );
        //submit是一個阻塞方法，此時會調用訂閱者的onNext方法
        publisher.submit(i);
    }


    //5.發布者 數據都已發布完成后，關閉發送，此時會回調訂閱者的onComplete方法
    publisher.close();

    //主線程睡一會
    Thread.currentThread().join(100000);


  }
}

?打印輸出結果

Xnip20200225_134439.png

?看結果好像我們看不出來Reactive Stream有什么用，其實關鍵點在 publisher.submit(i); submit它是一個阻塞方法
讓我們把代碼修改一點

1.將onNext添加耗時操作，模擬業務耗時邏輯
2.增加發布者發布數據的數量，模擬真實場景無限數據

    @Override
        public void onNext(Integer item) {
            log.info("【onNext 接受到數據 item : {}】 ", item);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            subscription.request(1);
        }

    //發布者 生成數據
    for (int i = 1; i <= 1000; i++) {
        log.info("【生產數據 {} 】", i );
        //submit是一個阻塞方法，此時會調用訂閱者的onNext方法
        publisher.submit(i);
    }

?直接看打印

?會發現發布者生成數據到256后就會停止生產，這是因為publisher.submit(i)方法是阻塞的，
內部有個緩沖數組最大容量就是256，只有當訂閱者發送 subscription.request(1); 請求后，才會從緩沖數組里拿按照順序拿出數據傳給 onNext方法供訂閱者處理，當subscription.request(1)這個方法被調用后，發布者發現數組里沒有滿才會再生產數據，這樣就防止了生產者一次生成過多的數據把訂閱者壓垮，從而實現了背壓機制

Xnip20200225_135111.png

?6.案例二響應式帶 Processor 使用案例

??6.1創建自定義Processor

package com.johnny.webflux.webfluxlearn.reactivestream;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;

/**
* 自定義 Processor
*
* @author johnny
* @create 2020-02-25 下午1:56
**/
@Slf4j
public class MyProcessor extends SubmissionPublisher<Integer> implements Flow.Processor<Integer, Integer> {

private Flow.Subscription subscription;

@Override
public void onSubscribe(Flow.Subscription subscription) {
    log.info("【Processor 收到訂閱請求】");
    //保存訂閱關系，需要用它來給發布者 相應
    this.subscription = subscription;

    this.subscription.request(1);
}

@Override
public void onNext(Integer item) {
    log.info("【onNext 收到發布者數據  : {} 】", item);

    //做業務處理。。
    if (item % 2 == 0) {
        //篩選偶數 發送給 訂閱者
        this.submit(item);
    }
    this.subscription.request(1);
}

@Override
public void onError(Throwable throwable) {
    // 我們可以告訴發布者, 后面不接受數據了
    this.subscription.cancel();
 }

@Override
public void onComplete() {
    log.info("【處理器處理完畢】");
    this.close();
 }
}

??6.2 運行demo 關聯publisher 和 Processor 和 subscriber

package com.johnny.webflux.webfluxlearn.reactivestream;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;
import java.util.concurrent.TimeUnit;

/**
* 帶Processor的案例
*
* @author johnny
* @create 2020-02-25 下午2:17
**/
@Slf4j
public class ProcessorDemo {

public static void main(String[] args) throws InterruptedException {


    //創建發布者
    SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();


    //創建 Processor 即是發布者也是訂閱者
    MyProcessor myProcessor = new MyProcessor();


    //創建最終訂閱者
    Flow.Subscriber<Integer> subscriber = new Flow.Subscriber<>() {

        private Flow.Subscription subscription;

        @Override
        public void onSubscribe(Flow.Subscription subscription) {
            this.subscription = subscription;
            this.subscription.request(1);
        }

        @Override
        public void onNext(Integer item) {
            log.info("【onNext 從Processor 接受到過濾后的 數據 item : {}】 ", item);
            this.subscription.request(1);
        }

        @Override
        public void onError(Throwable throwable) {
            log.info("【onError 出現異?！?);
            subscription.cancel();
        }

        @Override
        public void onComplete() {
            log.info("【onComplete 所有數據接收完成】");
        }
    };

    //建立關系 發布者和處理器， 此時處理器扮演 訂閱者
    publisher.subscribe(myProcessor);

    //建立關系 處理器和訂閱者  此時處理器扮演
    myProcessor.subscribe(subscriber);

    //發布者發布數據

    publisher.submit(1);
    publisher.submit(2);
    publisher.submit(3);
    publisher.submit(4);

    publisher.close();

    TimeUnit.SECONDS.sleep(2);

  }
}

Xnip20200225_143039.png

?7.總結

?只需要關注JDK9提供的 4個接口，以及內部的方法，對著案例敲一遍代碼其實流程還是很簡單的加油吧?。?！

個人博客網站 https://www.askajohnny.com 歡迎來訪問！
本文由博客一文多發平臺 OpenWrite 發布！

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

JDK9新特性 Reactive Stream 響應式流

JDK9新特性 Reactive Stream 響應式流

JDK9新特性 Reactive Stream 響應式流

?1.Reactive Stream 概念

?2.背壓（back pressure）概念

?3.JDK9中 Reactive Stream規范的實現

??3.1 發布者 Publisher

??3.2 訂閱者 Subscriber

??3.3 訂閱合同 Subscription

??3.4 處理器 Processor

?4.JDK9 中Reactive Stream（Flow API ）規范調用流程

?5.案例一響應式基礎使用案例

??5.1 以下代碼簡單演示了SubmissionPublisher 和這套發布-訂閱框架的基本使用方式：

?6.案例二響應式帶 Processor 使用案例

??6.1創建自定義Processor

??6.2 運行demo 關聯publisher 和 Processor 和 subscriber

?7.總結

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

JDK9新特性 Reactive Stream 響應式流

JDK9新特性 Reactive Stream 響應式流

?1.Reactive Stream 概念

?2.背壓（back pressure）概念

?3.JDK9中 Reactive Stream規范的實現

??3.1 發布者 Publisher

??3.2 訂閱者 Subscriber

??3.3 訂閱合同 Subscription

??3.4 處理器 Processor

?4.JDK9 中Reactive Stream（Flow API ）規范調用流程

?5.案例一 響應式基礎使用案例

??5.1 以下代碼簡單演示了SubmissionPublisher 和這套發布-訂閱框架的基本使用方式：

?6.案例二 響應式帶 Processor 使用案例

??6.1創建自定義Processor

??6.2 運行demo 關聯publisher 和 Processor 和 subscriber

?7.總結

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

?5.案例一響應式基礎使用案例

?6.案例二響應式帶 Processor 使用案例