java实现消息队列的两种方式 java消息队列异步处理任务

在java中操作pulsar消息队列需掌握客户端api的异步特性及消息生产与消费模式。1. 引入pulsar客户端依赖；2. 初始化pulsarclient，配置serviceurl、iothreads、listenerthreads等参数；3. 创建生产者并配置批量发送、发送超时、压缩类型等参数以提升吞吐量和可靠性；4. 创建消费者并选择合适的订阅模式（exclusive、shared、failover、key_shared）以满足不同业务场景对顺序性、并发性和高可用性的需求；5. 使用schema实现端到端类型安全，通过schema.json或schema.avro等指定数据结构，避免运行时错误并简化开发；6. 正确处理消息确认机制（acknowledge、negativeacknowledge）以确保消息可靠投递。合理配置各项参数并结合实际业务需求选择合适的消息模型，是高效使用pulsar的关键。

在Java中操作Pulsar消息队列，核心在于理解其客户端API的异步特性以及消息的生产与消费模式。这不单单是调用几个方法那么简单，更深层次地，它关乎你如何设计消息流、处理并发、确保数据一致性，以及应对各种网络和服务端异常。在我看来，Pulsar的Java客户端设计得相当成熟，提供了一套强大而灵活的工具集，但要真正用好它，得跳出传统思维，拥抱异步编程范式。

要构建一个完整的Java Pulsar消息操作方案，我们通常会从依赖引入开始，然后依次是客户端初始化、生产者配置与消息发送、消费者订阅与消息处理，以及一些高级特性如Schema的使用和错误处理。

首先，你得在项目的pom.xml（如果你用Maven）或build.gradle（如果你用Gradle）中引入Pulsar客户端库：

立即学习“Java免费学习笔记（深入）”；

<!-- Maven --><dependency>    <groupId>org.apache.pulsar</groupId>    <artifactId>pulsar-client-java</artifactId>    <version>2.11.0</version> <!-- 根据实际情况选择最新稳定版 --></dependency>

接着，是Pulsar客户端的初始化。这是一个重量级对象，通常在应用启动时创建一次，并复用。

import org.apache.pulsar.client.api.PulsarClient;import org.apache.pulsar.client.api.PulsarClientException;import org.apache.pulsar.client.api.Schema;import org.apache.pulsar.client.api.Producer;import org.apache.pulsar.client.api.Consumer;import org.apache.pulsar.client.api.SubscriptionType;import org.apache.pulsar.client.api.Message;import org.apache.pulsar.client.api.Messages;import java.util.concurrent.TimeUnit;import java.util.concurrent.CompletableFuture;public class PulsarOperation {    private static PulsarClient client;    private static final String SERVICE_URL = "pulsar://localhost:6650"; // 你的Pulsar服务地址    private static final String TOPIC_NAME = "persistent://public/default/my-java-topic";    private static final String SUBSCRIPTION_NAME = "my-java-subscription";    static {        try {            client = PulsarClient.builder()                    .serviceUrl(SERVICE_URL)                    .connectionTimeout(30, TimeUnit.SECONDS) // 连接超时                    .ioThreads(8) // IO线程数，根据实际负载调整                    .listenerThreads(8) // 监听线程数，用于处理回调                    .enableTcpNoDelay(true) // 启用TCP_NODELAY                    // .authentication(AuthenticationFactory.token("YOUR_TOKEN")) // 如果需要认证                    .build();            System.out.println("Pulsar client initialized successfully.");        } catch (PulsarClientException e) {            System.err.println("Failed to initialize Pulsar client: " + e.getMessage());            e.printStackTrace();            // 生产环境应有更健壮的错误处理        }    }    // 生产者示例    public void produceMessages() throws PulsarClientException {        // 使用Schema.STRING，也可以是Schema.JSON(MyObject.class), Schema.AVRO等        Producer<String> producer = client.newProducer(Schema.STRING)                .topic(TOPIC_NAME)                .producerName("my-java-producer")                .enableBatching(true) // 启用批量发送                .batchingMaxMessages(1000) // 批处理最大消息数                .batchingMaxPublishDelay(10, TimeUnit.MILLISECONDS) // 批处理最大延迟                .sendTimeout(30, TimeUnit.SECONDS) // 发送超时                .blockIfQueueFull(true) // 如果发送队列满了，则阻塞                .create();        for (int i = 0; i < 10; i++) {            String message = "Hello Pulsar from Java " + i;            // 异步发送，推荐方式            producer.sendAsync(message)                    .thenAccept(msgId -> System.out.println("Message sent: " + message + ", ID: " + msgId))                    .exceptionally(ex -> {                        System.err.println("Failed to send message: " + message + ", Error: " + ex.getMessage());                        return null;                    });            // 同步发送，会阻塞当前线程直到消息发送成功或失败            // try {            //     MessageId msgId = producer.send(message);            //     System.out.println("Message sent synchronously: " + message + ", ID: " + msgId);            // } catch (PulsarClientException e) {            //     System.err.println("Failed to send message synchronously: " + message + ", Error: " + e.getMessage());            // }        }        // 确保所有异步消息发送完成        producer.flush();        producer.close(); // 生产环境通常不会立即关闭，而是复用    }    // 消费者示例    public void consumeMessages() throws PulsarClientException {        Consumer<String> consumer = client.newConsumer(Schema.STRING)                .topic(TOPIC_NAME)                .subscriptionName(SUBSCRIPTION_NAME)                .subscriptionType(SubscriptionType.Shared) // 订阅类型，Shared, Exclusive, Failover, Key_Shared                .messageListener((cons, msg) -> { // 使用消息监听器异步处理                    try {                        System.out.println("Received message: " + msg.getValue() + " (ID: " + msg.getMessageId() + ")");                        cons.acknowledge(msg); // 确认消息，表示处理成功                    } catch (Exception e) {                        System.err.println("Error processing message: " + msg.getValue() + ", " + e.getMessage());                        cons.negativeAcknowledge(msg); // 负确认，消息会被重新投递                    }                })                .subscribe();        System.out.println("Consumer started. Press Ctrl+C to exit.");        // 保持主线程运行，以便消费者可以持续接收消息        try {            Thread.currentThread().join();        } catch (InterruptedException e) {            Thread.currentThread().interrupt();        } finally {            consumer.close();        }    }    public static void main(String[] args) throws PulsarClientException, InterruptedException {        PulsarOperation op = new PulsarOperation();        // 生产消息        System.out.println("--- Producing messages ---");        op.produceMessages();        Thread.sleep(2000); // 等待消息发送完成        // 消费消息        System.out.println("--- Consuming messages ---");        op.consumeMessages();        // 应用关闭时关闭客户端        if (client != null) {            client.close();            System.out.println("Pulsar client closed.");        }    }}

这只是一个基础框架，实际应用中会涉及更复杂的逻辑，比如异常重试、死信队列、事务消息、多租户管理等等。

高效地配置Pulsar客户端和生产者，不仅仅是设置几个参数那么简单，它更像是一门艺术，需要在吞吐量、延迟和资源消耗之间找到一个平衡点。我个人在实践中，发现很多性能问题其实都出在初始配置上。

对于PulsarClient，核心在于serviceUrl的正确性，以及ioThreads和listenerThreads的合理分配。ioThreads主要处理网络IO，而listenerThreads则处理消息回调，比如消费者收到消息后的处理逻辑。如果你有大量的消息处理逻辑，listenerThreads设得太少，可能会成为瓶颈。此外，connectionTimeout和operationTimeout也挺关键，它们决定了客户端在网络不稳定时能有多大的容忍度。我通常会把connectionTimeout设置得稍微长一些，比如30秒，给Pulsar集群足够的启动时间或者网络抖动恢复时间。

至于生产者，它的配置选项就更多了，直接影响到消息发送的效率和可靠性。

批量发送 (enableBatching, batchingMaxMessages, batchingMaxPublishDelay): 这是提升吞吐量的杀手锏。将多条小消息打包成一个批次发送，可以显著减少网络往返次数和CPU开销。batchingMaxMessages控制批次大小，batchingMaxPublishDelay控制批次的最大等待时间。我的经验是，如果你对延迟不那么敏感，可以适当增加batchingMaxPublishDelay来换取更高的吞吐量。但如果追求低延迟，就需要权衡了。

发送超时 (sendTimeout): 这是一个非常重要的参数。如果消息在指定时间内没有收到Pulsar的确认，就会被认为是发送失败。设置一个合理的超时时间，既能避免长时间阻塞，又能给Pulsar足够的处理时间。我通常会根据网络状况和Pulsar集群的负载情况来调整，比如5秒到30秒不等。

发送队列满时的行为 (blockIfQueueFull): 当内部发送队列满了之后，生产者可以选择阻塞当前线程，或者立即失败。blockIfQueueFull(true)在消息积压时会阻塞调用线程，这在某些场景下可以作为一种简单的流量控制手段，避免瞬时流量过大压垮生产者。但如果你的应用对延迟非常敏感，或者需要快速失败，那么可能需要考虑设置为false并实现自己的重试逻辑。

消息路由模式 (messageRoutingMode): 对于分区Topic，Pulsar提供了多种路由模式，比如RoundRobinPartition（轮询）和SinglePartition（单分区）。如果你需要保证某个Key的消息始终发送到同一个分区以保持严格的顺序，那么HashingStickinessConsistentHashing或自定义MessageRouter就显得非常重要。

压缩 (compressionType): 对于大消息或者对网络带宽敏感的场景，启用消息压缩（如LZ4, ZSTD）能有效减少网络传输量。这虽然会增加一些CPU开销，但通常是值得的。

这些参数的组合使用，就像调配一杯咖啡，需要根据你应用的具体需求和Pulsar集群的实际负载来反复尝试和优化。没有一劳永逸的最佳配置，只有最适合你当前场景的配置。

Pulsar的订阅模式（Subscription Type）是其区别于其他MQ的一个亮点，它提供了非常灵活的消息分发策略，但也常常是新手容易混淆的地方。正确选择订阅模式是确保消息按预期被处理的关键，这直接影响到你的消费者应用如何扩展、如何处理故障。

Pulsar提供了四种主要的订阅模式：

Exclusive (独占模式): 这是最严格的模式。一个订阅只能有一个消费者连接到它。如果有多个消费者尝试连接同一个订阅，只有第一个会成功，其他会失败。这非常适合需要严格消息顺序的场景，或者当一个消息只能被一个消费者处理时。它的优点是简单，消息顺序有保证，但缺点是无法横向扩展，存在单点故障。我个人在做一些关键业务的审计日志处理时，会倾向于使用这种模式，确保每一条日志都按顺序被一个且仅一个处理器消费。

Shared (共享模式): 这是最常用的模式，也是实现负载均衡和高吞吐量的首选。一个订阅可以有多个消费者连接，Puler会轮询地将消息分发给这些消费者。消息的顺序性在分区级别无法保证（因为不同消息可能由不同消费者处理），但在单个消费者内部，通常还是有序的。它的优点是高可用、易于扩展，缺点是消息处理顺序不严格。大部分的微服务异步通信，我都会选择Shared模式。

Failover (灾备模式): 这种模式下，一个订阅也可以有多个消费者连接，但只有一个是"主"消费者，负责接收所有消息。其他消费者处于"备用"状态。当主消费者发生故障时，Pulsar会自动从备用消费者中选举一个新的主消费者来接管消息流。它提供了高可用性，同时又能在一定程度上保持消息的顺序性（在主消费者切换前）。这很适合那些需要高可用但又不能完全放弃顺序性的场景，比如一些状态机流转。

Key_Shared (键共享模式): 这是Pulsar 2.7.0版本后引入的一种高级模式，它结合了Shared和Exclusive的优点。在Key_Shared模式下，一个订阅可以有多个消费者，Pulsar会根据消息的orderingKey（或者messageKey）将具有相同Key的消息发送给同一个消费者。这样，对于同一个Key的消息，可以保证严格的顺序性，而不同Key的消息则可以在多个消费者之间并行处理。这对于需要按业务ID（如订单ID、用户ID）进行顺序处理，但又希望整体并行处理的场景非常有用。我个人觉得这是Pulsar在消息分发策略上的一大创新，它很好地解决了“全局无序但局部有序”的业务需求。

消息确认机制 (Acknowledgment)

Pulsar的消息确认机制是确保消息可靠投递的关键。消费者接收到消息后，必须向Pulsar发送确认（ACK），Pulsar才会认为这条消息已被成功处理并可以删除。如果未确认，Pulsar会在一定时间后重新投递。

consumer.acknowledge(msg): 这是最常见的确认方式，表示单条消息处理成功。对于Shared和Exclusive模式，通常都用这个。

consumer.acknowledgeCumulative(msg): 累积确认。它会确认包括当前消息在内的所有之前未确认的消息。这个方法主要用于Exclusive和Failover模式，因为这些模式下消息是严格有序的。如果乱用在Shared模式下，可能会导致一些未处理的消息也被错误地确认掉。

consumer.negativeAcknowledge(msg) (NACK): 负确认。当你处理消息失败时（比如业务异常、数据解析错误），可以使用NACK。Pulsar会认为这条消息处理失败，并在稍后重新投递。NACK通常会有延迟投递的机制，避免立即重试导致死循环。合理使用NACK，配合重试策略和死信队列（Dead Letter Topic），可以构建非常健壮的错误处理流程。

consumer.redeliverUnacknowledgedMessages(): 这个方法可以手动触发Pulsar重新投递所有当前消费者未确认的消息。通常用于消费者在处理过程中遇到不可恢复的错误，需要快速重置状态，让消息重新回到队列中。

我建议，在设计消费者时，一定要仔细考虑你的业务场景对消息顺序、并发处理和容错能力的要求，然后选择最合适的订阅模式。同时，对于消息的ACK/NACK操作，务必放在try-catch块中，确保即使业务逻辑失败，也能正确地进行负确认，避免消息丢失或重复消费。

在消息队列的世界里，数据格式的兼容性一直是个头疼的问题。如果生产者发送的数据格式变了，而消费者没有及时更新，那后果可能就是一堆解析错误和难以追踪的生产事故。Pulsar的Schema机制就是为了解决这个问题而生，它提供了一种端到端（end-to-end）的类型安全保障，让我这个曾经饱受JSON序列化/反序列化之苦的开发者感到欣慰。

Pulsar的Schema是内置在Broker上的，当你第一次用某个Schema发送消息到Topic时，Pulsar会自动注册这个Topic的Schema。后续的生产者和消费者，只要指定相同的Schema，Pulsar就会在消息发送和接收时进行类型校验。如果Schema不匹配，Pulsar会直接拒绝操作，而不是等到运行时才报错。

Java客户端对Schema的支持非常友好，主要通过Schema类来实现。Pulsar支持多种Schema类型，包括：

实现端到端类型安全的核心步骤：

定义POJO类: 无论是JSON、Avro还是Protobuf，你都需要一个Java对象来表示你的消息结构。

public class MyMessage {    private String field1;    private int field2;    // Getter, Setter, Constructors    public MyMessage() {}    public MyMessage(String field1, int field2) {        this.field1 = field1;        this.field2 = field2;    }    @Override    public String toString() {        return "MyMessage{" +               "field1='" + field1 + '\'' +               ", field2=" + field2 +               '}';    }}

生产者使用Schema: 在创建生产者时，指定对应的Schema。

// 生产者创建时指定SchemaProducer<MyMessage> producer = client.newProducer(Schema.JSON(MyMessage.class))        .topic(TOPIC_NAME)        .create();MyMessage msg = new MyMessage("Hello Schema", 123);producer.sendAsync(msg).thenAccept(msgId -> System.out.println("Sent typed message: " + msg + ", ID: " + msgId));

消费者使用Schema: 消费者同样需要指定Schema。

// 消费者创建时指定SchemaConsumer<MyMessage> consumer = client.newConsumer(Schema.JSON(MyMessage.class))        .topic(TOPIC_NAME)        .subscriptionName(SUBSCRIPTION_NAME)        .subscriptionType(SubscriptionType.Shared)        .messageListener((cons, message) -> {            try {                MyMessage receivedMsg = message.getValue(); // 直接获取到POJO对象                System.out.println("Received typed message: " + receivedMsg + " (ID: " + message.getMessageId() + ")");                cons.acknowledge(message);            } catch (Exception e) {                System.err.println("Error processing typed message: " + e.getMessage());                cons.negativeAcknowledge(message);            }        })        .subscribe();

Schema的好处与我的思考：

以上就是Java操作Pulsar消息队列的完整方案的详细内容，更多请关注乐哥常识网其它相关文章！