简单的幂等性校验

于 2024-08-12 08:00:00 发布
阅读量1.1k 收藏 13
点赞数 27
分类专栏： java小记 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19342829/article/details/141052120
版权

简单的幂等性校验

1. 需求

项目开发过程中，发现有部分接口数据操作不正确，出现数据重复问题，最后发现是接口连点发生了重复数据生成，所以此处我们新增了一个简易的防连点幂等校验功能，主要是使用redis以及spring aop切面进行的实现。

2. 具体实现逻辑

  • 拦截用户发起请求
  • 获取请求中的请求路径以及用户携带token信息，确定唯一用户单一功能点击
  • 使用获取信息进行redis加锁【加锁带有超时时间】，如果加锁成功正常执行后续操作，失败进行用户连点提示
  • 执行完毕、超过、执行报错抛出异常情况下，自动释放锁，方便用户后续再次进行此功能操作

3. 实现代码

代码部分主要包含三部分，切面部分，注解部分以及redis锁部分，具体代码实现如下

  • 注解部分

    package cn.git.common.idempotent;

import cn.git.common.lock.LockTypeEnum;

import java.lang.annotation.*;

/**
 * @program: bank-credit-sy
 * @description: 接口幂等性注解
 * @author: wanglianli
 * @create: 2021-02-26 08:57
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ApiIdempotent {

    /**
     * 幂等操作枚举类型
     * @return
     */
    LockTypeEnum lockTypeEnum() default LockTypeEnum.BASE_SERVER_IDEMPOTENCE;

}

  • 切面部分

    package cn.git.common.idempotent;

import cn.git.common.constant.HeaderConstant;
import cn.git.common.exception.ServiceException;
import cn.git.common.lock.LockTypeEnum;
import cn.git.common.lock.SimpleDistributeLock;
import cn.git.common.log.LogOperateProperties;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * @program: bank-credit-sy
 * @description: 幂等性切面实现
 * @author: wanglianli
 * @create: 2021-03-02 10:40
 */
@Aspect
@Slf4j
@Component
public class IdempotentAspect {

    /**
     * 幂等加锁value值
     */
    private static final ThreadLocal<String> IDEMPOTENT_VALUE = new ThreadLocal<>();

    /**
     * 设置幂等加锁值
     * @param idempotentValue 值信息
     */
    private void setIdempotentValue(String idempotentValue) {
        if (StrUtil.isNotBlank(idempotentValue)) {
            IDEMPOTENT_VALUE.set(idempotentValue);
        }
    }

    /**
     * 获取幂等加锁值
     * @return 加锁值信息
     */
    private String getIdempotentValue() {
        return IDEMPOTENT_VALUE.get();
    }

    /**
     * 删除幂等加锁值信息
     */
    private void removeIdempotentValue() {
        IDEMPOTENT_VALUE.remove();
    }

    @Autowired
    private SimpleDistributeLock simpleDistributeLock;

    /**
     * 前置切面
     * @param joinPoint
     */
    @Before("@annotation(apiIdempotent)")
    public void beforePointCut(JoinPoint joinPoint, ApiIdempotent apiIdempotent) {
        // 获取请求url信息以及token信息,并且进行幂等加锁
        String lockKeySuffix = getLockKeySuffix();

        // 幂等类型
        LockTypeEnum lockTypeEnum = LockTypeEnum.BASE_SERVER_IDEMPOTENCE;
        if (ObjectUtil.isNotNull(apiIdempotent)) {
            lockTypeEnum = apiIdempotent.lockTypeEnum();
        }

        // 开始进行加锁
        String lockResult = simpleDistributeLock.tryLock(lockTypeEnum, lockKeySuffix);

        // 如果返回加锁信息不为空，则加锁成功
        if (StrUtil.isBlank(lockResult)) {
            log.error("幂等请求加锁失败，加锁key信息为[{}]", lockKeySuffix);
            throw new ServiceException(StrUtil.format("幂等校验失败，请勿重复快速点击!", lockKeySuffix));
        } else {
            // 设置线程信息,后续解锁使用
            setIdempotentValue(lockResult);
        }
    }

    /**
     * 后置切面
     * @param joinPoint
     */
    @AfterReturning("@annotation(apiIdempotent)")
    public void afterReturning(JoinPoint joinPoint, ApiIdempotent apiIdempotent) {
        try {
            // 获取加锁key后缀信息
            String lockKeySuffix = getLockKeySuffix();
            if (StrUtil.isBlank(lockKeySuffix)) {
                log.error("后置切面获取加锁后缀值信息失败!");
                return;
            }

            // 幂等类型
            LockTypeEnum lockTypeEnum = LockTypeEnum.BASE_SERVER_IDEMPOTENCE;
            if (ObjectUtil.isNotNull(apiIdempotent)) {
                lockTypeEnum = apiIdempotent.lockTypeEnum();
            }

            // 获取线程加锁value信息
            String idempotentValue = getIdempotentValue();
            if (ObjectUtil.isNotNull(idempotentValue)) {
                // 释放锁信息
                simpleDistributeLock.releaseLock(lockTypeEnum, lockKeySuffix, idempotentValue);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放设定值信息
            removeIdempotentValue();
        }
    }

    /**
     * 后置异常切面 捕获异常信息
     * @param joinPoint joinPoint
     * @param e 异常信息
     */
    @AfterThrowing(value = "@annotation(apiIdempotent)" , throwing = LogOperateProperties.LOG_EXCEPTION)
    public void afterThrowing(JoinPoint joinPoint, ApiIdempotent apiIdempotent, Exception e) {
        try {
            // 获取加锁key后缀信息
            String lockKeySuffix = getLockKeySuffix();
            if (StrUtil.isBlank(lockKeySuffix)) {
                log.error("后置切面获取加锁后缀值信息失败!");
                return;
            }

            // 幂等类型
            LockTypeEnum lockTypeEnum = LockTypeEnum.BASE_SERVER_IDEMPOTENCE;
            if (ObjectUtil.isNotNull(apiIdempotent)) {
                lockTypeEnum = apiIdempotent.lockTypeEnum();
            }

            // 获取线程加锁value信息
            String idempotentValue = getIdempotentValue();
            if (ObjectUtil.isNotNull(idempotentValue)) {
                // 释放锁信息
                simpleDistributeLock.releaseLock(lockTypeEnum, lockKeySuffix, idempotentValue);
                // 释放线程值信息
                removeIdempotentValue();
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        } finally {
            // 释放设定值信息
            removeIdempotentValue();
        }
    }

    /**
     * 获取幂等性锁后缀信息
     * @return 后缀 信息
     */
    public String getLockKeySuffix() {
        // 获取请求url信息以及token信息
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (ObjectUtil.isNotNull(attributes) && ObjectUtil.isNotNull(attributes.getRequest())) {
            HttpServletRequest request = attributes.getRequest();
            // 设置锁key信息
            return request.getRequestURI()
                    .concat(StrUtil.COLON)
                    .concat(request.getHeader((HeaderConstant.HEADER_TOKEN)));
        }
        return null;
    }
}

  • redis锁部分，包含加锁以及释放锁

    package cn.git.common.lock;

import cn.git.redis.RedisUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;

import java.util.Collections;

/**
 * 简单分布式锁
 * todo: 暂时未实现重入，阻塞队列等锁定功能后续添加
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2022-04-25
 */
@Slf4j
@Component
public class SimpleDistributeLock {

    /**
     * LUA解锁脚本
     */
    private static final String UNLOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

    /**
     * 释放锁失败标识
     */
    private static final long RELEASE_OK_FLAG = 0L;

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 加锁方法
     * @param lockTypeEnum 锁信息
     * @param customKey 自定义锁定key
     * @return true 成功，false 失败
     */
    public String tryLock(LockTypeEnum lockTypeEnum, String customKey) {
        // 锁对应值信息
        String lockValue = IdUtil.simpleUUID();
        // 对自定义key进行加锁操作,value值与key值相同
        boolean result = redisUtil.setNxEx(lockTypeEnum.getLockType().concat(StrUtil.COLON).concat(customKey),
                lockValue,
                lockTypeEnum.getExpireTime().intValue());
        if (result) {
            log.info("[{}]加锁成功!", lockTypeEnum.getLockType().concat(StrUtil.COLON).concat(customKey));
            return lockValue;
        }

        return null;
    }

    /**
     * 解锁操作
     * @param lockTypeEnum 锁定类型
     * @param customKey 自定义key
     * @param releaseValue 释放value
     * @return true 成功，false 失败
     */
    public boolean releaseLock(LockTypeEnum lockTypeEnum, String customKey, String releaseValue) {
        // 各个模块服务启动时间差，预留5秒等待时间，防止重调用
        if (ObjectUtil.isNotNull(lockTypeEnum.getLockedWaitTimeMiles())) {
            try {
                Thread.sleep(lockTypeEnum.getLockedWaitTimeMiles());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 设置释放锁定key,value值
        String releaseKey = lockTypeEnum.getLockType().concat(StrUtil.COLON).concat(customKey);

        // 释放锁定资源
        RedisScript<Long> longDefaultRedisScript = new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class);
        Long result = redisUtil.executeLuaCustom(longDefaultRedisScript, Collections.singletonList(releaseKey), releaseValue);
        // 根据返回结果判断是否成功成功匹配并删除 Redis 键值对，若果结果不为空和0，则验证通过
        if (ObjectUtil.isNotNull(result) && result != RELEASE_OK_FLAG) {
            log.info("[{}]释放锁成功!", releaseKey);
            return true;
        } else {
            log.error("[{}]释放锁失败!", releaseKey);
            return false;
        }
    }

}

  • 其他部分工具类代码
    redisUtil加锁释放锁实现

        /**
     * 如果不存在，则设置对应key,value 键值对,并且设置过期时间
     * @param key 锁key
     * @param value 锁值
     * @param time 时间单位second
     * @return 设定结果
     */
    public Boolean setNxEx(String key, String value, long time) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * @Description: 执行lua脚本，只对key进行操作
     * @Param: [redisScript, keys, value]
     * @return: java.lang.Long
     * @Date: 2021/2/21 15:00
     */
    public Long executeLuaCustom(RedisScript<Long> redisScript, List keys, Object value) {
        return redisTemplate.execute(redisScript, keys, value);
    }

    加锁参数枚举类

    package cn.git.common.lock;

import lombok.Getter;

/**
 * 分布式锁类型设定enum
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2022-04-25
 */
@Getter
public enum LockTypeEnum {

    /**
     * 分布式锁类型详情
     */
    DISTRIBUTE_TASK_LOCK("DISTRIBUTE_TASK_LOCK", 120L, "xxlJob初始化分布式锁", 5000L),
    CACHE_INIT_LOCK("CACHE_INIT_LOCK", 120L, "缓存平台初始化缓存信息分布式锁", 5000L),
    RULE_INIT_LOCK("RULE_INIT_LOCK", 120L, "规则引擎规则加载初始化", 5000L),
    SEQUENCE_LOCK("SEQUENCE_LOCK", 120L, "序列信息月末初始化!", 5000L),
    UAA_ONLINE_NUMBER_LOCK("UAA_ONLINE_LOCK", 20L, "登录模块刷新在线人数", 5000L),
    BASE_SERVER_IDEMPOTENCE("BASE_IDEMPOTENCE_LOCK", 15L, "基础业务幂等性校验"),
    WORK_FLOW_WEB_SERVICE_LOCK("WORK_FLOW_WEB_SERVICE_LOCK", 15L, "流程webService服务可用ip地址获取锁", 5000L),
    DRAG_RULE_INIT_LOCK("DRAG_RULE_INIT_LOCK", 120L, "拖拽规则详情初始化锁", 5000L),
    DRAG_RULE_URI_LOCK("DRAG_RULE_URI_LOCK", 120L, "拖拽规则规则链初始化锁", 5000L),
    ;

    /**
     * 锁类型
     */
    private String lockType;

    /**
     * 即过期时间,单位为second
     */
    private Long expireTime;

    /**
     * 枷锁成功后，默认等待时间，时间应小于过期时间，单位毫秒
     */
    private Long lockedWaitTimeMiles;

    /**
     * 描述信息
     */
    private String lockDesc;

    /**
     * 构造方法
     * @param lockType 类型
     * @param lockTime 锁定时间
     * @param lockDesc 锁描述
     */
    LockTypeEnum(String lockType, Long lockTime, String lockDesc) {
        this.lockDesc = lockDesc;
        this.expireTime = lockTime;
        this.lockType = lockType;
    }

    /**
     * 构造方法
     * @param lockType 类型
     * @param lockTime 锁定时间
     * @param lockDesc 锁描述
     * @param lockedWaitTimeMiles 锁失效时间
     */
    LockTypeEnum(String lockType, Long lockTime, String lockDesc, Long lockedWaitTimeMiles) {
        this.lockDesc = lockDesc;
        this.expireTime = lockTime;
        this.lockType = lockType;
        this.lockedWaitTimeMiles = lockedWaitTimeMiles;
    }
}

4. 调用方式

想使用也非常简单，如果是特定功能，可以在枚举中新增自己的加锁枚举参数，也可以使用默认的加锁枚举类型，然后只需要在controller方法上加上@ApiIdempotent注解即可
在这里插入图片描述

小大力
关注
专栏目录
面试高频：什么是接口的幂等性，如何实现接口幂等性？
Java_Jishu的博客
11-18 1115
推荐阅读： 我总结了72份面试题，累计3170页，斩获了30+互联网公司offer（含BATJM） 2020首战告捷,这份Java面试神技Plus版，让我成功拿到了阿里、京东、字节跳动等大厂offer 膜拜！阿里内部都在强推的K8S(kubernetes)学习指南，不能再详细了 （一）幂等性概念 幂等性原本是数学上的概念，用在接口上就可以理解为：同一个接口，多次发出同一个请求，必须保证操作只执行一次。 调用接口发生异常并且重复尝试时，总是会造成系统所无法承受的损失，所以必须阻止这种现象的发生
幂等性的研究及后台验证短时间内同一申请是否重复提交的方案
yowasa的博客
05-26 2862
重复性校验：幂等性校验与纯后台程序短时间重复申请过滤
aop 幂等验证（二）
正怒月神的博客
04-25 563
1 创建IIdempotent @Target({ElementType.PARAMETER, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface IIdempotent { } 2 创建aop @Component @Aspect public class I...
幂等性校验
学无止境
10-21 1672
幂等性校验：基于spring boot 的拦截器功能+ redis
Java使用注解优雅的进行接口幂等性校验
weixin_45795312的博客
01-19 1624
什么是幂等？ 用户对于同一操作发起的一次请求或者多次请求的结果是一致的。 数据库操作中：SELECT UPDATE DELETE 操作天然就是幂等的，同样的语句执行多次结果都不会产生变化，唯一的就是受影响的行数会变化，但 INSERT 插入操作则不是(在未指定主键或唯一性字段的前提下)；所以需要我们在Java层面保证请求为幂等。否则会出现多次下单、数据异常、扣款重复等情况。闲话少说，说时迟那时快，抄起键盘就是干！ 1、定义一个幂等校验的注解,使用的时候放在需要保证幂等的请求方法上即可。 /** *
接口幂等性校验（使用拦截器+自定义注解+redis解决问题）
qq_42926855的博客
02-13 1668
使用 拦截器+自定义注解+redis解决接口幂等性问题
AOP 实现接口安全性幂等性校验
zsj777的专栏
06-15 323
1、接口安全性校验注解 和接口幂等性校验注解 aop拦截器 注册拦截器 测试请求
后端接口幂等性校验（数据库唯一索引 + 自定义注解和拦截器的token校验）
LO_YUN的博客
09-17 2208
最近工作中需要实现一个防止重复提交的任务，其本质就是需要保证接口的幂等性。接口幂等性就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。 采用的方案包括了两部分，一部分核心的业务逻辑使用token校验，另一部分使用数据库的唯一索引来防止重复更改数据库。 先来说说使用数据库唯一索引的方案，使用数据库唯一索引的方案可以防止数据库表中在唯一索引字段相同的情况下去...
java幂等性实现及校验代码（全套流程）
yushun的博客
11-30 775
使用场景： 我们实际系统中有很多操作，是不管做多少次，都应该产生一样的效果或返回一样的结果。 例如1. 前端重复提交选中的数据，应该后台只产生对应这个数据的一个反应结果；2. 我们发起一笔付款请求，应该只扣用户账户一次钱，当遇到网络重发或系统bug重发，也应该只扣一次钱；3. 发送消息，也应该只发一次，同样的短信发给用户，用户会哭的；4. 创建业务订单，一次业务请求只能创建一个，创建多个就会出大问题等等很多重要的情况都需要幂等的特性来支持。 效果如下： 实现原理： String idempotentK
【安全】Java幂等性校验解决重复点击（6种实现方式）
最新发布
ACGkaka的博客
11-04 6135
【安全】Java幂等性校验解决重复点击（6种实现方式）
面试官：如何实现幂等性校验？
这个时代，作为程序员可能要学习小程序
11-01 849
点击上方关注 “终端研发部”设为“星标”，和你一起掌握更多数据库知识作者 |wangzaiplus来源 | https://www.jianshu.com/p/6189275403ed一、概念幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次比如:订单接口, 不能多次创建订单支付接口, 重复支付同一笔订单只能扣一次钱支付宝回调接口, 可能会多次回调, 必须处理重复回...
接口幂等性校验，太优雅了(经典)
gb4215287的博客
10-15 941
接口幂等性校验，太优雅了
幂等校验是什么意思_接口的幂等性怎么设计？
weixin_30824577的博客
01-28 4896
点击上方IT牧场，选择置顶或者星标技术干货每日送达自己最近负责的几个接口，都涉及到了幂等性的操作，抽空总结了一下，这也是面试官比较爱问的问题。一、什么是幂等？看一下维基百科怎么说的：幂等性：多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。二、使用幂等的场景1、前端重复提交用户注册，用户创建商品等操作，前端都会提交一些数据给后台服务，后台需要根据用户...
接口的幂等性
suixinsuoyu12519的专栏
09-17 351
最近跟朋友聊起这个话题,想深入了解下,于是学习总结,记录下来,此文章参考以下博客综合而来表示感谢: http://blog.brucefeng.info/post/api-idempotent http://825635381.iteye.com/blog/2276077 https://www.cnblogs.com/leechenxiang/p/6626629.html 1. 接口调用存在的问题 现如今我们的系统大多拆分为分布式SOA，或者微服务，一套系统中包含了多个子系统服务...
怎么保证接口幂等性？
qq_35599414的博客
11-26 831
什么是幂等性就不说了 对于数据库的一些操作中，有一些是天然的具备有幂等性的，例查询、删除、非增量更新（不管你查多少次，都是那个结果；不管你删几次，你只能删除一次成功；只要不是对某属性进行+-操作，你更新多少次都是那个结果） 而对于新增、也会存在天然幂等性的情况，如果插入的数据中，有属性属于唯一约束的，则是天然幂等性情况（例如字段phone是唯一的，此时由于字段的唯一性约束，如果同一phone的值插入多次是只有一次成功的），而如果没有唯一性约束则需要进行幂等保证。 唯一性约束也常常被用来保证幂等性 .
Spring Boot + Redis 实现接口幂等性 | 分布式开发必知！
程序猿DD
08-11 1415
点击蓝色“程序猿DD”关注我回复“资源”获取独家整理的学习资料！来源：http://tinyurl.com/y5k2sx5t>>阿里云8月最新优惠，点击查看&...
接口幂等性校验
热门推荐
huchao_lingo的博客
04-15 1万+
接口幂等性校验   一、概念 幂等（idempotent、idempotence）是一个数学与计算机学概念，常见于抽象代数中。 在编程中.一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同。幂等函数，或幂等方法，是指可以使用相同参数重复执行，并能获得相同结果的函数。 这些函数不会影响系统状态，也不用担心重复执行会对系统造成改变。例如，“getUsername()和set...
幂等性校验自定义注解
10-12
幂等性校验自定义注解可以用于标记某个方法需要进行幂等性校验，以确保同一个请求不会被重复处理。下面是一个简单的示例： ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值