数据结构的分类方式

传统上,我们可以把数据结构分为逻辑结构物理结构两大类。

1、逻辑结构分类:

逻辑结构是从具体问题中抽象出来的模型,是抽象意义上的结构,按照对象中数据元素之间的相互关系分类。
a.集合结构:集合结构中数据元素除了属于同一个集合外,他们之间没有任何其他的关系。
数据结构分类
b.线性结构:线性结构中的数据元素之间存在一对一的关系
数据结构分类
c.树形结构:树形结构中的数据元素之间存在一对多的层次关系
数据结构分类
d.图形结构:图形结构的数据元素是多对多的关系
数据结构分类

2、物理结构分类:

逻辑结构在计算机中真正的表示方式(又称为映像)称为物理结构,也可以叫做存储结构。常见的物理结构有顺序存储结构、链式存储结构。

顺序存储结构:
把数据元素放到地址连续的存储单元里面,其数据间的逻辑关系和物理关系是一致的 ,比如我们常用的数组就是 顺序存储结构。

数据结构分类

链式存储结构:
顺序存储结构存在一定的弊端,就像生活中排时也会有人插队也可能有人有特殊情况突然离开,这时候整个结构都
处于变化中,此时就需要链式存储结构。

链式存储结构是把数据元素存放在任意的存储单元里面,这组存储单元可以是连续的也可以是不连续的。此时,数据元素之间并
不能反映元素间的逻辑关系,因此在链式存储结构中引进了一个指针存放数据元素的地址,这样通过地址就可以找
到相关联数据元素的位置
数据结构分类

0

java8 stream forEachOrdered 和 forEach 的区别

 

这两个函数都是对集合的流,进行遍历操作,是属于内部迭代;传入一个Consumer的函数接口,下面通过案例,简单了解下:

先看第一段输出和第二段输出,使用的是stream的串行流,也就是程序是串行执行的,所有看到遍历的结果都是按照集合的元素放入的顺序。

看第三段和第四段输出,使用的parallelStream的并行流,也就是在程序内部迭代的时候,会并行处理。

第三段代码的forEachOrdered表示严格按照顺序取数据,第四段forEach在并行中,元素随机排列了。

由此可看出,在并行的程序中,如果对处理之后的数据,没有顺序的要求,使用forEach的效率,肯定是要更好的。

以上就是 java8 stream forEachOrdered 和 forEach 的区别。

 

 

0

minio设置文件访问链接永久有效(可通过路径直接访问)

通过minio分享的链接只能支持7天,在某些场景下使用非常不方便。

那如何设置文件访问链接永久有效呢?

解决方案是设置对应的bucket 可通过路径直接访问。(必须通过minio client才能设置下载策略)

0

MySQL递归查询树结构方法总结

在日常开发中我们经常会遇到树形结构数据的处理,如:组织机构之类的情况。在表结构通常会采用idparent_id这种设计方案。一个常见的需求:查询某个节点下的所有子节点。

为方便后续说明,在此统一约定表名为:t_org,其定义如下:

字段 类型 说明
id bigint(20) NOT NULL 机构编码
parent_id bigint(20) 上级机构编码
desc varchar(200) 备注

查询实现方案

表中现有如下测试数据

测试数据

组织机构层级数确定时

可以采用自关联LEFT JOIN方式进行查询获取结果。

查询结果如下:

查询结果

组织机构层级数不确定时

当组织机构层级数不确定时,无法使用上述方式进行查询

可以通过自定义函数方式实现查询

在上面函数中使用到了两个MySQL函数

GROUP_CONCAT(expr)
该函数会从expr中连接所有非NULL的字符串。如果没有非 NULL 的字符串,那么它就会返回NULL。语法如下:

注意事项:GROUP_CONCAT查询结果默认最大长度限制为1024,该值是系统变量group_concat_max_len的默认值,可以通过SET [GLOBAL | SESSION] group_concat_max_len = val;更改该值。

FIND_IN_SET(str,strlist)
该函数返回一个1~N的值表示strstrlist中的位置。
该函数结合WHERE使用对结果集进行过过滤

函数使用方式

方案缺点

返回结果长度受VARCHAR最大长度限制,特别是当组织机构比较庞大时该方案会失效。下面我们可以使用存储过程结合临时表来解决这个问题。

存储过程+临时表

使用存储过程结合临时表的方案需要创建两个存储过程,一个用于递归查询所有节点并将数据写入临时表中,另一个负责创建临时表、清空临时表数据,触发查询调用动作。
首先,定义第一个存储过程,如下:

如上所示,逻辑比较简单。接下来定义第二个存储过程,如下;

使用方式如下

至此,我们在可以处理无限层级的树形结构数据。

MyBatis调用存储过程

MyBatis中我们可以使用如下方式对存储过程进行调用

需要指定statementTypeCALLABLE表示需要执行的是一个存储过程,statementType默认值为PREPARED

总结

存储过程和函数的方式虽然简化了代码处理逻辑,但是使用函数和存储过程也有其缺点,主要体现在函数和存储过程在线上业务中其性能不容易监控,针对慢查询优化等方面从DBA角度来讲不是那么方便,所以在使用函数和存储过程时需要进行相应的权衡。

0

Java 里 hashCode() 和 equals() 的相关问题整理

本章的内容主要解决下面几个问题:

equals() 的作用是什么

equals() 与 == 的区别是什么

hashCode() 的作用是什么

hashCode() 和 equals() 之间有什么联系?


第1部分 equals() 的作用

equals() 的作用是 用来判断两个对象是否相等

equals() 定义在JDK的Object.java中。通过判断两个对象的地址是否相等(即,是否是同一个对象)来区分它们是否相等。源码如下:

既然Object.java中定义了equals()方法,这就意味着所有的Java类都实现了equals()方法,所有的类都可以通过equals()去比较两个对象是否相等。 但是,我们已经说过,使用默认的“equals()”方法,等价于“==”方法。因此,我们通常会重写equals()方法:若两个对象的内容相等,则equals()方法返回true;否则,返回fasle。

下面根据“类是否覆盖equals()方法”,将它分为2类。
(01) 若某个类没有覆盖equals()方法,当它的通过equals()比较两个对象时,实际上是比较两个对象是不是同一个对象。这时,等价于通过“==”去比较这两个对象。
(02) 我们可以覆盖类的equals()方法,来让equals()通过其它方式比较两个对象是否相等。通常的做法是:若两个对象的内容相等,则equals()方法返回true;否则,返回fasle。

下面,举例对上面的2种情况进行说明。

1.  “没有覆盖equals()方法”的情况

代码如下 (EqualsTest1.java)


运行结果

结果分析

我们通过 p1.equals(p2) 来“比较p1和p2是否相等时”。实际上,调用的Object.java的equals()方法,即调用的 (p1==p2) 。它是比较“p1和p2是否是同一个对象”。
而由 p1 和 p2 的定义可知,它们虽然内容相同;但它们是两个不同的对象!因此,返回结果是false。

 

2. “覆盖equals()方法的情况

我们修改上面的EqualsTest1.java覆盖equals()方法

代码如下 (EqualsTest2.java)


运行结果

结果分析

我们在EqualsTest2.java 中重写了Person的equals()函数:当两个Person对象的 name 和 age 都相等,则返回true。
因此,运行结果返回true。

 

讲到这里,顺便说一下java对equals()的要求。有以下几点:

 

现在,再回顾一下equals()的作用:判断两个对象是否相等。当我们重写equals()的时候,可千万不好将它的作用给改变了!

 


第2部分 equals() 与 == 的区别是什么?

== : 它的作用是判断两个对象的地址是不是相等。即,判断两个对象是不试同一个对象。

equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况(前面第1部分已详细介绍过):
情况1,类没有覆盖equals()方法。则通过equals()比较该类的两个对象时,等价于通过“==”比较这两个对象。
情况2,类覆盖了equals()方法。一般,我们都覆盖equals()方法来两个对象的内容相等;若它们的内容相等,则返回true(即,认为这两个对象相等)。

 

下面,通过示例比较它们的区别。

代码如下

 

运行结果

结果分析

在EqualsTest3.java 中:
(01) p1.equals(p2)
这是判断p1和p2的内容是否相等。因为Person覆盖equals()方法,而这个equals()是用来判断p1和p2的内容是否相等,恰恰p1和p2的内容又相等;因此,返回true。

(02) p1==p2
这是判断p1和p2是否是同一个对象。由于它们是各自新建的两个Person对象;因此,返回false。

 


第3部分 hashCode() 的作用

hashCode() 的作用是获取哈希码,也称为散列码;它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在JDK的Object.java中,这就意味着Java中的任何类都包含有hashCode() 函数。
虽然,每个Java类都包含hashCode() 函数。但是,仅仅当创建并某个“类的散列表”(关于“散列表”见下面说明)时,该类的hashCode() 才有用(作用是:确定该类的每一个对象在散列表中的位置;其它情况下(例如,创建类的单个对象,或者创建类的对象数组等等),类的hashCode() 没有作用。
上面的散列表,指的是:Java集合中本质是散列表的类,如HashMap,Hashtable,HashSet。

也就是说:hashCode() 在散列表中才有用,在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码,进而确定该对象在散列表中的位置。

OK!至此,我们搞清楚了:hashCode()的作用是获取散列码。但是,散列码是用来干什么的呢?为什么散列表需要散列码呢?要解决这些问题,就需要理解散列表!关于散列表可以自行百度。

为了能理解后面的内容,这里简单的介绍一下散列码的作用。

下面,我们以HashSet为例,来深入说明hashCode()的作用。

假设,HashSet中已经有1000个元素。当插入第1001个元素时,需要怎么处理?因为HashSet是Set集合,它允许有重复元素。
“将第1001个元素逐个的和前面1000个元素进行比较”?显然,这个效率是相等低下的。散列表很好的解决了这个问题,它根据元素的散列码计算出元素在散列表中的位置,然后将元素插入该位置即可。对于相同的元素,自然是只保存了一个。
由此可知,若两个元素相等,它们的散列码一定相等;但反过来确不一定。在散列表中,
1、如果两个对象相等,那么它们的hashCode()值一定要相同;
2、如果两个对象hashCode()相等,它们并不一定相等。
注意:这是在散列表中的情况。在非散列表中一定如此!

 

对“hashCode()的作用”就谈这么多。

 


第4部分 hashCode() 和 equals() 的关系

接下面,我们讨论另外一个话题。网上很多文章将 hashCode() 和 equals 关联起来,有的讲的不透彻,有误导读者的嫌疑。在这里,我自己梳理了一下 “hashCode() 和 equals()的关系”。

我们以“类的用途”来将“hashCode() 和 equals()的关系”分2种情况来说明。

 

1. 第一种 不会创建“类对应的散列表”

这里所说的“不会创建类对应的散列表”是说:我们不会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中,用到该类。例如,不会创建该类的HashSet集合。

在这种情况下,该类的“hashCode() 和 equals() ”没有半毛钱关系的!
这种情况下,equals() 用来比较该类的两个对象是否相等。而hashCode() 则根本没有任何作用,所以,不用理会hashCode()。

下面,我们通过示例查看类的两个对象相等 以及 不等时hashCode()的取值。

源码如下 (NormalHashCodeTest.java):


运行结果

从结果也可以看出:p1和p2相等的情况下,hashCode()也不一定相等。

 

2. 第二种 会创建“类对应的散列表”

这里所说的“会创建类对应的散列表”是说:我们会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中,用到该类。例如,会创建该类的HashSet集合。

在这种情况下,该类的“hashCode() 和 equals() ”是有关系的:
1)、如果两个对象相等,那么它们的hashCode()值一定相同。
这里的相等是指,通过equals()比较两个对象时返回true。
2)、如果两个对象hashCode()相等,它们并不一定相等。
因为在散列表中,hashCode()相等,即两个键值对的哈希值相等。然而哈希值相等,并不一定能得出键值对相等。补充说一句:“两个不同的键值对,哈希值相等”,这就是哈希冲突。

此外,在这种情况下。若要判断两个对象是否相等,除了要覆盖equals()之外,也要覆盖hashCode()函数。否则,equals()无效。
例如,创建Person类的HashSet集合,必须同时覆盖Person类的equals() 和 hashCode()方法。
如果单单只是覆盖equals()方法。我们会发现,equals()方法没有达到我们想要的效果。

参考代码 (ConflictHashCodeTest1.java):


运行结果

结果分析

我们重写了Person的equals()。但是,很奇怪的发现:HashSet中仍然有重复元素:p1 和 p2。为什么会出现这种情况呢?

这是因为虽然p1 和 p2的内容相等,但是它们的hashCode()不等;所以,HashSet在添加p1和p2的时候,认为它们不相等。

 

下面,我们同时覆盖equals() 和 hashCode()方法。

参考代码 (ConflictHashCodeTest2.java):


运行结果

结果分析

这下,equals()生效了,HashSet中没有重复元素。
比较p1和p2,我们发现:它们的hashCode()相等,通过equals()比较它们也返回true。所以,p1和p2被视为相等。
比较p1和p4,我们发现:虽然它们的hashCode()相等;但是,通过equals()比较它们返回false。所以,p1和p4被视为不相等。

0

Java8 stream list 转 map 方法总结

list转map在Java8中stream的应用

1.利用Collectors.toMap方法进行转换

其中第一个参数就是可以,第二个参数就是value的值。

2.收集对象实体本身

在开发过程中我们也需要有时候对自己的list中的实体按照其中的一个字段进行分组(比如 id ->List),这时候要设置map的value值是实体本身。

account -> account是一个返回本身的lambda表达式,其实还可以使用Function接口中的一个默认方法 Function.identity(),这个方法返回自身对象,更加简洁

重复key的情况

在list转为map时,作为key的值有可能重复,这时候流的处理会抛出个异常:Java.lang.IllegalStateException:Duplicate key。这时候就要在toMap方法中指定当key冲突时key的选择。(这里是选择第二个key覆盖第一个key)

用groupingBy 或者 partitioningBy进行分组

根据一个字段或者属性分组也可以直接用groupingBy方法,很方便。

partitioningBy可以理解为特殊的groupingBy,key值为true和false,当然此时方法中的参数为一个判断语句(用于判断的函数式接口)

 

 

0

Mybatis的 resultmap collection 标签嵌套查询(select)跨不同xml的写法

业务需求:手机商城分页获取商品的全部规格信息和规格的全部选项值。

手机规格类名称:GoodsSpecification

规格选项值类名称:GoodsSpecificationOption

Mapper接口名称:
规格接口:AdminGoodsSpecificationMapper

规格选项接口:AdminGoodsSpecificationOptionMapper

mapper.xml文件:

规格接口映射xml文件:AdminGoodsSpecificationMapper.xml

规格选项接口映射xml文件:AdminGoodsSpecificationOptionMapper.xml

springbootTest测试类:

控制台打印结果:

总结:

collection标签中的select属性填写对应接口的包路径+方法名即可跨xml

0

Nacos Config 配置动态刷新@RefreshScope

动态刷新

Nacos Config Starter 默认为所有获取数据成功的 Nacos 的配置项添加了监听功能,在监听到服务端配置发生变化时会实时触发 org.springframework.cloud.context.refresh.ContextRefresher 的 refresh 方法 。

0

Reactor响应式编程(二)

简介

上篇文章我们简单的介绍了Reactor的发展史和基本的Flux和Mono的使用,本文将会进一步挖掘Reactor的高级用法,一起来看看吧。

自定义Subscriber

之前的文章我们提到了4个Flux的subscribe的方法:


这四个方法,需要我们使用lambda表达式来自定义consumer,errorConsumer,completeSonsumer和subscriptionConsumer这四个Consumer。

写起来比较复杂,看起来也不太方便,我们考虑一下,这四个Consumer是不是和Subscriber接口中定义的4个方法是一一对应的呢?


对的,所以我们有一个更加简单点的subscribe方法:


这个subscribe方法直接接收一个Subscriber类。从而实现了所有的功能。

自己写Subscriber太麻烦了,Reactor为我们提供了一个BaseSubscriber的类,它实现了Subscriber中的所有功能,还附带了一些其他的方法。

我们看下BaseSubscriber的定义:

注意,BaseSubscriber是单次使用的,这就意味着,如果它首先subscription到Publisher1,然后subscription到Publisher2,那么将会取消对第一个Publisher的订阅。

因为BaseSubscriber是一个抽象类,所以我们需要继承它,并且重写我们需要自己实现的方法。

下面看一个自定义的Subscriber:


BaseSubscriber中有很多以hook开头的方法,这些方法都是我们可以重写的,而Subscriber原生定义的on开头的方法,在BaseSubscriber中都是final的,都是不能重写的。

我们看一个定义:


可以看到,它内部实际上调用了hook的方法。

上面的CustSubscriber中,我们重写了两个方法,一个是hookOnSubscribe,在建立订阅的时候调用,一个是hookOnNext,在收到onNext信号的时候调用。

在这些方法中,给了我们足够的自定义空间,上面的例子中我们调用了request(1),表示再请求一个元素。

其他的hook方法还有: hookOnComplete, hookOnError, hookOnCancel 和 hookFinally。

Backpressure处理

我们之前讲过了,reactive stream的最大特征就是可以处理Backpressure。

什么是Backpressure呢?就是当consumer处理过不来的时候,可以通知producer来减少生产速度。

我们看下BaseSubscriber中默认的hookOnSubscribe实现:


可以看到默认是request无限数目的值。 也就是说默认情况下没有Backpressure。

通过重写hookOnSubscribe方法,我们可以自定义处理速度。

除了request之外,我们还可以在publisher中限制subscriber的速度。


在Flux中,我们有一个limitRate方法,可以设定publisher的速度。

比如subscriber request(100),然后我们设置limitRate(10),那么最多producer一次只会产生10个元素。

创建Flux

接下来,我们要讲解一下怎么创建Flux,通常来讲有4种方法来创建Flux。

使用generate

第一种方法就是最简单的同步创建的generate.

先看一个例子:


输出结果:


上面的例子中,我们使用generate方法来同步的生成元素。

generate接收两个参数:


第一个参数是stateSupplier,用来指定初始化的状态。

第二个参数是一个generator,用来消费SynchronousSink,并生成新的状态。

上面的例子中,我们每次将state+1,一直加到10。

然后使用subscribe来将所有的生成元素输出。

使用create

Flux也提供了一个create方法来创建Flux,create可以是同步也可以是异步的,并且支持多线程操作。

因为create没有初始的state状态,所以可以用在多线程中。

create的一个非常有用的地方就是可以将第三方的异步API和Flux关联起来,举个例子,我们有一个自定义的EventProcessor,当处理相应的事件的时候,会去调用注册到Processor中的listener的一些方法。


我们怎么把这个Listener的响应行为和Flux关联起来呢?


使用create就够了,create接收一个consumer参数:


这个consumer的本质是去消费FluxSink对象。

上面的例子在MyEventListener的事件中对FluxSink对象进行消费。

使用push

push和create一样,也支持异步操作,但是同时只能有一个线程来调用next, complete 或者 error方法,所以它是单线程的。

使用Handle

Handle和上面的三个方法不同,它是一个实例方法。

它和generate很类似,也是消费SynchronousSink对象。


不同的是它的参数是一个BiConsumer,是没有返回值的。

看一个使用的例子:

 

0

Reactor响应式编程(一)

简介

Reactor是reactivex家族的一个非常重要的成员,Reactor是第四代的reactive library,它是基于Reactive Streams标准基础上开发的,主要用来构建JVM环境下的非阻塞应用程序。

今天给大家介绍一下Reactor。

Reactor简介

Reactor是基于JVM的非阻塞API,他直接跟JDK8中的API相结合,比如:CompletableFuture,Stream和Duration等。

它提供了两个非常有用的异步序列API:Flux和Mono,并且实现了Reactive Streams的标准。

并且还可以和reactor-netty相结合,作为一些异步框架的底层服务,比如我们非常熟悉的Spring MVC 5中引入的WebFlux。

我们知道WebFlux的底层使用的是reactor-netty,而reactor-netty又引用了Reactor。所以,如果你在POM中引入了webFlux依赖:


那么项目将会自动引入Reactor。

如果你用的不是Spring webflux,没关系,你可以直接添加下面的依赖来使用Reactor:

reactive programming的发展史

最最开始的时候微软为.NET平台创建了Reactive Extensions (Rx) library。接着RxJava实现了JVM平台的Reactive。

然后Reactive Streams标准出现了,它定义了Java平台必须满足的的一些规范。并且已经集成到JDK9中的java.util.concurrent类中。

在Flow中定义了实现Reactive Streams的四个非常重要的组件,分别是Publisher,Subscriber,Subscription和Processor。

Iterable-Iterator 和Publisher-Subscriber的区别

一般来说reactive在面向对象的编程语言中是以观察者模式的扩展来使用的。

我们来具体看一下这个观察者模式的实现,以Publisher和Subscriber为例:


上面定义了两个接口,Publisher和Subscriber,Publisher的作用就是subscribe到subscriber。

而subscriber定义了4个on方法,用来触发特定的事件。

那么Publisher中的subscribe是怎么触发Subscriber的onSubscribe事件呢?

很简单,我们看一个具体的实现:


上面的例子是PullPublisher的subscribe实现。我们可以看到,在这个subscribe中触发了subscriber.onSubscribe方法。而这就是观察者模式的秘密。

或者说,当Publisher调用subscribe的时候,是主动push subscriber的onSubscribe方法。

熟悉Iterable-Iterator模式的朋友应该都知道,Iterator模式,其实是一个主动的pull模式,因为需要不断的去调用next()方法。所以它的控制权是在调用方。

为什么要使用异步reactive

在现代应用程序中,随着用户量的增多,程序员需要考虑怎么才能提升系统的处理能力。

传统的block IO的方式,因为需要占用大量的资源,所以是不适合这样的场景的。我们需要的是NO-block IO。

JDK中提供了两种异步编程的模型:

第一种是Callbacks,异步方法可以通过传入一个Callback参数的形式来在Callback中执行异步任务。比较典型的像是java Swing中的EventListener。

第二中就是使用Future了。我们使用Callable来提交一个任务,然后通过Future来拿到它的运行结果。

这两种异步编程会有什么问题呢?

callback的问题就在于回调地狱。熟悉JS的朋友应该很理解这个回调地狱的概念。

简单点讲,回调地狱就是在callback中又使用了callback,从而造成了这种callback的层级调用关系。

而Future主要是对一个异步执行的结果进行获取,它的 get()实际上是一个block操作。并且不支持异常处理,也不支持延迟计算。

当有多个Future的组合应该怎么处理呢?JDK8 实际上引入了一个CompletableFuture类,这个类是Future也是一个CompletionStage,CompletableFuture支持then的级联操作。不过CompletableFuture提供的方法不是那么的丰富,可能满足不了我的需求。

于是我们的Reactor来了。

Flux

Reactor提供了两个非常有用的操作,他们是 Flux 和 Mono。 其中Flux 代表的是 0 to N 个响应式序列,而Mono代表的是0或者1个响应式序列。

我们看一个Flux是怎么transfer items的:

Reactor响应式编程(一)

先看下Flux的定义:


可以看到Flux其实就是一个Publisher,用来产生异步序列。

Flux提供了非常多的有用的方法,来处理这些序列,并且提供了completion和error的信号通知。

相应的会去调用Subscriber的onNext, onComplete, 和 onError 方法。

Mono

我们看下Mono是怎么transfer items的:

Reactor响应式编程(一)

看下Mono的定义:


Mono和Flux一样,也是一个Publisher,用来产生异步序列。

Mono因为只有0或者1个序列,所以只会触发Subscriber的onComplete和onError方法,没有onNext。

另一方面,Mono其实可以看做Flux的子集,只包含Flux的部分功能。

Mono和Flux是可以互相转换的,比如Mono#concatWith(Publisher)返回一个Flux,而 Mono#then(Mono)返回一个Mono.

Flux和Mono的基本操作

我们看下Flux创建的例子:


可以看到Flux提供了很多种创建的方式,我们可以自由选择。

再看看Flux的subscribe方法:


subscribe可以一个参数都没有,也可以多达4个参数。

看下没有参数的情况:

注意,没有参数并不表示Flux的对象不被消费,只是不可见而已。

看下带参数的情况:consumer用来处理on each事件,errorConsumer用来处理on error事件,completeConsumer用来处理on complete事件,subscriptionConsumer用来处理on subscribe事件。

前面的3个参数很好理解,我们来举个例子:


我们构建了从1到4的四个整数的Flux,on each就是打印出来,如果中间有错误的话,就输出Error,全部完成就输出Done。

那么最后一个subscriptionConsumer是做什么用的呢?

subscriptionConsumer accept的是一个Subscription对象,我们看下Subscription的定义:


Subscription 定义了两个方法,用来做初始化用的,我们可以调用request(n)来决定这次subscribe获取元素的最大数目。

比如上面我们的例子中,虽然构建了4个整数,但是最终输出的只有2个。

上面所有的subscribe方法,都会返回一个Disposable对象,我们可以通过Disposable对象的dispose()方法,来取消这个subscribe。

Disposable只定义了两个方法:


dispose的原理是向Flux 或者 Mono发出一个停止产生新对象的信号,但是并不能保证对象产生马上停止。

有了Disposable,当然要介绍它的工具类Disposables。

Disposables.swap() 可以创建一个Disposable,用来替换或者取消一个现有的Disposable。

Disposables.composite(…​)可以将多个Disposable合并起来,在后面统一做处理。

总结

本文介绍了Reactor的基本原理和两非常重要的组件Flux和Mono,下一篇文章我们会继续介绍Reactor core的一些更加高级的用法。敬请期待。

0