消息队列 / 系统课时

可靠生产者实现

可靠生产者实现

可靠生产者不是“发送 API 不报错”,而是让业务事务、本地消息记录、RabbitMQ 确认与失败补偿形成闭环。本节用 Transactional Outbox 先可靠保存事件,再由补偿任务持续投递,直到 Broker 确认接管。

学习目标

  • 用本地消息表消除“业务提交成功但事件没有留下”的丢失窗口
  • 使用 Publisher Confirm 判断 RabbitMQ 是否已经接管消息,并处理不可路由返回
  • 设计可重试的消息状态与验收方法,理解重复发布仍可能发生的边界

先定义可靠性的边界

一次可靠发送至少跨过三个状态:业务数据已经提交、待发送事件已经持久化、RabbitMQ 已经确认接管。Publisher Confirm 只能覆盖生产者到 Broker 的这段链路,不能替代本地数据库事务,也不能证明消费者已经完成业务处理。

因此不要在业务事务里直接“先改数据库,再发送消息”。网络超时可能让应用无法判断 RabbitMQ 到底收没收到;反过来先发消息再提交数据库,又可能让消费者看到尚未提交的业务状态。更稳妥的做法是让业务表和 Outbox 在同一个本地事务中提交。

本地消息表驱动的可靠生产闭环

建立 Outbox 数据模型

下面以 PostgreSQL 为例。event_id 是业务事件的稳定唯一标识;status 记录发送状态;retry_count 和 next_retry_at 控制补偿节奏。多实例部署时还应增加领取租约或使用 FOR UPDATE SKIP LOCKED,避免多个 Worker 同时处理同一行。

sql
CREATE TABLE order_event_outbox (
    id              BIGSERIAL PRIMARY KEY,
    event_id        UUID NOT NULL UNIQUE,
    exchange_name   VARCHAR(120) NOT NULL,
    routing_key     VARCHAR(120) NOT NULL,
    payload         JSONB NOT NULL,
    status          VARCHAR(16) NOT NULL DEFAULT 'PENDING',
    retry_count     INTEGER NOT NULL DEFAULT 0,
    next_retry_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    last_error      TEXT,
    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
    sent_at         TIMESTAMPTZ
);

CREATE INDEX idx_outbox_due
ON order_event_outbox (next_retry_at, id)
WHERE status IN ('PENDING', 'RETRY');

这是数据结构定义。执行后应确认 event_id 唯一约束和 idx_outbox_due 索引存在;它们分别承担事件去重标识和补偿扫描加速。

把业务提交与发送拆成两段

片段示例:以下代码假设 Spring Boot 已提供 JdbcTemplate、RabbitMQ Java Client 的单线程专用 Channel,并且交换机与绑定已预先声明。业务方法只负责在同一数据库事务中写订单和 Outbox;定时任务负责发布。示例使用同步等待 Confirm,便于看清边界,高吞吐场景可改为异步 Confirm 并维护序号到事件的关联表。

java
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Set;

@Service
class OrderService {
    private final JdbcTemplate jdbc;

    OrderService(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    @Transactional
    UUID createOrder(String orderId, BigDecimal amount) {
        UUID eventId = UUID.randomUUID();
        jdbc.update(
            "INSERT INTO orders(order_id, amount, status) VALUES (?, ?, 'CREATED')",
            orderId, amount
        );
        jdbc.update(
            "INSERT INTO order_event_outbox(event_id, exchange_name, routing_key, payload) " +
            "VALUES (?, 'evt.order', 'order.created', " +
            "jsonb_build_object('eventId', ?, 'orderId', ?))",
            eventId, eventId.toString(), orderId
        );
        return eventId;
    }
}

@Component
class OutboxPublisher {
    private final JdbcTemplate jdbc;
    private final Channel channel;
    private final Set<String> returned = ConcurrentHashMap.newKeySet();

    OutboxPublisher(JdbcTemplate jdbc, Channel channel) throws Exception {
        this.jdbc = jdbc;
        this.channel = channel;
        channel.confirmSelect();
        channel.addReturnListener(message -> {
            String id = message.getProperties().getMessageId();
            if (id != null) returned.add(id);
        });
    }

    @Scheduled(fixedDelay = 1000)
    void flush() {
        List<OutboxEvent> events = jdbc.query(
            "SELECT id, event_id::text, exchange_name, routing_key, payload::text " +
            "FROM order_event_outbox " +
            "WHERE status IN ('PENDING','RETRY') AND next_retry_at <= now() " +
            "ORDER BY id LIMIT 100",
            (rs, n) -> new OutboxEvent(
                rs.getLong("id"),
                rs.getString("event_id"),
                rs.getString("exchange_name"),
                rs.getString("routing_key"),
                rs.getString("payload")
            )
        );
        events.forEach(this::publishOne);
    }

    private void publishOne(OutboxEvent event) {
        try {
            AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
                .deliveryMode(2)
                .contentType("application/json")
                .messageId(event.eventId())
                .build();

            channel.basicPublish(
                event.exchange(), event.routingKey(), true, props,
                event.payload().getBytes(StandardCharsets.UTF_8)
            );
            channel.waitForConfirmsOrDie(5_000);

            if (returned.remove(event.eventId())) {
                throw new IllegalStateException("unroutable");
            }

            jdbc.update(
                "UPDATE order_event_outbox SET status='SENT', sent_at=now(), last_error=NULL WHERE id=?",
                event.id()
            );
        } catch (Exception ex) {
            jdbc.update(
                "UPDATE order_event_outbox " +
                "SET status='RETRY', retry_count=retry_count+1, " +
                "next_retry_at=now()+interval '5 seconds', last_error=? WHERE id=?",
                ex.getMessage(), event.id()
            );
        }
    }

    record OutboxEvent(long id, String eventId, String exchange,
                       String routingKey, String payload) {}
}

这里有一个必须接受的事实:Broker 已确认后,进程可能在把 Outbox 更新成 SENT 之前崩溃。恢复后同一事件会再次发布,所以这套方案提供的是至少一次发送,不是“绝不重复”;event_id 必须一直随消息传到消费者。

用故障结果验收闭环

先正常创建一笔订单并等待补偿任务运行,再查询最新 Outbox。确认成功时应看到 SENT;如果暂时停止 RabbitMQ 或故意使用不存在的路由,再次执行相同业务流程,应先看到 RETRY,Broker 恢复且路由正确后最终转为 SENT。

sql
SELECT event_id, status, retry_count
FROM order_event_outbox
ORDER BY id DESC
LIMIT 1;

预期结果

text
event_id                               | status | retry_count
<ID>                                   | SENT   | 0

<ID> 会因每次创建事件而变化。真正上线时还应为 RETRY 长时间堆积、最大重试次数、不可路由数量和 Confirm 延迟建立监控;Outbox 解决的是“有记录可补偿”,最终链路仍要依赖消费者幂等来吸收重复事件。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

可靠生产者实现

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通