Spring reactor框架简介

最新推荐文章于 2024-08-13 11:36:04 发布
最新推荐文章于 2024-08-13 11:36:04 发布
阅读量4.1k 收藏 3
点赞数 3
分类专栏： java基础
Spring社区上月发布了基于事件驱动的异步框架 reactor。当前reactor还在密集研发中，代码几天大变样，非常的不稳定，这2周还完全重写了它自己的reactor-tcp。sample code也跟不上。这里只选取其其中最最基本和核心的功能，让大家先睹为快。

一：核心：基于事件驱动。

事件注册：

Java代码   收藏代码
  1. //初始化环境变量，若无，会从默认的读取classpath下默认的default.properties 文件  
  2. Environment env = new Environment();  
  3. //创建一个Reactor，指定的dispatcher为eventLoop,（dispatcher 种类下面会再细说）  
  4. Reactor reactor = R.reactor().using(env).dispatcher("eventLoop").get();  
  5. //注册一个名为event的事件，事件为Consumer  
  6. reactor.on($("event"), new Consumer<Event<String>>() {  
  7. @Override  
  8. public void accept(Event<String> t) {  
  9.   System.out.println("This is sample code" + t.getData());  
  10. }  
  11. });  
//初始化环境变量，若无，会从默认的读取classpath下默认的default.properties 文件
Environment env = new Environment();
//创建一个Reactor，指定的dispatcher为eventLoop,（dispatcher 种类下面会再细说）
Reactor reactor = R.reactor().using(env).dispatcher("eventLoop").get();
//注册一个名为event的事件，事件为Consumer
reactor.on($("event"), new Consumer<Event<String>>() {
@Override
public void accept(Event<String> t) {
  System.out.println("This is sample code" + t.getData());
}
});


事件发布(或者事件触发)


Java代码   收藏代码
  1. //传入一个String事件，事件的值为Hello World!  
  2. reactor.notify("event", new Event<String>("Hello World!"));  
//传入一个String事件，事件的值为Hello World!
reactor.notify("event", new Event<String>("Hello World!"));


运行后的结果为: This is sample code!
由此一个最最简单的事件驱动程序就完成了。

二. Composable的使用

Reactor里另外一个核心的功能就是Composable，当一个业务有很多步阻塞调用的时候，在不用callback的情况下，可以应用Composable将其中的阻塞调用，分割成异步非阻塞执行。

我们想象一个应用场景，一个账号服务，需要根据一个accountId来拿到一个account的余额。业务上可能需要这么几步：
a) 验证是否是有效用户 --> 调用authService.isValidUser
b) 根据accountId拿到整个account信息 -->accountService.getAccountById
c) 传入account获得account balance --> billService.getAccountBalance

那么代码怎么实现的。最最简单的直观的就是顺序阻塞调用。
代码A
Java代码   收藏代码
  1. public Long getAccountBalance1(Integer accountId){  
  2.     boolean auth = authService.isValidUser(accountId);  
  3.     if(auth){  
  4.         Account account = accountService.getAccountById(accountId);  
  5.         if(account!=null){  
  6.             return billService.getAccountBalance(account);  
  7.         }  
  8.         else{  
  9.             return -1l;  
  10.         }  
  11.     }  
  12.     else{  
  13.         return -1l;  
  14.     }  
  15. }  
	public Long getAccountBalance1(Integer accountId){
		boolean auth = authService.isValidUser(accountId);
		if(auth){
			Account account = accountService.getAccountById(accountId);
			if(account!=null){
				return billService.getAccountBalance(account);
			}
			else{
				return -1l;
			}
		}
		else{
			return -1l;
		}
	}


先不论代码的逻辑正确性，上述的代码肯定是吞吐量不高。为求改善，现改为异步调用。最简单的异步就是加callback
代码B：

Java代码   收藏代码
  1. public Long getAccountBalance1(Integer id){  
  2.         final Integer accountId = id;  
  3.         final Future<Long> balanceFuture;  
  4.         authService.isValidUser(accountId, new ICallback(){  
  5.             @Override  
  6.             public void callback(Object value) {  
  7.                 boolean auth = (boolean)value;  
  8.                 if(auth){  
  9.                     accountService.getAccountById(accountId, new ICallback(){  
  10.                         @Override  
  11.                         public void callback(Object value) {  
  12.                             if(value!=null){  
  13.                                 Account account = (Account)value;  
  14.                                Long balance = billService.getAccountBalance(account);  
  15.                                balanceFuture.setValue(balance);  
  16.                             }  
  17.                         }  
  18.                           
  19.                     });  
  20.                 }  
  21.                   
  22.             }  
  23.               
  24.         });  
  25.           
  26.         return balanceFuture.get(3000,TimeUnit.MILLISECONDS);  
  27.     }  
public Long getAccountBalance1(Integer id){
	    final Integer accountId = id;
	    final Future<Long> balanceFuture;
		authService.isValidUser(accountId, new ICallback(){
			@Override
			public void callback(Object value) {
				boolean auth = (boolean)value;
				if(auth){
					accountService.getAccountById(accountId, new ICallback(){
						@Override
						public void callback(Object value) {
							if(value!=null){
								Account account = (Account)value;
							   Long balance = billService.getAccountBalance(account);
							   balanceFuture.setValue(balance);
							}
						}
						
					});
				}
				
			}
			
		});
		
		return balanceFuture.get(3000,TimeUnit.MILLISECONDS);
	}


这断代码没有测试过。但是可以明显的看到这里用了嵌套的callback，代码很难看，不优雅，并对代码有侵入（需要有一个callback的同名接口）。
那么用了Reactor Composable的代码又将会是如何呢，请看：

Java代码   收藏代码
  1. public Long getAccountBalance(Integer id){  
  2.         final Integer accountId = id;  
  3.         Composable<Long> c = S.each(Arrays.asList(accountId))  
  4.                 .using(new Environment())  
  5.                 .dispatcher("eventLoop")  
  6.                 .get()  
  7.                 .map(new Function<Integer, Boolean>(){  
  8.                     @Override  
  9.                     public Boolean apply(Integer accountId) {  
  10.                         return authService.isValidUser(accountId);  
  11.                     }  
  12.                 })  
  13.                 .map(new Function<Boolean,Account>(){  
  14.   
  15.                     @Override  
  16.                     public Account apply(Boolean auth) {  
  17.                         if(auth){  
  18.                             return accountService.getAccountById(accountId);  
  19.                         }  
  20.                         return null;  
  21.                     }  
  22.                 }).map(new Function<Account,Long>(){  
  23.   
  24.                     @Override  
  25.                     public Long apply(Account account) {  
  26.                         return billService.getAccountBalance(account);  
  27.                     }  
  28.           
  29.                 });  
  30.         try {  
  31.             return c.await(3, TimeUnit.SECONDS);  
  32.         } catch (InterruptedException e) {  
  33.             // TODO Auto-generated catch block  
  34.             e.printStackTrace();  
  35.             return -1l;  
  36.         }  
  37.   
  38.     }  
public Long getAccountBalance(Integer id){
		final Integer accountId = id;
		Composable<Long> c = S.each(Arrays.asList(accountId))
				.using(new Environment())
				.dispatcher("eventLoop")
				.get()
				.map(new Function<Integer, Boolean>(){
					@Override
					public Boolean apply(Integer accountId) {
						return authService.isValidUser(accountId);
					}
				})
				.map(new Function<Boolean,Account>(){

					@Override
					public Account apply(Boolean auth) {
						if(auth){
							return accountService.getAccountById(accountId);
						}
						return null;
					}
				}).map(new Function<Account,Long>(){

					@Override
					public Long apply(Account account) {
						return billService.getAccountBalance(account);
					}
		
				});
		try {
			return c.await(3, TimeUnit.SECONDS);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return -1l;
		}

	}


显然代码优雅了很多，没有代码侵入。但这些都不是关键。
关键是业务中的，a，b，c都被分割成一个独立的事件注册到了reactor，每一步都是独立的线程执行，并且在这个列子中，是顺序执行的，线程安全。

三：Dispatcher
最后这里再详细介绍下之前提到的Reactor的Dispatcher，dispatcher是reactor的核心，顾名思义，就是一个分发器，用作事件的分发，当一个事件到达，(即Reacot.notify被调用)最终会由dispatcher进行任务分发调度(dispatcher.dipatch)

Dispatcher根据线程和队列分为下面几种dispatcher，系统现在默认为SynchronousDispatcher（不知道以后会不会变，之前默认的是BlockingQueueDispatcher）

SynchronousDispatcher
当一个事件到达时，直接由reactor所在的线程直接执行

BlockingQueueDispatcher(eventloop)
事件到达时先存储在一个Blockingqueue中，再由统一的后台线程一一顺序执行

ThreadPoolExecutorDispatcher(threadpool)
事件达到时将事件交由线程池统一调度。该线程池为固定大小线程池，（Executors.newFixedThreadPool）线程大小由配置文件指定。

RingBufferDispatcher(ringbuffer)
该dispatcher是吞吐量最高，使用了名头比较响的lmax的Disruptor构建的ringBuffer作为事件存储数组，其实就是一个不断递增，并可覆盖之前值环。（大家可以关注下lmax disruptpr）还是比较有意思的。
__Jone
关注
专栏目录
用Reactor框架实现一个简单的tcp服务器
hedes的专栏
11-07 1451
#include #include #include #include #include #include #include class My_Svc_Handler:    public ACE_Svc_Handler {    public:        int open(void*)        {            ACE_INET_Addr raddr;           
Java响应式的框架和工具包：RxJava、Spring Reactor 和 Vert.x 概述
m0_68850571的博客
04-29 3086
今天，人们想要具有强大用户体验的高响应、交互式应用程序，这通常意味着处理异步性，尤其是当应用程序涉及高负载、实时数据和多用户时。 由于 Java 是一种面向对象的语言，本质上支持命令式编程风格，因此异步性是一个相当麻烦的问题，可以将代码变成完全地狱。解决异步并发症的一种可能方法是在编码级别（反应式编程）或设计和架构级别（反应式系统）引入“反应性”。 让我们浏览一下最流行的框架和工具包，以了解我们今天有哪些选项可以在 Java 中实现响应式以及它们有何不同（如果有的话）。但是，从“反应式”上下文中刷新一些
Reactor构架模式及框架概述
weixin_34406061的博客
07-19 110
Reactor框架是ACE各个框架中最基础的一个框架，其他框架都或多或少地用到了Reactor框架。本文分析Reactor构架模式的基本原理。 2.1Reactor构架模式 对每一个构架模式的分析，我们都使用参考文献的分析风格，着重分析意图、上下文、问题、解决方案、结构和实现 6个方面的内容。而实现就是ACE源代码。 1. 意图 在事件驱动的应用中，将一个或多个客户的服务请求分离（demult...
SpringBoot响应式编程(1)Reactor核心
最新发布
qq_62377885的博客
08-13 775
可编排性（Composability）以及可读性（Readability）使用丰富的操作符来处理形如流的数据在订阅（subscribe）之前什么都不会发生背压（backpressure）具体来说即消费者能够反向告知生产者生产内容的速度的能力高层次（同时也是有高价值的）的抽象，从而达到并发无关的效果handle()方法是 Reactor 中一个非常强大的操作符，它允许你同时处理和转换流中的元素。它的功能类似于map()和filter()的结合体，能够在处理元素的同时决定是否将其传递给下游。
Reactor框架
Allan_Zeng的专栏
04-04 1891
记录对reactor的理解。
Spring Reactor 入门与实践
热门推荐
daniel7443的博客
06-21 3万+
适合阅读的人群：本文适合对 Spring、Netty 等框架，以及 Java 8 的 Lambda、Stream 等特性有基本认识，希望了解 Spring 5 的反应式编程特性的技术人员阅读。一、前言最近几年，随着 Node.js、Golang 等新技术、新语言的出现，Java 的服务器端开发语言老大的地位受到了不小的挑战。虽然，Java 的市场份额依旧很大，短时间内也不会改变，但 Java 社区...
vertx-vs-spring-reactor:一个基准，比较使用Groovy，Vertx和vertx-redis-client与Groovy，Spring Reactor和生菜制作的Web服务
05-10
我想看看新的闪亮（好吧，不是真的）Spring Reactor与Vert.x的比较 这两个软件包都是用Groovy编写的。 这个想法是将9 hash get命令发送给redis。 这是通过以下方式完成的： 在vert.x示例中，使用Vertx-Redis-...
Java编程方法论 之 Spring Reactor Reactor-Netty Spring Webflux 全面解读.pdf
08-20
Spring Webflux是Spring框架的一个扩展，引入了反应式编程模型，允许开发者构建非阻塞的Web应用。 在讨论ChannelPool的设计实现时，我们聚焦于如何有效地管理和复用与服务器的连接。ChannelPool是Netty中的一个重要...
mydemo:Spring Reactor Webflux
03-20
【标题】"mydemo:Spring Reactor Webflux" 指的是一个使用Spring框架和Reactor Webflux构建的示例项目。Spring Reactor Webflux是Spring Framework的一部分，它支持响应式编程模型，允许开发人员创建非阻塞、高并发...
reactor框架推送式框架文档
11-09
Reactor 是一个强大的开源库，它是 Spring Framework 的一部分，用于构建高效的、响应式的应用程序。这个框架专注于异步处理和非阻塞编程，充分利用了 Java 8 和 Reactive Streams 规范。文档主要分为多个部分，详细...
spring-reactor-demo:演示项目，用于说明 Reactor 在 Spring 午餐和学习应用程序中的使用
06-07
描述 这是一个演示 Spring Boot、Spring MVC（作为 REST 控制器）和 Reactor 使用的项目。 该项目和即兴创作基于指南。 用法 构建和测试 mvn test 从命令行运行它 mvn spring-boot:run 之后，您应该在端口 8080 上有可用的应用程序。 你可以去 查看返回的 JSON { id: 1, content: "Hello, Evgeniy!" } 如果你尝试调用你应该得到 400 错误代码。
响应式编程简介之:Reactor
程序那些事
11-06 1万+
Reactor是reactivex家族的一个非常重要的成员，Reactor是第四代的reactive library，它是基于Reactive Streams标准基础上开发的，主要用来构建JVM环境下的非阻塞应用程序。 今天给大家介绍一下Reactor。
spring reactor框架
caoruntie的专栏
05-21 188
前几天发现了spring社区发布reactor框架，还没有比较多的使用案例，但从简介中已能探知是一个比较给力框架，融入了比较多的编程思想，大家可以学习一二，短期内可能不会有太多的使用案例 https://github.com/reactor/reactor#events-selectors-and-consumers   http://blog.springsource.org/2013/...
Spring Reactor教程
最佳 Java 编程
06-10 4997
在RESTful服务的世界中，实际上实际上是在幕后进行许多工作，我们通常必须在应用程序中进行很多处理，而实际上并不会影响需要发送给真实用户的响应。 可以被动地做出这些业务决策，以便它们对与应用程序交互的用户没有任何影响。 Spring Framework为我们提供了一个出色的项目，称为Spring Reactor项目，它使我们能够在后台很好地管理此后台处理。 在学习本课程之前，我们必须注意一...
ACE之（三）Reactor框架
XingyuZhengtu的博客
11-21 1391
关注微信公众号“池边小树”~~获取更多分析~~（文末二维码~~） 目录 3 Reactor框架 3.1 Reactor构架模式 3.2 Reactor框架概述 3.3 Reactor框架应用实例 3.4 事件处理器接口实现 3.5 Reactor 管理器的设计分析 3.5.1 Reactor管理器接口分析 3.5.2 ACE_Select_Reactor_Impl类分析 3...
Spring Reactor
qq_19266669的博客
05-05 2439
Flux, 包含 0-N 个元素的异步序列 Flux 是一个能够发出 0 到 N 个元素的标准的 Publisher，它会被一个“错误（error）” 或“完成（completion）”信号终止。因此，一个 flux 的可能结果是一个 value、completion 或 error。 如果没有 onNext 事件但是有一个 onComplete 事件， 那么发出的就是 空的 有限序列// subscribe 首先触发request，然后onNext， 默认request(Long.MAX_VALUE
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值