114 接口中幂等性的保证

前言

同样是面试问题

如何确保接口的幂等性

幂等是一个较为抽象的概念, 多次重复访问, 不会导致业务逻辑的异常

这里从增删改查, 几个方面列一下

一般来说, 我们核心需要关注的就是新增和更新

对于增加元素, 首先针对唯一约束进行校验, 然后再处理新增的相关业务, 严格一点需要加锁, 分布式并发控制

对于删除元素, 就是检查元素存不存在, 存在则删除, 不存在返回相关状态吗, 或者直接成功都 OK

元素的新增

基于持久化的数据库的机制

比如 mysql 这边目标表, 增加唯一索引, 或者主键

比如, 我们这里限定在用户表中用户名不能重复, 这个只有特定的业务场景中可以这么处理

CREATE TABLE `auth_user` (
  `id` int(11) NOT NULL,
  `name` varchar(256) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `name` (`name`) USING BTREE COMMENT 'name'
) ENGINE=InnoDB DEFAULT CHARSET=utf8

然后服务器这边就不用做过多的控制, 核心业务部分直接 "insert into" 都可以

由 mysql 这边本身的机制来确保用户名的不能重复, 防止用户多次提交造成的业务问题

分布式并发过滤控制 + 数据库的悲观锁

我们这里展现一下完整的处理流程, 主要是包含了外层的并发过滤控制, 数据库校验控制, 数据库加锁+插入控制

这里分布式并发控制这里模拟实现, 是 userRunningStore 部分

并发过滤控制这边处理如下, 基于 spring 的注解 + aop

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ConcurrentLatch {

}

并发过滤控制的处理如下

@Component
@Aspect
public class ConcurrentLatchAop {

    @Pointcut("@annotation(ConcurrentLatch)")
    public void concurrentLatchAop() {

    }

    Set<String> userRunningStore = new LinkedHashSet<>();

    @Around("concurrentLatchAop()")
    public Object doProcess(ProceedingJoinPoint point) throws Throwable {
        Object[] args = point.getArgs();
        AuthUser user = (AuthUser) args[0];

        String name = user.getName();
        // lock
        if (userRunningStore.contains(name)) {
            throw new RuntimeException(String.format("有其他用户在新增用户 %s, 请刷新后重试", name));
        }
        userRunningStore.add(name);
        // unlock

        Object result = point.proceed();
        return result;
    }

}

数据库校验控制, 数据库加锁+插入控制如下

@PutMapping("/user")
@ConcurrentLatch
public AuthUser add(AuthUser user) {
    // physic verify
    if (user.getAge() > 0 && user.getAge() < 111) {
        throw new RuntimeException("用户的 age 必须在合法的区间");
    }
    // logistic verify
    Map<String, Object> existsUser = JdbcTemplateUtils.queryOne(jdbcTemplate, String.format(" select * from auth_user where name = '%s'; ", user.getName()));
    if (existsUser != null) {
        throw new RuntimeException("该用户已经存在, 用户名称不能重复");
    }

    // do other biz

    // lock then insert
    existsUser = JdbcTemplateUtils.queryOne(jdbcTemplate, String.format(" select * from auth_user where name = '%s' for update; ", user.getName()));
    if (existsUser != null) {
        throw new RuntimeException("该用户已经存在, 用户名称不能重复");
    }
    jdbcTemplate.execute(String.format("INSERT INTO `auth_user`(`name`, `age`) VALUES ('%s', %s);", user.getName(), user.getAge()));
    return user;
}

t oken 分布式并发控制 + 数据库的悲观锁

这个就主要是整体的交互机制调整, 增加了一层 token 的获取和验证

token 的分派这边如下, 做限流, 生成 token 的相关处理

public static Map<String, AtomicInteger> interf2Counter = new LinkedHashMap<>();
public static Set<String> tokenStore = new LinkedHashSet<>();

// pre install all interfs
static {
    interf2Counter.put("IdempotentController.add", new AtomicInteger());
}

@GetMapping("/requestToken")
public String requestToken(String interf) {
    AtomicInteger counter = interf2Counter.get(interf);
    int incred = counter.getAndIncrement();
    // rate limit
    if (incred > 20) {
        counter.getAndDecrement();
        throw new RuntimeException(" 服务器繁忙, 请稍后重试 ");
    }

    String token = UUID.randomUUID().toString();
    String compositeToken = interf + token;
    tokenStore.add(compositeToken);
    return token;
}

并发控制这边处理如下

/**
 * ConcurrentLatchAop
 *
 * @author Jerry.X.He
 * @version 1.0
 * @date 2023/9/21 10:17
 */
@Component
@Aspect
public class ConcurrentLatchAop {

    @Pointcut("@annotation(ConcurrentLatch)")
    public void concurrentLatchAop() {

    }

    @Around("concurrentLatchAop()")
    public Object doProcess(ProceedingJoinPoint point) throws Throwable {
        Object[] args = point.getArgs();
        String interf = "get interf from request";
        String token = "get token from request";

        // lock
        if (!IdempotentController.tokenStore.contains(token)) {
            throw new RuntimeException("服务器异常, 请刷新后重试");
        }
        IdempotentController.tokenStore.remove(token);
        // unlock

        Object result = point.proceed();
        AtomicInteger counter = IdempotentController.interf2Counter.get(interf);
        counter.getAndDecrement();
        return result;
    }

}

元素的更新

以上三种处理方式在元素的更新中同样可以使用

元素的更新数据库的更新控制这边可以使用基于数据库的乐观锁

数据库的乐观锁更新

并发控制这边和上面类似, 我们这里着重关注数据库的更新这边

数据库的更新这边, 主要是增加一个版本号的字段, 然后更新的时候在原有的 id 条件之外, 再增加一个 version 控制的字段

根据 mysql 这边更新, 会增加行排他锁, 具体的处理如下

/**
 * IdempotentController
 *
 * @author Jerry.X.He
 * @version 1.0
 * @date 2023/9/21 9:58
 */
@RestController
@RequestMapping("/idempotent")
public class IdempotentController {

    @Resource
    private JdbcTemplate jdbcTemplate;

    @PostMapping("/user")
    @ConcurrentLatch
    public AuthUser update(AuthUser user) {
        // physic verify
        if (user.getAge() > 0 && user.getAge() < 111) {
            throw new RuntimeException("用户的 age 必须在合法的区间");
        }
        // logistic verify
        Map<String, Object> existsUser = JdbcTemplateUtils.queryOne(jdbcTemplate, String.format(" select * from auth_user where name = '%s'; ", user.getName()));
        if (existsUser == null) {
            throw new RuntimeException("该用户不存在, 请确认输入");
        }

        // do other biz

        // lock then insert
        String id = String.valueOf(existsUser.get("id"));
        String version = String.valueOf(existsUser.get("version"));
        int updatedCount = jdbcTemplate.update(String.format("update auth_user set name = '%s', age = %s where id = %s and version = %s;", user.getName(), user.getAge(), id, version));
        if (updatedCount == 0) {
            throw new RuntimeException("该用户信息已经发生改变, 请刷新后重试");
        }
        return user;
    }

}

完