消息队列 / 系统课时
可靠生产者实现
可靠生产者实现
可靠生产者不是“发送 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 同时处理同一行。
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 并维护序号到事件的关联表。
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。
SELECT event_id, status, retry_count
FROM order_event_outbox
ORDER BY id DESC
LIMIT 1;预期结果
event_id | status | retry_count
<ID> | SENT | 0<ID> 会因每次创建事件而变化。真正上线时还应为 RETRY 长时间堆积、最大重试次数、不可路由数量和 Confirm 延迟建立监控;Outbox 解决的是“有记录可补偿”,最终链路仍要依赖消费者幂等来吸收重复事件。