SpringBoot + Redis实现接口的幂等性

SpringBoot + Redis实现接口的幂等性

 

简介：

幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次。

比如:

• 订单接口, 不能多次创建订单。
• 支付接口, 重复支付同一笔订单只能扣一次钱。

产生原因：

• 1) 点击提交按钮两次;
• 2) 点击刷新按钮;
• 3) 使用浏览器后退按钮重复之前的操作，导致重复提交表单;
• 4) 使用浏览器历史记录重复提交表单;
• 5) 浏览器重复的HTTP请求;
• 6) nginx重发等情况;

开发过程使用场景

对于数据库<mysql> 的新增（insert） 和 修改（update）操作需要实现幂等的，因为多次操作会导致结果不一致或者数据重复。而查询（select）、删除(delete) 操作是天然幂等的。

常用解决方案

1、Mysql 唯一索引，防止新增脏数据
    唯一索引或唯一组合索引来防止新增数据存在脏数据 (当表存在唯一索引，并发新增会报错)

2、Mysql悲观锁(用在修改操作)
获取数据的时候加锁获取, 悲观锁使用时一般伴随事务一起使用，数据锁定时间可能会很长，根据实际情况选用。

# 注意：id字段一定是主键或者唯一索引，不然是锁表，会死人的 
select * from table_xxx where id='xxx' for update; 

3、乐观锁（用在修改操作时）
乐观锁只是在更新数据那一刻锁表，其他时间不锁表，所以相对于悲观锁，效率更高。
乐观锁的实现方式多种多样可以通过version或者其他状态条件：

update table_xxx set name={name},version=version+1 where version={version} 

4、 分布式锁（修改操作）
redis(jedis、redisson)或zookeeper实现。

5、 select + insert（先查询再新增，用在新增时）
并发不高的后台系统，或者一些任务JOB，为了支持幂等，支持重复执行，简单的处理方法是，先查询下一些关键数据，判断是否已经执行过，在进行业务处理，就可以了。
注意：核心高并发流程不要用这种方法

6、token机制 （SpringBoot + Redis实现）
业务要求： 页面的数据只能被点击提交一次
发生原因： 由于重复点击或者网络重发，或者nginx重发等情况会导致数据被重复提交
解决办法：

• 集群环境：采用token加redis（redis单线程的，处理需要排队）
• 单JVM环境：采用token加redis或token加jvm内存

SpringBoot + Redis实现接口幂等，防止重复提交

 

实现原理：

 

 完整代码：

1： Redis配置，这里就不讲了，请参考： https://www.cnblogs.com/dw3306/p/9520741.html

2： 自定义注解 @ApiIdempotent

/**
 * @Author dw
 * @ClassName ApiIdempotent
 * @Description 自定义注解实现接口的幂等性
 * @Date 2021/1/30 13:06
 * @Version 1.0
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiIdempotent {

}

 

3: 定义Token接口用于创建、验证Token

/**
 * @Author dw
 * @ClassName ITokenService
 * @Description 创建Token的接口，主要是生成接口的唯一Token、并且校验Token
 * @Date 2021/1/30 13:10
 * @Version 1.0
 */
public interface ITokenService {

    /**
     * 创建Token
     * @return
     */
    String createToken();

    /**
     * 效验Token
     * @param request
     * @return
     */
    boolean checkToken(HttpServletRequest request);
}

 

4、定义Token的实现类

/**
 * @Author dw
 * @ClassName TokenServiceImpl
 * @Description
 * @Date 2021/1/30 13:14
 * @Version 1.0
 */
@Service
public class TokenServiceImpl implements ITokenService {

    @Autowired
    RedisUtils redisUtils;

    @Override
    public String createToken() {
        String token = UUID.randomUUID().toString().replaceAll("-", "");
        redisUtils.set(token, token, 10000L);
        return token;
    }

    @Override
    public boolean checkToken(HttpServletRequest request) {
        // 检查请求信息是否携带Token
        String token = request.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            // head中不存在检查parameter
            token = request.getParameter("token");
            if(StringUtils.isEmpty(token)){
                throw new RuntimeException("没有获取到访问接口的Token字段");
            }
        }
        // 检查redis中是否存在key，如果不存在说明之前该接口已经请求过了
        if (!redisUtils.hasKey(token)) {
            throw new RuntimeException("重复请求");
        }
        // 效验成功，删除Token
        boolean remove = redisUtils.del(token);
        /**
         * 这里要注意：不能单纯的直接删除token而不校验token是否删除成功，会出现并发安全问题
         * 在多线程情况下，此时token还未被删除，继续向下执行
         */
        if (!remove) {
            throw new RuntimeException("token delete fail");
        }
        return true;
    }

}

 

RedisUtil

/**
     * 删除缓存，支持批量删除
     *
     * @param key
     */
    public boolean del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                return redisTemplate.delete(key[0]);
            } else {
                Long delete = redisTemplate.delete(Arrays.asList(key));
                if(delete > 0){
                    return true;
                }
                return false;
            }
        }
        return false;
    }


/**
     * 设置值并设置过期时间（单位秒）
     *
     * @param key
     * @param value
     * @param time  过期时间
     * @return
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error(e.getMessage());
            return false;
        }
    }

 

5、自定义拦截器

/**
 * @Author dw
 * @ClassName ApiIdempotentInterceptor
 * @Description 接口幂等性拦截器
 * @Date 2021/1/30 21:52
 * @Version 1.0
 */
@Component
public class ApiIdempotentInterceptor implements HandlerInterceptor {


    @Autowired
    private TokenServiceImpl tokenService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        ApiIdempotent apiIdempotent = method.getAnnotation(ApiIdempotent.class);
        if (apiIdempotent != null) {
            // 幂等性校验，通过则放行；失败抛出异常，统一异常处理返回友好提示
            tokenService.checkToken(request);
        }
        // 这里必须返回true，否则会拦截一切请求
        return true;
    }

}

 

6、注册拦截器

/**
 * @Author dw
 * @ClassName MyWebMvcConfig
 * @Description
 * @Date 2021/1/30 22:16
 * @Version 1.0
 */
@Configuration
public class MyWebMvcConfig extends WebMvcConfigurationSupport {

    @Autowired
    private ApiIdempotentInterceptor apiIdempotentInterceptor;

    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(apiIdempotentInterceptor);
        super.addInterceptors(registry);
    }
}

 

7、测试

/**
 * @Author dw
 * @ClassName TestApiIdempotentController
 * @Description  测试接口幂等性
 * @Date 2021/1/30 22:21
 * @Version 1.0
 */
@RestController
public class TestApiIdempotentController {

    @Resource
    private ITokenService tokenService;

    @GetMapping("/getToken")
    public String getToken() {
        String token = tokenService.createToken();
        return token;
    }


    @ApiIdempotent
    @PostMapping("/testIdempotent")
    public String testIdempotent() {
        try {
            // 模拟业务执行耗时
            Thread.sleep(500);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "SUCCESS";
    }

}