Java 后端 / 系统课时
处理失败重试与幂等
处理失败重试与幂等
本课解决事务失败后“该不该重试、怎样重试、怎样避免重复副作用”的问题。最终做法是用数据库唯一约束建立幂等边界,把有限次数、退避与异常分类放在事务外层,并让每次尝试都使用独立事务。
学习目标
- 区分可重试的临时数据库失败与不可重试的业务失败
- 用有限次数、指数退避和随机抖动控制事务重试
- 用稳定幂等键与数据库唯一约束避免重复写单和重复副作用
先判断失败是否值得重试
重试只适合“再次执行有合理机会成功”的临时故障,例如死锁、短暂锁冲突或被明确归类为瞬时的数据访问失败。参数校验失败、库存不足、状态机拒绝等业务失败不会因为重复执行而消失,应直接返回或进入补偿流程。
还要区分“事务已经回滚”和“调用可以安全重放”。一次尝试失败后,应先让当前事务结束,再等待并启动下一次独立事务。若响应丢失导致提交结果不确定,调用方也必须复用同一个幂等键,让数据库判断之前是否已经成功。
用数据库唯一约束建立幂等边界
先调用 existsByIdempotencyKey() 再执行插入存在竞态:两个并发请求可能同时查到“不存在”,随后都继续写入。真正的并发裁决点必须是数据库唯一约束,使“同一个幂等键只能成功插入一次”成为原子事实。
下面使用 idempotency_key 作为订单表主键,并用条件更新扣减库存。脚本可重复执行,最后一条查询用于确认实验初始状态。
DROP TABLE IF EXISTS orders;
DROP TABLE IF EXISTS inventory;
CREATE TABLE inventory (
sku VARCHAR(64) PRIMARY KEY,
available INTEGER NOT NULL
);
CREATE TABLE orders (
idempotency_key VARCHAR(80) PRIMARY KEY,
sku VARCHAR(64) NOT NULL,
quantity INTEGER NOT NULL
);
INSERT INTO inventory (sku, available) VALUES ('SKU-1', 10);
SELECT sku, available
FROM inventory
WHERE sku = 'SKU-1';预期结果
sku | available
SKU-1 | 10主键或唯一索引必须是真实的数据库约束,而不是只靠应用先查后写。两个请求并发使用同一个 idempotency_key 时,数据库会让一个插入成功;若该事务最终提交,另一个请求会得到重复键异常,再读取并校验已有订单即可。
把有限重试放在事务外层
下面是项目内可运行的主示例,依赖已经配置好的 DataSource 和 Spring JDBC。TransactionTemplate 使用 PROPAGATION_REQUIRES_NEW,因此每次循环尝试都会创建新事务;退避发生在事务之外,不会在睡眠期间继续持有数据库锁。示例还提供一次性故障注入,只用于本地验证重试路径,生产代码应移除该注入入口。
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicBoolean;
import org.springframework.boot.CommandLineRunner;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.dao.TransientDataAccessException;
import org.springframework.dao.TransientDataAccessResourceException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.TransactionTemplate;
@Service
public class OrderApplicationService {
private static final int MAX_ATTEMPTS = 3;
private final JdbcTemplate jdbc;
private final TransactionTemplate tx;
private final AtomicBoolean failNextAttemptForDemo = new AtomicBoolean();
public OrderApplicationService(
JdbcTemplate jdbc,
PlatformTransactionManager transactionManager) {
this.jdbc = jdbc;
this.tx = new TransactionTemplate(transactionManager);
this.tx.setPropagationBehavior(
TransactionDefinition.PROPAGATION_REQUIRES_NEW);
}
public OrderResult createOrder(String key, String sku, int quantity) {
if (key == null || key.isBlank() || quantity <= 0) {
throw new IllegalArgumentException("invalid request");
}
for (int attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
System.out.printf("attempt=%d key=%s%n", attempt, key);
try {
OrderResult result =
tx.execute(status -> createOnce(key, sku, quantity));
System.out.println("result=" + result.resultType());
return result;
} catch (DuplicateKeyException duplicate) {
// 重复键不是临时故障:读取已有结果并校验 key 是否被复用。
OrderResult existing = loadExisting(key, sku, quantity);
System.out.println("result=" + existing.resultType());
return existing;
} catch (TransientDataAccessException transientFailure) {
if (attempt == MAX_ATTEMPTS) {
throw transientFailure;
}
long baseDelayMs = 100L << (attempt - 1);
long delayMs =
baseDelayMs + ThreadLocalRandom.current().nextLong(50);
System.out.println("retrying after " + delayMs + " ms");
sleepOutsideTransaction(delayMs);
}
}
throw new IllegalStateException("unreachable");
}
private OrderResult createOnce(String key, String sku, int quantity) {
if (failNextAttemptForDemo.compareAndSet(true, false)) {
throw new TransientDataAccessResourceException(
"simulated transient failure");
}
jdbc.update(
"INSERT INTO orders (idempotency_key, sku, quantity) "
+ "VALUES (?, ?, ?)",
key, sku, quantity);
int updated = jdbc.update(
"UPDATE inventory SET available = available - ? "
+ "WHERE sku = ? AND available >= ?",
quantity, sku, quantity);
if (updated != 1) {
throw new InsufficientStockException();
}
return new OrderResult(key, sku, quantity, "CREATED");
}
private OrderResult loadExisting(String key, String sku, int quantity) {
Map<String, Object> row = jdbc.queryForMap(
"SELECT sku, quantity FROM orders "
+ "WHERE idempotency_key = ?",
key);
String storedSku = (String) row.get("sku");
int storedQuantity = ((Number) row.get("quantity")).intValue();
if (!storedSku.equals(sku) || storedQuantity != quantity) {
throw new IllegalArgumentException(
"idempotency key reused with different request");
}
return new OrderResult(
key, storedSku, storedQuantity, "EXISTING");
}
public void injectOneTransientFailureForDemo() {
failNextAttemptForDemo.set(true);
}
private void sleepOutsideTransaction(long delayMs) {
try {
Thread.sleep(delayMs);
} catch (InterruptedException interrupted) {
Thread.currentThread().interrupt();
throw new IllegalStateException(
"retry interrupted", interrupted);
}
}
public record OrderResult(
String key, String sku, int quantity, String resultType) {
}
private static final class InsufficientStockException
extends RuntimeException {
}
}
@Component
class OrderRetryRunner implements CommandLineRunner {
private final OrderApplicationService service;
OrderRetryRunner(OrderApplicationService service) {
this.service = service;
}
@Override
public void run(String... args) {
service.createOrder("req-1001", "SKU-1", 2);
service.createOrder("req-1001", "SKU-1", 2);
service.injectOneTransientFailureForDemo();
service.createOrder("req-1002", "SKU-1", 1);
}
}预期结果
attempt=1 key=req-1001
result=CREATED
attempt=1 key=req-1001
result=EXISTING
attempt=1 key=req-1002
retrying after <VALUE> ms
attempt=2 key=req-1002
result=CREATED<VALUE> 是加入随机抖动后的实际等待毫秒数,运行时会不同。每个临时失败最多尝试 3 次,任一次成功就立即停止;库存不足等业务异常不会命中 TransientDataAccessException,因此不会进入重试。实际项目还应根据数据库驱动和 Spring 异常翻译结果维护明确的可重试异常白名单,而不是笼统重试所有 DataAccessException。

幂等要覆盖真正的业务副作用
数据库唯一约束只能保护订单身份和本地数据。扣款、第三方接口调用、消息发布等外部副作用不会随数据库事务自动回滚,因此下游调用也应携带同一个稳定幂等键,重试时不能重新生成业务请求 ID。
如果外部系统没有幂等能力,不要把外部调用直接放进可重试数据库事务。更稳妥的做法是在本地事务中同时写入业务状态与待投递事件,再用 Outbox 或可靠消息异步发送;消费者也按业务键去重。
避免重试放大故障
最危险的场景是“数据库可能已经提交,但响应在返回前丢失”。此时再次请求不是简单地重做失败操作,而是在确认第一次是否已成功;复用原幂等键后,重复创建会被唯一约束转换为读取已有结果,从而避免再次扣库存或再次生成订单。
持续性故障下还要防止重试风暴。重试次数必须有限,等待时间应递增并带抖动,同时记录幂等键、异常分类、尝试次数、最终结果和总耗时。原则可以归纳为三点:先结束当前事务再重试;每次重试复用同一个业务身份;所有真实副作用都必须有幂等保护。