Java 后端 / 系统课时

处理失败重试与幂等

处理失败重试与幂等

本课解决事务失败后“该不该重试、怎样重试、怎样避免重复副作用”的问题。最终做法是用数据库唯一约束建立幂等边界,把有限次数、退避与异常分类放在事务外层,并让每次尝试都使用独立事务。

学习目标

  • 区分可重试的临时数据库失败与不可重试的业务失败
  • 用有限次数、指数退避和随机抖动控制事务重试
  • 用稳定幂等键与数据库唯一约束避免重复写单和重复副作用

先判断失败是否值得重试

重试只适合“再次执行有合理机会成功”的临时故障,例如死锁、短暂锁冲突或被明确归类为瞬时的数据访问失败。参数校验失败、库存不足、状态机拒绝等业务失败不会因为重复执行而消失,应直接返回或进入补偿流程。

还要区分“事务已经回滚”和“调用可以安全重放”。一次尝试失败后,应先让当前事务结束,再等待并启动下一次独立事务。若响应丢失导致提交结果不确定,调用方也必须复用同一个幂等键,让数据库判断之前是否已经成功。

用数据库唯一约束建立幂等边界

先调用 existsByIdempotencyKey() 再执行插入存在竞态:两个并发请求可能同时查到“不存在”,随后都继续写入。真正的并发裁决点必须是数据库唯一约束,使“同一个幂等键只能成功插入一次”成为原子事实。

下面使用 idempotency_key 作为订单表主键,并用条件更新扣减库存。脚本可重复执行,最后一条查询用于确认实验初始状态。

sql
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';

预期结果

text
sku    | available
SKU-1  | 10

主键或唯一索引必须是真实的数据库约束,而不是只靠应用先查后写。两个请求并发使用同一个 idempotency_key 时,数据库会让一个插入成功;若该事务最终提交,另一个请求会得到重复键异常,再读取并校验已有订单即可。

把有限重试放在事务外层

下面是项目内可运行的主示例,依赖已经配置好的 DataSource 和 Spring JDBC。TransactionTemplate 使用 PROPAGATION_REQUIRES_NEW,因此每次循环尝试都会创建新事务;退避发生在事务之外,不会在睡眠期间继续持有数据库锁。示例还提供一次性故障注入,只用于本地验证重试路径,生产代码应移除该注入入口。

java
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);
    }
}

预期结果

text
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 或可靠消息异步发送;消费者也按业务键去重。

避免重试放大故障

最危险的场景是“数据库可能已经提交,但响应在返回前丢失”。此时再次请求不是简单地重做失败操作,而是在确认第一次是否已成功;复用原幂等键后,重复创建会被唯一约束转换为读取已有结果,从而避免再次扣库存或再次生成订单。

持续性故障下还要防止重试风暴。重试次数必须有限,等待时间应递增并带抖动,同时记录幂等键、异常分类、尝试次数、最终结果和总耗时。原则可以归纳为三点:先结束当前事务再重试;每次重试复用同一个业务身份;所有真实副作用都必须有幂等保护。

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

目录与阅读设置

记录一个想法

处理失败重试与幂等

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

登录哪都通