3、Spring Cloud Stream + RocketMQ 高级消息特性完全指南

原创 已于 2025-10-04 18:06:35 修改 · 802 阅读 · 20 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rocketmq #java #spring boot #spring cloud

于 2025-10-04 18:03:05 首次发布

📜 Spring Cloud Stream + RocketMQ 高级消息特性完全指南

支持事务消息、顺序消息、定时/延时消息
基于 Spring Cloud Stream 4.x + Spring Boot 3.x + RocketMQ Binder
100% 函数式编程模型 | 无 @StreamListener

一、核心前提：Spring Cloud Stream 的定位

✅ Spring Cloud Stream 的职责：

职责说明
✅ 统一抽象提供 Supplier、Function、Consumer 接口，屏蔽 Kafka/RabbitMQ/RocketMQ 等差异
✅ 自动绑定自动创建 Topic/Queue、配置消费者组、序列化、反序列化
✅ 集成监控集成 Actuator、Micrometer、日志、错误处理
✅ 弹性机制自动重试、DLQ、并发控制、分区感知

❌ Spring Cloud Stream 不负责：

不负责说明
❌ 消息协议细节如事务消息的两阶段提交、顺序消息的队列绑定、延时消息的 TimeWheel 实现
❌ Broker 特有功能RocketMQ 的 MessageQueue、Tag、DelayLevel、TransactionListener 等底层概念
❌ 事务协调器事务消息需要 RocketMQ Broker + 客户端本地事务状态回查机制

✅ 结论：
Spring Cloud Stream 是“消息通道的抽象层”，而 RocketMQ Binder 是“该抽象层与 RocketMQ 协议的适配器”。
高级特性（事务、顺序、延时）由 RocketMQ Binder 实现，但需你显式配置或使用扩展 API。

二、RocketMQ Binder 的能力边界（官方支持情况）

特性Spring Cloud Stream 是否原生支持？说明
✅ 普通消息✔️ 完全支持使用 Supplier / StreamBridge 发送，自动序列化
✅ 顺序消息⚠️ 部分支持需手动指定 MessageQueueSelector，需自定义 Message Header
✅ 延时/定时消息⚠️ 部分支持需通过 RocketMQMessageHeaders 设置 DELAY_TIME_LEVEL
✅ 事务消息❌ 不直接支持Spring Cloud Stream 无内置事务管理器，需结合 @Transactional + RocketMQTemplate 手动实现
✅ 批量消息✔️ 支持（通过 StreamBridge 批量发送）可循环调用 send()，或使用 List<Message>
✅ 消息过滤（Tag）✔️ 支持通过 RocketMQMessageHeaders.TAGS 设置
✅ 消息 Key✔️ 支持通过 RocketMQMessageHeaders.KEYS 设置
✅ 消息 ID / Trace✔️ 自动注入RocketMQ Binder 自动设置 MessageId、BornHost、StoreHost

🔍 重要：RocketMQ Binder 的实现基于 spring-cloud-starter-stream-rocketmq，其底层封装了 Apache RocketMQ Client（DefaultMQProducer），但不暴露所有高级 API。

三、如何实现 RocketMQ 高级消息类型？—— 实战方案

我们将使用以下依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-stream-rocketmq</artifactId>
    <version>4.1.0</version> <!-- 适配 Spring Boot 3.x -->
</dependency>

💡 注意：spring-cloud-starter-stream-rocketmq 从 4.0+ 开始支持 RocketMQ 5.x，推荐使用 RocketMQ 5.1+。

✅ 场景一：发送普通消息（基础，已掌握）

1. 定义 POJO

// Order.java
package com.example.rocketmq.model;

import lombok.Data;

@Data
public class Order {
    private String orderId;
    private String productName;
    private Long price;
}

2. 使用 StreamBridge 手动发送

@RestController
public class OrderController {

    @Autowired
    private StreamBridge streamBridge;

    @PostMapping("/order")
    public ResponseEntity<String> createOrder(@RequestBody Order order) {
        boolean sent = streamBridge.send("orders-out-0", order);
        return ResponseEntity.ok(sent ? "订单已发送" : "发送失败");
    }
}

3. 配置绑定

spring:
  cloud:
    stream:
      bindings:
        orders-out-0:
          destination: orders-topic
          content-type: application/json
      rocketmq:
        binder:
          name-server: 127.0.0.1:9876
          producer:
            group: order-producer-group

✅ 此为标准普通消息，RocketMQ Binder 自动处理。

✅ 场景二：发送延时消息 / 定时消息（RocketMQ 特有）

🚀 RocketMQ 延时消息机制：

  • RocketMQ 支持 18 个延时等级（默认）：1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
  • 通过设置 DELAY_TIME_LEVEL 头部实现，不是时间戳！

✅ 实现方式：使用 RocketMQMessageHeaders

import org.springframework.cloud.stream.binder.rocketmq.headers.RocketMQMessageHeaders;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;

@PostMapping("/order-delay")
public ResponseEntity<String> createDelayedOrder(@RequestBody Order order) {
    // 设置延时等级：30秒（对应第4级，从1开始）
    Map<String, Object> headers = Map.of(
        RocketMQMessageHeaders.DELAY_TIME_LEVEL, 4  // 30秒
    );

    Message<Order> message = MessageBuilder
        .withPayload(order)
        .copyHeaders(headers)
        .build();

    boolean sent = streamBridge.send("orders-out-0", message);

    return ResponseEntity.ok("订单已发送，延时30秒消费");
}

✅ 配置文件（无需额外配置）

spring:
  cloud:
    stream:
      bindings:
        orders-out-0:
          destination: orders-topic
          content-type: application/json
      rocketmq:
        binder:
          name-server: 127.0.0.1:9876
          producer:
            group: order-producer-group

✅ 消费端验证（普通 Consumer）

@Bean
public Consumer<Order> orderConsumer() {
    return order -> {
        System.out.println("✅ 收到延时订单: " + order);
        // 30秒后才打印，证明延时生效
    };
}

✅ 关键点：

  • 延时等级是 预设值，不能自定义毫秒数（如 12345ms）。
  • 若设置无效等级（如 20），RocketMQ 会忽略，转为普通消息。
  • 推荐使用常量封装：
public class RocketMQDelayLevels {
    public static final int LEVEL_1S = 1;
    public static final int LEVEL_5S = 2;
    public static final int LEVEL_10S = 3;
    public static final int LEVEL_30S = 4;
    public static final int LEVEL_1M = 5;
    public static final int LEVEL_2M = 6;
    public static final int LEVEL_3M = 7;
    public static final int LEVEL_10M = 15;
    public static final int LEVEL_1H = 17;
}

✅ 场景三：发送顺序消息（Message Ordering）

🚀 RocketMQ 顺序消息原理：

  • 同一个 MessageQueue 内的消息按顺序消费。
  • 通过 MessageQueueSelector 将消息路由到固定队列。
  • 必须指定 ShardingKey（如订单ID），确保同一订单的所有消息发往同一队列。

✅ 实现方式：自定义 Message Header + StreamBridge

RocketMQ Binder 不直接提供 MessageQueueSelector 接口，但可通过 自定义 Header + Binder 扩展 实现。

✅ 步骤 1：使用 RocketMQMessageHeaders.SHARDING_KEY
@PostMapping("/order-ordered")
public ResponseEntity<String> createOrderedOrder(@RequestBody Order order) {
    // ✅ 关键：设置 sharding key，确保同一订单的所有消息发往同一队列
    Map<String, Object> headers = Map.of(
        RocketMQMessageHeaders.SHARDING_KEY, order.orderId() // 用 orderId 作为分区键
    );

    Message<Order> message = MessageBuilder
        .withPayload(order)
        .copyHeaders(headers)
        .build();

    boolean sent = streamBridge.send("orders-out-0", message);

    return ResponseEntity.ok("顺序订单已发送，订单ID: " + order.orderId());
}
✅ 步骤 2：验证顺序性（消费者端）
@Bean
public Consumer<Order> orderConsumer() {
    return order -> {
        // 模拟耗时处理，观察是否乱序
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("✅ 消费顺序订单: " + order.orderId() + " @ " + LocalDateTime.now());
    };
}
✅ 步骤 3：测试
  • 同时发送 5 个订单：ORD-1, ORD-2, ORD-1, ORD-1, ORD-2
  • 你会看到：
    ✅ 消费顺序订单: ORD-1 @ 10:00:01
✅ 消费顺序订单: ORD-1 @ 10:00:02
✅ 消费顺序订单: ORD-1 @ 10:00:03
✅ 消费顺序订单: ORD-2 @ 10:00:04
✅ 消费顺序订单: ORD-2 @ 10:00:05

✅ 同一订单的多条消息按发送顺序被消费，不同订单之间可并行 —— 实现了分区顺序性。

⚠️ 注意：

  • RocketMQ 顺序消息仅保证单个 MessageQueue 内有序，不是全局有序。
  • SHARDING_KEY 必须是业务主键（如订单ID、用户ID、账户ID）。
  • 如果你用 UUID 作为 SHARDING_KEY，则每条消息都发往不同队列 → 无顺序！

✅ 场景四：发送事务消息（最复杂，需手动实现）

❗ Spring Cloud Stream 不原生支持事务消息！

RocketMQ 事务消息依赖：

  1. TransactionListener 接口（实现本地事务执行与状态回查）
  2. DefaultMQProducer 的 sendMessageInTransaction() 方法
  3. 本地事务状态（COMMIT / ROLLBACK）
  4. Broker 回查机制

而 Spring Cloud Stream 的 StreamBridge 和 Supplier 都基于 DefaultMQProducer.send()，无法调用事务发送 API。

✅ 解决方案：混合使用 RocketMQ 原生 API

✅ 最佳实践：在 Spring Boot 事务中，用原生 RocketMQ Client 发送事务消息，用 Stream 处理消费

架构设计：

[REST API] → [Service 层] → [事务内调用 RocketMQTemplate] → 发送事务消息
                            ↓
                        [RocketMQ Broker]
                            ↓
                [Stream Consumer] → 处理消息 → 更新库存/积分

✅ 步骤 1：添加 RocketMQ 原生依赖

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.3.0</version> <!-- 适配 RocketMQ 5.x -->
</dependency>

✅ 步骤 2：配置 RocketMQ Producer（application.yml）

rocketmq:
  name-server: 127.0.0.1:9876
  producer:
    group: order-trans-producer-group
    send-message-timeout: 3000

✅ 步骤 3：实现事务消息发送服务

@Service
public class OrderTransactionService {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Autowired
    private OrderService orderService; // 你的本地业务服务

    @Transactional
    public void createOrderWithTransaction(Order order) {
        // 1️⃣ 先保存订单到数据库（本地事务）
        orderService.save(order); // ✅ 本地事务

        // 2️⃣ 发送事务消息（RocketMQ 事务消息）
        String topic = "orders-topic";
        String tags = "create";

        SendResult sendResult = rocketMQTemplate.sendMessageInTransaction(
            topic + ":" + tags,
            MessageBuilder.withPayload(order).build(),
            order // 传入业务参数（用于回查时获取订单）
        );

        if (SendResult.Status.SEND_OK == sendResult.getSendStatus()) {
            System.out.println("✅ 事务消息已发送，等待回查");
        } else {
            throw new RuntimeException("事务消息发送失败");
        }
    }
}

✅ 步骤 4：实现 TransactionListener（核心！）

@Component
@RocketMQTransactionListener(
    txProducerGroup = "order-trans-producer-group", // 必须与 producer.group 一致
    consumerGroup = "order-trans-consumer-group"     // 消费组用于回查
)
public class OrderTransactionListener implements RocketMQLocalTransactionListener {

    @Autowired
    private OrderService orderService;

    // ✅ 执行本地事务（在发送消息后调用）
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        Order order = (Order) msg.getPayload();

        // ✅ 业务逻辑：检查是否成功写入数据库
        // 注意：此时数据库事务已提交，但 RocketMQ 还未确认
        boolean success = orderService.exists(order.orderId());

        if (success) {
            System.out.println("✅ 本地事务成功，提交消息");
            return RocketMQLocalTransactionState.COMMIT;
        } else {
            System.out.println("❌ 本地事务失败，回滚消息");
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }

    // ✅ Broker 回查本地事务状态（定时调用）
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        Order order = (Order) msg.getPayload();
        boolean exists = orderService.exists(order.orderId());

        if (exists) {
            System.out.println("🔍 回查订单: " + order.orderId() + " → 提交");
            return RocketMQLocalTransactionState.COMMIT;
        } else {
            System.out.println("🔍 回查订单: " + order.orderId() + " → 回滚");
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }
}

✅ 步骤 5：Controller 调用

@RestController
public class OrderController {

    @Autowired
    private OrderTransactionService orderTransactionService;

    @PostMapping("/order/transaction")
    public ResponseEntity<String> createOrder(@RequestBody Order order) {
        try {
            orderTransactionService.createOrderWithTransaction(order);
            return ResponseEntity.ok("事务订单创建中...");
        } catch (Exception e) {
            return ResponseEntity.status(500).body("创建失败: " + e.getMessage());
        }
    }
}

✅ 步骤 6：消费端（仍用 Stream，与事务无关）

@Bean
public Consumer<Order> orderConsumer() {
    return order -> {
        System.out.println("✅ 消费事务消息: " + order);
        // 更新库存、积分、通知等
    };
}

✅ 关键架构图：

[REST] → [Service] → [save DB] → [sendTransactionMsg] → [Broker]
                                     ↓
                        [TransactionListener.execute] → COMMIT/ROLLBACK
                                     ↓
                      [Broker 定时回查 checkLocalTransaction]
                                     ↓
                          [Broker 发送消息到 Topic]
                                     ↓
                        [Stream Consumer] → 处理业务

✅ 优点：

  • 事务一致性由 RocketMQ 保证
  • 消费端仍使用统一的 Stream 函数式模型，不耦合
  • 业务代码清晰，事务边界明确

❌ 缺点：

  • 需引入 rocketmq-spring-boot-starter
  • 代码分散（事务发送在 Service，消费在 Stream）
  • 需要理解 RocketMQ 事务机制

✅ 场景五：发送带 Tag 的消息（消息过滤）

RocketMQ 支持通过 Tag 过滤消息（Consumer 可只订阅特定 Tag）。

@PostMapping("/order-with-tag")
public ResponseEntity<String> createOrderWithTag(@RequestBody Order order) {
    Map<String, Object> headers = Map.of(
        RocketMQMessageHeaders.TAGS, "create"  // 消息标签
    );

    Message<Order> message = MessageBuilder
        .withPayload(order)
        .copyHeaders(headers)
        .build();

    streamBridge.send("orders-out-0", message);
    return ResponseEntity.ok("已发送，Tag=create");
}

消费端只消费特定 Tag 的消息：

spring:
  cloud:
    stream:
      bindings:
        orderConsumer-in-0:
          destination: orders-topic
          group: order-consumer-group
          consumer:
            # ✅ RocketMQ 特有：只消费指定 Tag 的消息
            tags: create

✅ 注意：tags 是 RocketMQ Binder 的扩展属性，不是标准 Stream 属性。

四、RocketMQ Binder 扩展属性速查表（Header / 配置）

功能Header 名类型说明
延时等级RocketMQMessageHeaders.DELAY_TIME_LEVELInteger1~18，对应延时等级
顺序键RocketMQMessageHeaders.SHARDING_KEYString用于路由到固定 MessageQueue
消息标签RocketMQMessageHeaders.TAGSString消息过滤标签
消息 KeyRocketMQMessageHeaders.KEYSString查询消息用，可多个用 # 分隔
消息优先级RocketMQMessageHeaders.PRIORITYInteger0~9，数字越大优先级越高
消息延迟RocketMQMessageHeaders.DELAY_SECONDSLong❌ 无效！RocketMQ 不支持秒级延时，只支持等级
消息体类型MessageHeaders.CONTENT_TYPEStringapplication/json

✅ 在配置中使用 consumer.tags 控制消费端过滤。

五、完整配置示例（application.yml）

spring:
  cloud:
    stream:
      bindings:
        orders-out-0:
          destination: orders-topic
          content-type: application/json
        orderConsumer-in-0:
          destination: orders-topic
          group: order-consumer-group
          consumer:
            tags: create  # 只消费 Tag=create 的消息

      rocketmq:
        binder:
          name-server: 127.0.0.1:9876
          producer:
            group: order-producer-group
            send-message-timeout: 5000
            retry-times-when-send-failed: 2
          consumer:
            group: order-consumer-group
            consume-message-batch-max-size: 10
            pull-batch-size: 32
            pull-timeout-millis: 10000

# RocketMQ 原生配置（用于事务消息）
rocketmq:
  name-server: 127.0.0.1:9876
  producer:
    group: order-trans-producer-group
    send-message-timeout: 3000

六、总结：Spring Cloud Stream + RocketMQ 高级消息能力全景图

特性是否支持实现方式推荐度
✅ 普通消息✔️ 原生StreamBridge.send()⭐⭐⭐⭐⭐
✅ 延时消息✔️ 支持RocketMQMessageHeaders.DELAY_TIME_LEVEL⭐⭐⭐⭐☆
✅ 顺序消息✔️ 支持RocketMQMessageHeaders.SHARDING_KEY⭐⭐⭐⭐☆
✅ 事务消息❌ 不原生混合使用 RocketMQTemplate + TransactionListener⭐⭐⭐☆☆（复杂但必须）
✅ 消息 Tag 过滤✔️ 支持RocketMQMessageHeaders.TAGS + consumer.tags⭐⭐⭐⭐⭐
✅ 消息 Key✔️ 支持RocketMQMessageHeaders.KEYS⭐⭐⭐⭐☆
✅ 批量发送✔️ 支持循环调用 send()⭐⭐⭐⭐☆
✅ 消费者并发✔️ 支持consumer.concurrency⭐⭐⭐⭐⭐

七、最佳实践与建议

建议说明
✅ 事务消息优先使用 rocketmq-spring-boot-starter + TransactionListener，不要试图用 Stream 实现
✅ 顺序消息用 SHARDING_KEY，必须用业务主键（订单ID、用户ID）
✅ 延时消息用 DELAY_TIME_LEVEL，避免用 ScheduledExecutorService 模拟
✅ 消息过滤用 TAGS，比 SQL 过滤更高效
✅ 监控启用 Actuator，查看 stream.inbound.*.messages、rocketmq.producer.send.latency
✅ 测试用 spring-cloud-stream-test-support + TestChannelBinder 测试普通消息，事务消息需集成测试
✅ 生产建议事务消息只用于强一致性核心场景（如支付、库存），普通消息用 Stream 即可

八、推荐项目结构

src/main/java/com/example/rocketmq/
├── OrderServiceApplication.java
├── config/
│   └── RocketMQConfig.java
├── model/
│   ├── Order.java
├── controller/
│   ├── OrderController.java         # 普通/延时/顺序消息
│   └── OrderTransactionController.java # 事务消息入口
├── service/
│   ├── OrderService.java
│   └── OrderTransactionService.java # 事务消息发送
├── listener/
│   └── OrderTransactionListener.java # 事务回查
├── binding/
│   └── OrderBindings.java           # 可选：函数式绑定
└── RocketMQDelayLevels.java         # 常量类

九、官方资源

资源链接
Spring Cloud Stream RocketMQ Binderhttps://github.com/spring-cloud/spring-cloud-stream-binder-rocketmq
RocketMQ 官方文档（事务消息）https://rocketmq.apache.org/docs/transaction-message/
RocketMQ 延时消息说明https://rocketmq.apache.org/docs/4.9.4/02example/06delay-message/
Spring Boot + RocketMQ Starterhttps://github.com/apache/rocketmq-spring

✅ 最终结论

Spring Cloud Stream 是“消息通道的抽象”，不是“消息协议的完整实现”。
RocketMQ 的高级特性（事务、顺序、延时）由其原生客户端提供，Spring Cloud Stream Binder 仅提供“透传 Header”的能力。
你应：

  • ✅ 用 StreamBridge 发送普通/延时/顺序消息
  • ✅ 用 RocketMQTemplate + TransactionListener 实现事务消息
  • ✅ 用 Stream 统一消费所有消息，保持架构一致性
微服务架构 Spring Cloud 生态快速回顾指南
张彦峰的博客
02-14 168万+
本文介绍了Spring Cloud在微服务架构中的核心组件及其应用。Spring Cloud提供了服务注册与发现、负载均衡、配置管理和容错机制等功能，简化了分布式系统的构建与管理。通过对这些组件的分析，本文阐述了如何利用Spring Cloud提高微服务系统的可用性、灵活性和可扩展性。最终，本文强调了Spring Cloud作为现代云原生应用开发的重要工具，帮助开发者构建高效、可靠的微服务架构。
Java领域Spring Cloud Alibaba RocketMQ：消息队列应用
Java大师兄的博客
04-06 718
在当今的分布式系统开发中，消息队列起着至关重要的作用。它可以实现系统之间的解耦、异步通信、流量削峰等功能。Spring Cloud Alibaba是一套用于构建分布式应用的开源框架，而RocketMQ是阿里巴巴开源的高性能消息队列。本文章的目的在于详细介绍如何在Java领域中使用Spring Cloud Alibaba集成RocketMQ进行消息队列应用的开发，范围涵盖RocketMQ的核心概念、算法原理、数学模型、项目实战、实际应用场景等多个方面。
Spring Cloud Stream之rocketmq
u011353623的博客
02-02 2332
文档网址：参考：Spring Cloud Stream 是一个用来为微服务应用构建消息驱动能力的框架。它可以基于 Spring Boot 来创建独立的、可用于生产的 Spring 应用程序。Spring Cloud Stream 为一些供应商的消息中间件产品提供了个性化的自动化配置实现，并引入了发布-订阅、消费组、分区这三个核心概念。简单的说，Spring Cloud Stream本质上就是整合了Spring Boot和Spring Integration，实现了一套轻量级的消息驱动的微服务框架。
Spring Cloud Stream集成RocketMQ（kafka/rabbitMQ通用）
最新发布
Leaf吧的博客
05-06 1413
spring cloud stream 是什么 ，概念，集成rocketmq怎么实现，案例，代码分析
【实战】Spring Cloud Stream3.0 整合RocketMq
勤于笔记，成于点滴。
07-23 3243
使用Spring Cloud Stream来进行整合RocketMq。如果我们有在一个项目中需要引入多个MQ的需求，用Spring Cloud Stream简直不要太好。当然，我们是直接使用Spring Cloud Stream3.0,不再像之前低版本那样需要引入通道类进行指定，3.0版本可用直接字配置文件进行粘接绑定信道。
SpringCloud之Stream消息驱动RocketMQ讲解
上善若泪
06-29 4590
是一个用来为微服务应用构建消息驱动能力的框架。它可以基于来创建独立的、可用于生产的Spring应用程序。为一些供应商的消息中间件产品提供了个性化的自动化配置实现，并引入了发布-订阅、消费组、分区这三个核心概念。简单的说，本质上就是整合了和，实现了一套轻量级的消息驱动的微服务框架。/*** 这两个通道可能定义在两个不同的通道里面，这里为了方便放在同一个项目中演示*/ // 收(订阅频道/消息消费者) @Input(INPUT) SubscribableChannel input();
RocketMQ & Spring Cloud Stream
banmingi的博客
07-05 2798
一、RocketMQ简介 1. 概述 消息队列作为高并发系统的核心组件之一，能够帮助业务系统解构提升开发效率和系统稳定性。主要具有以下优势： 削峰填谷： 主要解决瞬时写压力大于应用服务能力导致消息丢失、系统奔溃等问题 系统解耦： 解决不同重要程度、不同能力级别系统之间依赖导致一死全死 提升性能： 当存在一对多调用时，可以发一条消息给消息系统，让消息系统通知相关系统 蓄流压测： 线上有些链路不好压测，可以通过堆积一定量消息再放开来压测 2. RocketMQ Apache Alibaba RocketMQ
SpringCloud的消息服务：SpringCloudStream
jiaodacailei的专栏
04-25 1012
源代码：https://gitee.com/jiaodacailei/SpringCloudStream.git 文章目录1.基础知识2.安装Kafka2.1.解压2.2.启动Kafka2.3.创建主题2.4.发送消息2.5.接收消息3.SpringCloud-Stream消息模型4.使用默认频道进行消息发送和接收4.1.创建项目4.1.1.父项目springcloud-stream4.1.2.创...
springboot项目如何整合RocketMq
yh_zeng2的博客
07-01 661
springboot项目如何整合rocketmq
Spring Cloud Stream实践指南：消息驱动微服务
Spring Cloud Stream是一个构建消息驱动微服务的框架，基于Spring Boot为基础，通过简单的声明式模型来支持可扩展的消息驱动微服务。 ## 1.2 Spring Cloud Stream的优势和特点 Spring Cloud Stream提供了一种简单...
SpringCloud Stream 整合RocketMQ
山后自相逢
08-11 4873
cloud stream rocketmq环境配置 nacos做注册中心 整合案例 生产者 消费者 重复消费 持久化
Spring Cloud Stream整合RocketMQ
冲出仁川，走出马德里，故事还会再继续
06-12 2387
Spring Cloud Stream是一个框架，用于构建与共享消息系统连接的高度可扩展的事件驱动微服务。该框架提供了一个灵活的编程模型，该模型基于已经建立和熟悉的Spring习惯用法和最佳实践，包括对持久pub/sub语义、消费者组和有状态分区的支持。:负责提供与外部消息传递系统集成的组件。:外部消息系统和最终用户提供的应用程序代码(生产者/消费者)之间的桥梁。Message:生产者和消费者用来与目标绑定器(以及通过外部消息系统的其他应用程序)进行通信的规范数据结构。
SpringCloudStream 集成RocketMQ
qq_50909707的博客
04-26 5331
RocketMQ安装步骤略。 一、RocketMQ可视化界面安装 Tags · apache/rocketmq-externals · GitHub 下载 下载好以后，修改配置文件： 开启rocketmq: windows start mqnamesrv.cmd start mqbroker.cmd 成功开启后，运行可视化项目，一般第一次运行会添加很多maven依赖 运行后服务可视化界面： ...
SpringCloudStream简单集成RocketMQ及事务消息
鸢尾_的博客
09-24 2003
SpringCloudStream简单集成RocketMQ及事务消息
RocketMQ以及Spring Cloud Stream的介绍
shitou的博客
03-27 798
Spring Cloud Stream是一个构建消息驱动微服务的框架，解决了开发人员无感知使用消息中间件的问题。通过进一步封装消息中间件，Spring Cloud Stream实现了代码层面对消息中间件的无感知，甚至可以动态切换中间件（如RabbitMQ切换为RocketMQ或Kafka），使微服务开发更加解耦，服务可以更专注于自身业务流程。
Spring Cloud Stream 和SpringBoot整合RocketMq区别和选择
Candy___i的博客
10-27 1253
如果您需要完全掌控RocketMQ的配置和细节，或者您的应用需要与RocketMQ进行更复杂的交互，例如自定义消息处理逻辑、事务性消息等，那么Spring Boot整合RocketMQ可能更适合您。
SpringCloud 集成 RocketMQ 示例及配置详解
demo_yo的博客
05-13 5854
定义Spring Cloud Stream 是一个用来为微服务应用构建消息驱动能力的框架。它可以基于 Spring Boot 来创建独立的、可用于生产的 Spring 应用程序。Spring Cloud Stream 为一些供应商的消息中间件产品提供了个性化的自动化配置实现，并引入了发布-订阅、消费组、分区这三个核心概念。简单的说，Spring Cloud Stream本质上就是整合了Spring Boot和Spring Integration，实现了一套轻量级的消息驱动的微服务框架。抽象模型。
（未完待续）浅谈微服务以及 常用中间件（ zookeeper redis rabbitmq）
舒婷(Zoe)
09-29 7177
传统的单体框架，已经不满足目前公司战略规划要求，近几年“微服务“ 这个字眼，出现的越来越频繁，虽然有过一年多微服务项目经验，也很难把微服务解释清楚，到底何为微服务？ 哈哈哈，好正经的开头，Martin Fowler曾在其blog上发表了”Microservices“的文章，正式提出了微服务架构，对于微服务的解释，他的定义为：微服务架构是一种架构模式，他 提倡将单一应用程序，划分为一个个独立的服务，服务之间相互协调，相互配合，为用户提供最终价值。 来一张图，感受一下微服务的魅力~ 将传统一个独...
"深入探索Spring生态中的RocketMQ实践指南
接着，通过Spring Cloud Stream体系及原理介绍了spring-cloud-stream-binder-rocektmq的使用方法，以及Spring Cloud Bus消息总线的介绍。最后，结合Apache RocketMQ作为阿里开源的业务消息的首选和Spring框架作为...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙茶清欢

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值