SpringBoot集成Pulsar 生产者与消费者示例代码

七维大脑

已于 2023-11-02 11:12:56 修改

阅读量2.8k

点赞数 1

分类专栏：技术&解决方案分享文章标签： java 中间件

于 2022-04-16 22:44:12 首次发布

本文链接：https://blog.csdn.net/weixin_52799373/article/details/124222022

版权

技术&解决方案分享专栏收录该内容

30 篇文章 5 订阅

订阅专栏

介绍

Pulsar 是一个多租户、高性能的服务器到服务器消息传递解决方案。Pulsar 最初由 Yahoo 开发，由 Apache 软件基金会管理。

功能特点

Pulsar 的主要功能如下：

原生支持 Pulsar 实例中的多个集群，并可跨集群无缝地复制消息。
非常低的发布和端到端延迟。
无缝扩展到超过一百万个主题。
一个简单的客户端 API，绑定了 Java、Go、Python 和 C++。
主题的多种订阅类型（独占、共享和故障转移）。
通过 Apache BookKeeper 提供的持久性消息存储来保证消息传递。无服务器轻量级计算框架 Pulsar Functions 提供了流原生数据处理的能力。
基于 Pulsar Functions 构建的无服务器连接器框架 Pulsar IO 可以更轻松地将数据移入和移出 Apache Pulsar。
当数据老化时，分层存储将数据从热/温存储卸载到冷/长期存储（如 S3 和 GCS）。

在这里插入图片描述

详细介绍请看官方文档：https://pulsar.apache.org/docs/

一、导入pulsar依赖

<dependency>
    <groupId>org.apache.pulsar</groupId>
    <artifactId>pulsar-client</artifactId>
    <version>2.9.2</version>
</dependency>

二、pulsar配置（示例为yml文件）

# pulsar配置
pulsar:
  # pulsar服务端地址
  url: pulsar://192.168.0.1:30000
  # 多个topic以逗号分隔
  topic: topic1,topic2
  # 消费者组
  subscription: topicGroup

三、生产者示例代码

enableBatching(true) 是否开启批量处理消息，默认true,需要注意的是enableBatching只在异步发送sendAsync生效，同步发送send失效。因此建议生产环境若想使用批处理，则需使用异步发送，或者多线程同步发送
compressionType(CompressionType.LZ4) //消息压缩（四种压缩方式：LZ4，ZLIB，ZSTD，SNAPPY），consumer端不用做改动就能消费，开启后大约可以降低3/4带宽消耗和存储（官方测试）
batchingMaxPublishDelay(10, TimeUnit.MILLISECONDS) 设置将对发送的消息进行批处理的时间段,10ms；可以理解为若该时间段内批处理成功，则一个batch中的消息数量不会被该参数所影响。
sendTimeout(0, TimeUnit.SECONDS) 设置发送超时0s；如果在sendTimeout过期之前服务器没有确认消息，则会发生错误。默认30s，设置为0代表无限制，建议配置为0
batchingMaxMessages(1000) 批处理中允许的最大消息数。默认1000
maxPendingMessages(1000) 设置等待接受来自broker确认消息的队列的最大大小，默认1000
blockIfQueueFull(true) 设置当消息队列中等待的消息已满时，Producer.send 和 Producer.sendAsync 是否应该block阻塞。默认为false，达到maxPendingMessages后send操作会报错，设置为true后，send操作阻塞但是不报错。建议设置为true
roundRobinRouterBatchingPartitionSwitchFrequency(10) 向不同partition分发消息的切换频率，默认10ms，可根据batch情况灵活调整
batcherBuilder(BatcherBuilder.DEFAULT) key_Shared模式要用KEY_BASED,才能保证同一个key的message在一个batch里

@Component
public class TestPulsarProducer {
 
    private static final Logger log = LoggerFactory.getLogger(TestPulsarProducer.class);
 
    @Value("${pulsar.url}")
    private String url;
    @Value("${pulsar.topic}")
    private String topic;
 
    PulsarClient client = null;
    Producer<byte[]> producer = null;
 
    @PostConstruct
    public void initPulsar() throws Exception{
        //构造Pulsar client
        client = PulsarClient.builder()
                .serviceUrl(url)
                .build();
 
        //创建producer
        producer = client.newProducer()
                .topic(topic.split(",")[0])
                .enableBatching(true)
                .compressionType(CompressionType.LZ4)
                .batchingMaxPublishDelay(10, TimeUnit.MILLISECONDS) 
                .sendTimeout(0, TimeUnit.SECONDS)
                .batchingMaxMessages(1000)
                .maxPendingMessages(1000)
                .blockIfQueueFull(true)
                .roundRobinRouterBatchingPartitionSwitchFrequency(10)
                .batcherBuilder(BatcherBuilder.DEFAULT)
                .create();
 
    }
 
    public void sendMsg(String key, String data){
        CompletableFuture<MessageId> future = producer.newMessage()
                .key(key)
                .value(data.getBytes()).sendAsync();//异步发送
        future.handle((v, ex) -> {
            if (ex == null) {
                log.info("Message persisted2: {}", data);
            } else {
                log.error("发送Pulsar消息失败msg:【{}】 ", data, ex);
            }
            return null;
        });
        // future.join();
        log.info("Message persisted: {}", data);
    }
 
}

四、消费者代码

subscriptionType(SubscriptionType.Shared) 指定消费模式，包含：Exclusive，Failover，Shared，Key_Shared。默认Exclusive模式
subscriptionInitialPosition(SubscriptionInitialPosition.Earliest) 指定从哪里开始消费还有Latest，valueof可选，默认Latest
.negativeAckRedeliveryDelay(60, TimeUnit.SECONDS) 指定消费失败后延迟多久broker重新发送消息给consumer，默认60s

@Component
public class AlarmPulsarConsumer {
 
    private static final Logger log = LoggerFactory.getLogger(AlarmPulsarConsumer.class);
 
    @Value("${pulsar.url}")
    private String url;
    @Value("${pulsar.topic}")
    private String topic;
    @Value("${pulsar.subscription}")
    private String subscription;
 
 
    private PulsarClient client = null;
    private Consumer consumer = null;
 
    /**
     * 使用@PostConstruct注解用于在依赖关系注入完成之后需要执行的方法上，以执行任何初始化
     */
    @PostConstruct
    public void initPulsar() throws Exception{
        try{
            //构造Pulsar client
            client = PulsarClient.builder()
                    .serviceUrl(url)
                    .build();
 
            //创建consumer
            consumer = client.newConsumer()
                    .topic(topic.split(","))
                    .subscriptionName(subscription)
                    .subscriptionType(SubscriptionType.Shared)
                    .subscriptionInitialPosition(SubscriptionInitialPosition.Earliest)
                    .negativeAckRedeliveryDelay(60, TimeUnit.SECONDS)
                    .subscribe();
 
            // 开始消费
            new Thread(()->{
                AlarmPulsarConsumer alarmPulsarConsumer = SpringUtils.getBean(AlarmPulsarConsumer.class);
                try{
                    alarmPulsarConsumer.start();
                }catch(Exception e){
                    log.error("消费Pulsar数据异常，停止Pulsar连接：", e);
                    alarmPulsarConsumer.close();
                }
            }).start();
 
        }catch(Exception e){
            log.error("Pulsar初始化异常：",e);
            throw e;
        }
    }
 
    private void start() throws Exception{
        //消费消息
        while (true) {
            Message message = consumer.receive();
            String[] keyArr = message.getKey().split("_");
            String jsons = new String(message.getData());
          
            if (StringUtils.isNotEmpty(json)) {
                try{
                    wsSend(type, strategyId, camId, camTime, json,depId,alarmType,target);
                }catch(Exception e){
                    log.error("消费Pulsar数据异常，key【{}】，json【{}】：", message.getKey(), json, e);
                }
            }
            consumer.acknowledge(message);
        }
    }

异步线程（伪代码），使用@Async，调用方和被调用方不能在一个类中

/**
     * 线程池异步处理Pulsar推送的数据
     *
     * @param camTime
     * @param type
     * @param camId
     * @param json
     */
//    @Async("threadPoolTaskExecutor")
    public void wsSend(Integer type, Integer strategyId, String camId, Long camTime, String json,Long depId,Integer alarmType,Integer target) {
       
    }
 
 
    public void close(){
        try {
            consumer.close();
        } catch (PulsarClientException e) {
            log.error("关闭Pulsar消费者失败：",e);
        }
        try {
            client.close();
        } catch (PulsarClientException e) {
            log.error("关闭Pulsar连接失败：",e);
        }
    }
 
}