SpringBoot整合分布式消息平台Pulsar

开发 前端 分布式
从 SpringBoot 整合 Java 客户端使用来看,Pulsar 的 api 是非常友好的,使用起来方便简洁。Consumer 的使用需要考虑多一些,需要考虑到批量、异步以及订阅类型。

大家好,我是君哥。

作为优秀的消息流平台,Pulsar 的使用越来越多,这篇文章讲解 Pulsar 的 Java 客户端。

部署 Pulsar

Pulsar 的部署方式主要有 3 种,本地安装二进制文件、docker 部署、在 Kubernetes 上部署。

本文采用 docker 部署一个单节点的 Pulsar 集群。实验环境是 2 核 CPU 和 4G 内存。

部署命令如下:

  1. docker run -it -p 6650:6650  -p 8080:8080 --mount source=pulsardata,target=/pulsar/data --mount source=pulsarconf,target=/pulsar/conf apachepulsar/pulsar:2.9.1 bin/pulsar standalone 

安装过程可能会出现下面的错误:

  1. unknown flag: --mount 
  2. See 'docker run --help'

这是因为 docker 版本低,不支持 mount 参数,把 docker 版本升级到 17.06 以上就可以了。

部署过程中可能会因为网络的原因失败,多试几次就可以成功了。如果看到下面的日志,就说明启动成功了。

  1. 2022-01-08T22:27:58,726+0000 [main] INFO  org.apache.pulsar.broker.PulsarService - messaging service is ready, bootstrap service port = 8080, broker url= pulsar://localhost:6650, cluster=standalone 

本地单节点集群启动后,会创建一个 namespace,名字叫 public/default

Pulsar 客户端

目前 Pulsar 支持多种语言的客户端,包括:

Java 客户端Go 客户端Python 客户端C++ 客户端Node.js 客户端WebSocket 客户端C# 客户端

SpringBoot 配置

使用 SpringBoot 整合 Pulsar 客户端,首先引入 Pulsar 客户端依赖,代码如下:

  1. <dependency> 
  2.     <groupId>org.apache.pulsar</groupId> 
  3.     <artifactId>pulsar-client</artifactId> 
  4.     <version>2.9.1</version> 
  5. </dependency> 

然后在 properties 文件中添加配置:

  1. # Pulsar 地址 
  2. pulsar.url=pulsar://192.168.59.155:6650 
  3. # topic 
  4. pulsar.topic=testTopic 
  5. # consumer group 
  6. pulsar.subscription=topicGroup 

创建 Client

创建客户端非常简单,代码如下:

  1. client = PulsarClient.builder() 
  2.                 .serviceUrl(url) 
  3.                 .build(); 

上面的 url 就是 properties 文件中定义的 pulsar.url 。

创建 Client 时,即使集群没有启成功,程序也不会报错,因为这时还没有真正地去连接集群。

创建 Producer

  1. producer = client.newProducer() 
  2.                 .topic(topic) 
  3.                 .compressionType(CompressionType.LZ4) 
  4.                 .sendTimeout(0, TimeUnit.SECONDS) 
  5.                 .enableBatching(true
  6.                 .batchingMaxPublishDelay(10, TimeUnit.MILLISECONDS) 
  7.                 .batchingMaxMessages(1000) 
  8.                 .maxPendingMessages(1000) 
  9.                 .blockIfQueueFull(true
  10.                 .roundRobinRouterBatchingPartitionSwitchFrequency(10) 
  11.                 .batcherBuilder(BatcherBuilder.DEFAULT
  12.                 .create(); 

创建 Producer,会真正的连接集群,这时如果集群有问题,就会报连接错误。

下面解释一下创建 Producer 的参数:

topic:Producer 要写入的 topic。

compressionType:压缩策略,目前支持 4 种策略 (NONE、LZ4、ZLIB、ZSTD),从 Pulsar2.3 开始,只有 Consumer 的版本在 2.3 以上,这个策略才会生效。

sendTimeout:超时时间,如果 Producer 在超时时间为收到 ACK,会进行重新发送。

enableBatching:是否开启消息批量处理,这里默认 true,这个参数只有在异步发送 (sendAsync) 时才能生效,选择同步发送会失效。

batchingMaxPublishDelay:批量发送消息的时间段,这里定义的是 10ms,需要注意的是,设置了批量时间,就不会受消息数量的影响。批量发送会把要发送的批量消息放在一个网络包里发送出去,减少网络 IO 次数,大大提高网卡的发送效率。

batchingMaxMessages:批量发送消息的最大数量。

maxPendingMessages:等待从 broker 接收 ACK 的消息队列最大长度。如果这个队列满了,producer 所有的 sendAsync 和 send 都会失败,除非设置了 blockIfQueueFull 值是 true。

blockIfQueueFull:Producer 发送消息时会把消息先放入本地 Queue 缓存,如果缓存满了,就会阻塞消息发送。

roundRobinRouterBatchingPartition-SwitchFrequency:如果发送消息时没有指定 key,那默认采用 round robin 的方式发送消息,使用 round robin 的方式,切换 partition 的周期是 (frequency * batchingMaxPublishDelay)。

创建 Consumer

Pulsar 的消费模型如下图:

从图中可以看到,Consumer 要绑定一个 subscription 才能进行消费。

  1. consumer = client.newConsumer() 
  2.         .topic(topic) 
  3.         .subscriptionName(subscription) 
  4.         .subscriptionType(SubscriptionType.Shared) 
  5.         .subscriptionInitialPosition(SubscriptionInitialPosition.Earliest) 
  6.         .negativeAckRedeliveryDelay(60, TimeUnit.SECONDS) 
  7.         .receiverQueueSize(1000) 
  8.         .subscribe(); 

下面解释一下创建 Consumer 的参数:

topic:Consumer 要订阅的 topic。

subscriptionName:consumer 要关联的 subscription 名字。

subscriptionType:订阅类型,Pulsar 支持四种类型订阅:

Exclusive:独占模式,同一个 Topic 只能有一个消费者,如果多个消费者,就会出错。Failover:灾备模式,同一个 Topic 可以有多个消费者,但是只能有一个消费者消费,其他消费者作为故障转移备用,如果当前消费者出了故障,就从备用消费者中选择一个进行消费。如下图:

Shared:共享模式,同一个 Topic 可以由多个消费者订阅和消费。消息通过 round robin 轮询机制分发给不同的消费者,并且每个消息仅会被分发给一个消费者。当消费者断开,如果发送给它消息没有被消费,这些消息会被重新分发给其它存活的消费者。如下图:

Key_Shared:消息和消费者都会绑定一个key,消息只会发送给绑定同一个key的消费者。如果有新消费者建立连接或者有消费者断开连接,就需要更新一些消息的 key。跟 Shared 模式相比,Key_Shared 的好处是既可以让消费者并发地消费消息,又能保证同一Key下的消息顺序。如下图:

subscriptionInitialPosition:创建新的 subscription 时从哪里开始消费,有两个选项:

Latest:从最新的消息开始消费Earliest:从最早的消息开始消费

negativeAckRedeliveryDelay:消费失败后间隔多久 broker 重新发送。

receiverQueueSize:在调用 receive 方法之前,最多能累积多少条消息。可以设置为 0,这样每次只从 broker 拉取一条消息。在 Shared 模式下,receiverQueueSize 设置为 0,可以防止批量消息多发给一个 Consumer 而导致其他 Consumer 空闲。

Consumer 接收消息有四种方式:同步单条、同步批量、异步单条和异步批量,代码如下:

  1. Message message = consumer.receive() 
  2. CompletableFuture<Message> message = consumer.receiveAsync(); 
  3. Messages message = consumer.batchReceive(); 
  4. CompletableFuture<Messages> message = consumer.batchReceiveAsync(); 

对于批量接收,也可以设置批量接收的策略,代码如下:

  1. consumer = client.newConsumer() 
  2.     .topic(topic) 
  3.     .subscriptionName(subscription) 
  4.         .batchReceivePolicy(BatchReceivePolicy.builder() 
  5.         .maxNumMessages(100) 
  6.         .maxNumBytes(1024 * 1024) 
  7.         .timeout(200, TimeUnit.MILLISECONDS) 
  8.         .build()) 
  9.     .subscribe(); 

代码中的参数说明如下:

maxNumMessages:批量接收的最大消息数量。maxNumBytes:批量接收消息的大小,这里是 1MB。

测试

首先编写 Producer 发送消息的代码,如下:

  1. public void sendMsg(String key, String data) { 
  2.     CompletableFuture<MessageId> future = producer.newMessage() 
  3.         .key(key
  4.         .value(data.getBytes()).sendAsync(); 
  5.     future.handle((v, ex) -> { 
  6.         if (ex == null) { 
  7.             logger.info("发送消息成功, key:{}, msg: {}"key, data); 
  8.         } else { 
  9.             logger.error("发送消息失败, key:{}, msg: {}"key, data); 
  10.         } 
  11.         return null
  12.     }); 
  13.     future.join(); 
  14.     logger.info("发送消息完成, key:{}, msg: {}"key, data); 

然后编写一个 Consumer 消费消息的代码,如下:

  1. public void start() throws Exception{ 
  2.     while (true) { 
  3.         Message message = consumer.receive(); 
  4.         String key = message.getKey(); 
  5.         String data = new String(message.getData()); 
  6.         String topic = message.getTopicName(); 
  7.         if (StringUtils.isNotEmpty(data)) { 
  8.             try{ 
  9.                 logger.info("收到消息, topic:{}, key:{}, data:{}", topic, key, data); 
  10.             }catch(Exception e){ 
  11.                 logger.error("接收消息异常,topic:{}, key:{}, data:{}", topic, key, data, e); 
  12.             } 
  13.         } 
  14.         consumer.acknowledge(message); 
  15.     } 

最后编写一个 Controller 类,调用 Producer 发送消息,代码如下:

  1. @RequestMapping("/send"
  2. @ResponseBody 
  3. public String send(@RequestParam String key, @RequestParam String data) { 
  4.     logger.info("收到消息发送请求, key:{}, value:{}"key, data); 
  5.     pulsarProducer.sendMsg(key, data); 
  6.     return "success"

调用 Producer 发送一条消息,key=key1,data=data1,具体操作为在浏览器中输入下面的 url 后回车:

  1. http://192.168.157.1:8083/pulsar/send?key=key1&data=data1 

可以看到控制台输出下面日志:

  1. 2022-01-08 22:42:33,199 [pulsar-client-io-6-1] [INFO] boot.pulsar.PulsarProducer - 发送消息成功, key:key1, msg: data1 
  2. 2022-01-08 22:42:33,200 [http-nio-8083-exec-1] [INFO] boot.pulsar.PulsarProducer - 发送消息完成, key:key1, msg: data1 
  3. 2022-01-08 22:42:33,232 [Thread-22] [INFO] boot.pulsar.PulsarConsumer - 收到消息, topic:persistent://public/default/testTopic, key:key1, data:data1 
  4. 2022-01-08 22:43:14,498 [pulsar-timer-5-1] [INFO] org.apache.pulsar.client.impl.ConsumerStatsRecorderImpl - [testTopic] [topicGroup] [7def6] Prefetched messages: 0 --- Consume throughput received: 0.02 msgs/s --- 0.00 Mbit/s --- Ack sent rate: 0.02 ack/s --- Failed messages: 0 --- batch messages: 0 ---Failed acks: 0 
  5. 2022-01-08 22:43:14,961 [pulsar-timer-9-1] [INFO] org.apache.pulsar.client.impl.ProducerStatsRecorderImpl - [testTopic] [standalone-9-0] Pending messages: 0 --- Publish throughput: 0.02 msg/s --- 0.00 Mbit/s --- Latency: med: 69.000 ms - 95pct: 69.000 ms - 99pct: 69.000 ms - 99.9pct: 69.000 ms - max: 69.000 ms --- Ack received rate: 0.02 ack/s --- Failed messages: 0 

从日志中看到,这里使用的 namespace 就是创建集群时生成的public/default。

总结

从 SpringBoot 整合 Java 客户端使用来看,Pulsar 的 api 是非常友好的,使用起来方便简洁。Consumer 的使用需要考虑多一些,需要考虑到批量、异步以及订阅类型。

 

责任编辑:姜华 来源: 君哥聊技术
相关推荐

2023-01-13 07:39:07

2023-07-18 07:23:46

分布式消息工具

2022-06-27 08:21:05

Seata分布式事务微服务

2023-01-04 09:23:58

2017-07-27 14:32:05

大数据分布式消息Kafka

2020-05-18 14:00:01

Dubbo分布式架构

2022-12-13 09:19:26

分布式消息队列

2023-02-28 07:01:11

分布式缓存平台

2019-09-05 09:02:45

消息系统缓存高可用

2022-06-28 08:37:07

分布式服务器WebSocket

2021-07-14 07:17:37

Springboot分布式UIDGenerato

2017-08-30 16:47:49

Kafka设计原理

2023-07-26 07:28:55

WebSocket服务器方案

2023-09-04 08:12:16

分布式锁Springboot

2023-07-25 09:52:00

本地事务宕机

2020-12-09 09:14:57

SpringCloudSeata 分布式

2019-10-10 09:16:34

Zookeeper架构分布式

2023-08-27 22:13:59

Redisson分布式缓存

2017-09-01 05:35:58

分布式计算存储
点赞
收藏

51CTO技术栈公众号