我们学习WebFlux前置知识

 1.Backpressure

Backpressure 在国内被翻译成背压，这个翻译在网上被很多人吐槽，我觉得大家的吐槽是有道理的，背压单纯从字面上确实看不出来有什么意思。所以松哥这里直接用英文 Backpressure 吧。

创新互联从2013年开始，是专业互联网技术服务公司，拥有项目成都网站设计、成都网站制作、外贸网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元宝山做网站,已为上家服务,为宝山各地企业和个人服务,联系电话:028-86922220

Backpressure 是一种现象：当数据流从上游生产者向下游消费者传输的过程中，上游生产速度大于下游消费速度，导致下游的 Buffer 溢出，这种现象就叫做 Backpressure。

换句话说，上游生产数据，生产完成后通过管道将数据传到下游，下游消费数据，当下游消费速度小于上游数据生产速度时，数据在管道中积压会对上游形成一个压力，这就是 Backpressure，从这个角度来说，Backpressure 翻译成反压、回压似乎更合理一些。

Backpressure 会出现在有 Buffer 上限的系统中，当出现 Buffer 溢出的时候，就会有 Backpressure，对于 Backpressure，它的应对措施只有一个：丢弃新事件。那么什么是 Buffer 溢出呢?例如我的服务器可以同时处理 2000 个用户请求，那么我就把请求上限设置为 2000，这个 2000 就是我的 Buffer，当超出 2000 的时候，就产生了 Backpressure。

2.Flow API

JDK9 中推出了 Flow API，用以支持 Reactive Programming，即响应式编程。

在响应式编程中，会有一个数据发布者 Publisher 和数据订阅者 Subscriber，Subscriber 接收 Publisher 发布的数据并进行消费，在 Subscriber 和 Publisher 之间还存在一个 Processor，类似于一个过滤器，可以对数据进行中间处理。

JDK9 中提供了 Flow API 用以支持响应式编程，另外 RxJava 和 Reactor 等框架也提供了相关的实现。

我们来看看 JDK9 中的 Flow 类：

非常简洁，基本上就是按照 Reactive Programming 的设计来的：

Publisher

Publisher 为数据发布者，这是一个函数式接口，里边只有一个方法，通过这个方法将数据发布出去，Publisher 的定义如下：

 
 
 
 
    
  
  
  
  
  1. @FunctionalInterface 
    2. 
  
  
  
  
  2. public static interface Publisher { 
    3. 
  
  
  
  
  3.     public void subscribe(Subscriber subscriber); 
    4. 
  
  
  
  
  4. } 
    5.

Subscriber

Subscriber 为数据订阅者，这个里边有四个方法，如下：

 
 
 
 
    
  
  
  
  
  1. public static interface Subscriber { 
    2. 
  
  
  
  
  2.     public void onSubscribe(Subscription subscription); 
    3. 
  
  
  
  
  3.     public void onNext(T item); 
    4. 
  
  
  
  
  4.     public void onError(Throwable throwable); 
    5. 
  
  
  
  
  5.     public void onComplete(); 
    6. 
  
  
  
  
  6. } 
    7.
  • onSubscribe：这个是订阅成功的回调方法，用于初始化 Subscription，并且表明可以开始接收订阅数据了。
  • onNext：接收下一项订阅数据的回调方法。
  • onError：在 Publisher 或 Subcriber 遇到不可恢复的错误时调用此方法，之后 Subscription 不会再调用 Subscriber 其他的方法。
  • onComplete：当接收完所有订阅数据，并且发布者已经关闭后会回调这个方法。

Subscription

Subscription 为发布者和订阅者之间的订阅关系，用来控制消息的消费，这个里边有两个方法：

 
 
 
 
    
  
  
  
  
  1. public static interface Subscription { 
    2. 
  
  
  
  
  2.     public void request(long n); 
    3. 
  
  
  
  
  3.     public void cancel(); 
    4. 
  
  
  
  
  4. } 
    5.
  • request：这个方法用来向数据发布者请求 n 个数据。
  • cancel：取消消息订阅，订阅者将不再接收数据。

Processor

Processor 是一个空接口，不过它同时继承了 Publisher 和 Subscriber，所以它既能发布数据也能订阅数据，因此我们可以通过 Processor 来完成一些数据转换的功能，先接收数据进行处理，处理完成后再将数据发布出去，这个也有点类似于我们 JavaEE 中的过滤器。

 
 
 
 
    
  
  
  
  
  1. public static interface Processor extends Subscriber, Publisher { 
    2. 
  
  
  
  
  2. } 
    3.

2.1 消息订阅初体验

我们通过如下一段代码体验一下消息的订阅与发布：

 
 
 
 
    
  
  
  
  
  1. public class FlowDemo { 
    2. 
  
  
  
  
  2.     public static void main(String[] args) { 
    3. 
  
  
  
  
  3.         SubmissionPublisher publisher = new SubmissionPublisher<>(); 
    4. 
  
  
  
  
  4.         Flow.Subscriber subscriber = new Flow.Subscriber() { 
    5. 
  
  
  
  
  5.             private Flow.Subscription subscription; 
    6. 
  
  
  
  
  6.             @Override 
    7. 
  
  
  
  
  7.             public void onSubscribe(Flow.Subscription subscription) { 
    8. 
  
  
  
  
  8.                 this.subscription = subscription; 
    9. 
  
  
  
  
  9.                 //向数据发布者请求一个数据 
    10. 
  
  
  
  
  10.                 this.subscription.request(1); 
    11. 
  
  
  
  
  11.             } 
    12. 
  
  
  
  
  12.             @Override 
    13. 
  
  
  
  
  13.             public void onNext(String item) { 
    14. 
  
  
  
  
  14.                 System.out.println("接收到 publisher 发来的消息了：" + item); 
    15. 
  
  
  
  
  15.                 //接收完成后，可以继续接收或者不接收 
    16. 
  
  
  
  
  16.                 //this.subscription.cancel(); 
    17. 
  
  
  
  
  17.                 this.subscription.request(1); 
    18. 
  
  
  
  
  18.             } 
    19. 
  
  
  
  
  19.             @Override 
    20. 
  
  
  
  
  20.             public void onError(Throwable throwable) { 
    21. 
  
  
  
  
  21.                 //出现异常，就会来到这个方法，此时直接取消订阅即可 
    22. 
  
  
  
  
  22.                 this.subscription.cancel(); 
    23. 
  
  
  
  
  23.             } 
    24. 
  
  
  
  
  24.             @Override 
    25. 
  
  
  
  
  25.             public void onComplete() { 
    26. 
  
  
  
  
  26.                 //发布者的所有数据都被接收，并且发布者已经关闭 
    27. 
  
  
  
  
  27.                 System.out.println("数据接收完毕"); 
    28. 
  
  
  
  
  28.             } 
    29. 
  
  
  
  
  29.         }; 
    30. 
  
  
  
  
  30.         //配置发布者和订阅者 
    31. 
  
  
  
  
  31.         publisher.subscribe(subscriber); 
    32. 
  
  
  
  
  32.         for (int i = 0; i < 5; i++) { 
    33. 
  
  
  
  
  33.             //发送数据 
    34. 
  
  
  
  
  34.             publisher.submit("hello:" + i); 
    35. 
  
  
  
  
  35.         } 
    36. 
  
  
  
  
  36.         //关闭发布者 
    37. 
  
  
  
  
  37.         publisher.close(); 
    38. 
  
  
  
  
  38.         new Scanner(System.in).next(); 
    39. 
  
  
  
  
  39.     } 
    40. 
  
  
  
  
  40. } 
    41.

松哥稍微解释一下上面这段代码：

  1. 首先创建一个 SubmissionPublisher 对象作为消息发布者。
  2. 接下来创建 Flow.Subscriber 对象作为消息订阅者，实现消息订阅者里边的四个方法，分别进行处理。
  3. 为 publisher 配置上 subscriber。
  4. 发送消息。
  5. 消息发送完成后关闭 publisher。
  6. 最后是让程序不要停止，观察消息订阅者打印情况。

2.2 模拟 Backpressure

Backpressure 问题在 Flow API 中得到了很好的解决。Subscriber 会将 Publisher 发布的数据缓存在 Subscription 中，其长度默认为256，相关源码如下：

 
 
 
 
    
  
  
  
  
  1. public final class Flow { 
    2. 
  
  
  
  
  2.     static final int DEFAULT_BUFFER_SIZE = 256; 
    3. 
  
  
  
  
  3.     public static int defaultBufferSize() { 
    4. 
  
  
  
  
  4.         return DEFAULT_BUFFER_SIZE; 
    5. 
  
  
  
  
  5.     } 
    6. 
  
  
  
  
  6.     ... 
    7. 
  
  
  
  
  7. } 
    8.

一旦超出这个数据量，publisher 就会降低数据发送速度。

我们对上面的案例进行修改，如下：

 
 
 
 
    
  
  
  
  
  1. public class FlowDemo { 
    2. 
  
  
  
  
  2.     public static void main(String[] args) { 
    3. 
  
  
  
  
  3.         SubmissionPublisher publisher = new SubmissionPublisher<>(); 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.         Flow.Subscriber subscriber = new Flow.Subscriber() { 
    6. 
  
  
  
  
  6.             private Flow.Subscription subscription; 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.             @Override 
    9. 
  
  
  
  
  9.             public void onSubscribe(Flow.Subscription subscription) { 
    10. 
  
  
  
  
  10.                 this.subscription = subscription; 
    11. 
  
  
  
  
  11.                 //向数据发布者请求一个数据 
    12. 
  
  
  
  
  12.                 this.subscription.request(1); 
    13. 
  
  
  
  
  13.             } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.             @Override 
    16. 
  
  
  
  
  16.             public void onNext(String item) { 
    17. 
  
  
  
  
  17.                 System.out.println("接收到 publisher 发来的消息了：" + item); 
    18. 
  
  
  
  
  18.                 //接收完成后，可以继续接收或者不接收 
    19. 
  
  
  
  
  19.                 //this.subscription.cancel(); 
    20. 
  
  
  
  
  20.                 try { 
    21. 
  
  
  
  
  21.                     Thread.sleep(2000); 
    22. 
  
  
  
  
  22.                 } catch (InterruptedException e) { 
    23. 
  
  
  
  
  23.                     e.printStackTrace(); 
    24. 
  
  
  
  
  24.                 } 
    25. 
  
  
  
  
  25.                 this.subscription.request(1); 
    26. 
  
  
  
  
  26.             } 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.             @Override 
    29. 
  
  
  
  
  29.             public void onError(Throwable throwable) { 
    30. 
  
  
  
  
  30.                 //出现异常，就会来到这个方法，此时直接取消订阅即可 
    31. 
  
  
  
  
  31.                 this.subscription.cancel(); 
    32. 
  
  
  
  
  32.             } 
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34.             @Override 
    35. 
  
  
  
  
  35.             public void onComplete() { 
    36. 
  
  
  
  
  36.                 //发布者的所有数据都被接收，并且发布者已经关闭 
    37. 
  
  
  
  
  37.                 System.out.println("数据接收完毕"); 
    38. 
  
  
  
  
  38.             } 
    39. 
  
  
  
  
  39.         }; 
    40. 
  
  
  
  
  40.         publisher.subscribe(subscriber); 
    41. 
  
  
  
  
  41.         for (int i = 0; i < 500; i++) { 
    42. 
  
  
  
  
  42.             System.out.println("i--------->" + i); 
    43. 
  
  
  
  
  43.             publisher.submit("hello:" + i); 
    44. 
  
  
  
  
  44.         } 
    45. 
  
  
  
  
  45.         //关闭发布者 
    46. 
  
  
  
  
  46.         publisher.close(); 
    47. 
  
  
  
  
  47.         new Scanner(System.in).next(); 
    48. 
  
  
  
  
  48.     } 
    49. 
  
  
  
  
  49. } 
    50.

一共修改了三个地方：

  1. Subscriber#onNext 方法中，每次休息两秒再处理下一条数据。
  2. 发布数据时，一共发布 500 条数据。
  3. 打印数据发布的日志。

修改完成后，我们再次启动项目，观察控制台输出：

可以看到，生产者先是一股脑生产了 257 条数据(hello0 在一开始就被消费了，所以缓存中实际上是 256 条)，消息则是一条一条的来，由于消费的速度比较慢，所以当缓存中的数据超过 256 条之后，接下来都是消费一条，再发送一条。

2.3 数据处理

Flow.Processor 可以像过滤器一样，对数据进行预处理，数据从 publisher 出来之后，先进入 Flow.Processor 中进行预处理，然后再进入 Subscriber。

修改后的代码如下：

 
 
 
 
    
  
  
  
  
  1. public class FlowDemo { 
    2. 
  
  
  
  
  2.     public static void main(String[] args) { 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.         class DataFilter extends SubmissionPublisher implements Flow.Processor{ 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.             private Flow.Subscription subscription; 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.             @Override 
    9. 
  
  
  
  
  9.             public void onSubscribe(Flow.Subscription subscription) { 
    10. 
  
  
  
  
  10.                 this.subscription = subscription; 
    11. 
  
  
  
  
  11.                 this.subscription.request(1); 
    12. 
  
  
  
  
  12.             } 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.             @Override 
    15. 
  
  
  
  
  15.             public void onNext(String item) { 
    16. 
  
  
  
  
  16.                 this.submit("【这是一条被处理过的数据】" + item); 
    17. 
  
  
  
  
  17.                 this.subscription.request(1); 
    18. 
  
  
  
  
  18.             } 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20.             @Override 
    21. 
  
  
  
  
  21.             public void onError(Throwable throwable) { 
    22. 
  
  
  
  
  22.                 this.subscription.cancel(); 
    23. 
  
  
  
  
  23.             } 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.             @Override 
    26. 
  
  
  
  
  26.             public void onComplete() { 
    27. 
  
  
  
  
  27.                 this.close(); 
    28. 
  
  
  
  
  28.             } 
    29. 
  
  
  
  
  29.         } 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.         SubmissionPublisher publisher = new SubmissionPublisher<>(); 
    32. 
  
  
  
  
  32.         DataFilter dataFilter = new DataFilter(); 
    33. 
  
  
  
  
  33.         publisher.subscribe(dataFilter); 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35.         Flow.Subscriber subscriber = new Flow.Subscriber() { 
    36. 
  
  
  
  
  36.             private Flow.Subscription subscription; 
    37. 
  
  
  
  
  37.  
    38. 
  
  
  
  
  38.             @Override 
    39. 
  
  
  
  
  39.             public void onSubscribe(Flow.Subscription subscription) { 
    40. 
  
  
  
  
  40.                 this.subscription = subscription; 
    41. 
  
  
  
  
  41.                 //向数据发布者请求一个数据 
    42. 
  
  
  
  
  42.                 this.subscription.request(1); 
    43. 
  
  
  
  
  43.             } 
    44. 
  
  
  
  
  44.  
    45. 
  
  
  
  
  45.             @Override 
    46. 
  
  
  
  
  46.             public void onNext(String item) { 
    47. 
  
  
  
  
  47.                 System.out.println("接收到 publisher 发来的消息了：" + item); 
    48. 
  
  
  
  
  48.                 //接收完成后，可以继续接收或者不接收 
    49. 
  
  
  
  
  49.                 //this.subscription.cancel(); 
    50. 
  
  
  
  
  50.                 try { 
    51. 
  
  
  
  
  51.                     Thread.sleep(2000); 
    52. 
  
  
  
  
  52.                 } catch (InterruptedException e) { 
    53. 
  
  
  
  
  53.                     e.printStackTrace(); 
    54. 
  
  
  
  
  54.                 } 
    55. 
  
  
  
  
  55.                 this.subscription.request(1); 
    56. 
  
  
  
  
  56.             } 
    57. 
  
  
  
  
  57.  
    58. 
  
  
  
  
  58.             @Override 
    59. 
  
  
  
  
  59.             public void onError(Throwable throwable) { 
    60. 
  
  
  
  
  60.                 //出现异常，就会来到这个方法，此时直接取消订阅即可 
    61. 
  
  
  
  
  61.                 this.subscription.cancel(); 
    62. 
  
  
  
  
  62.             } 
    63. 
  
  
  
  
  63.  
    64. 
  
  
  
  
  64.             @Override 
    65. 
  
  
  
  
  65.             public void onComplete() { 
    66. 
  
  
  
  
  66.                 //发布者的所有数据都被接收，并且发布者已经关闭 
    67. 
  
  
  
  
  67.                 System.out.println("数据接收完毕"); 
    68. 
  
  
  
  
  68.             } 
    69. 
  
  
  
  
  69.         }; 
    70. 
  
  
  
  
  70.         dataFilter.subscribe(subscriber); 
    71. 
  
  
  
  
  71.         for (int i = 0; i < 500; i++) { 
    72. 
  
  
  
  
  72.             System.out.println("发送消息 i--------->" + i); 
    73. 
  
  
  
  
  73.             publisher.submit("hello:" + i); 
    74. 
  
  
  
  
  74.         } 
    75. 
  
  
  
  
  75.         //关闭发布者 
    76. 
  
  
  
  
  76.         publisher.close(); 
    77. 
  
  
  
  
  77.         new Scanner(System.in).next(); 
    78. 
  
  
  
  
  78.     } 
    79. 
  
  
  
  
  79. } 
    80.

简单起见，我这里创建了一个局部内部类 DataFilter，DataFilter 继承自 SubmissionPublisher 并实现了 Flow.Processor 接口，由于 DataFilter 继承自 SubmissionPublisher，所以它也兼具 SubmissionPublisher 的功能。

在 DataFilter 中完成消息的处理并重新发送出去。接下来定义 publisher，让 dataFilter 作为其订阅者，再定义新的订阅者，作为 dataFilter 的订阅者。

最终运行效果如下：

3.小结

好啦，这就是今天和大家介绍的 Java9 中的 Reactive Stream，那么至此，我们的 WebFlux 前置知识差不多告一段落了，下篇文章开始，正式开整 WebFlux。

本文转载自微信公众号「江南一点雨」，可以通过以下二维码关注。转载本文请联系江南一点雨公众号。

当前标题：我们学习WebFlux前置知识
本文链接：http://www.shufengxianlan.com/qtweb/news36/270736.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

用户体验知识

分类信息网

成都商城网站建设　　 　微信小程序开发　　 　彭州网站建设　　 　微信小程序开发　　 　LED亮化工程　　 　seo优化　　 　专业网站建设　　 　联通机柜租用　　 　成都网站建设　　 　网站排名优化　　 　成都网站推广　　 　公司logo设计　　 　宇仓仓储　　 　全网营销　　 　成都网站维护公司　　 　康明斯发电机　　 　德阳定制网站建设　　 　乐山服务器托管　　 　橡塑保温材料　　 　网站推广公司