Redis分布式锁实现后端防重复提交

Katyn Plum

已于 2023-03-05 21:00:10 修改

阅读量2.7k

点赞数 5

于 2023-03-05 20:59:42 首次发布

本文链接：https://blog.csdn.net/weixin_46906359/article/details/129351077

版权

Redis分布式锁实现后端防重复提交

一.防重复提交概述

1.接口幂等性

幂等性原本是数学上的概念，用在接口上就可以理解为：同一个接口，多次发出同一个请求，必须保证操作只执行一次。

在我们编程中常见幂等

select查询天然幂等
delete删除也是幂等,删除同一个多次效果一样
update直接更新某个值的,幂等
update更新累加操作的,非幂等（比如库存-1之类的）
insert是非幂等操作,每次新增一条（多次就会增加多条）

2.接口非幂等性（重复提交）产生原因

由于重复点击或者网络重发 eg:

点击提交按钮两次;
点击刷新按钮;
使用浏览器后退按钮重复之前的操作，导致重复提交表单;
使用浏览器历史记录重复提交表单;
浏览器重复的HTTP请求;
nginx重发等情况;
分布式RPC的try重发等;

3.常用解决方案

前端防重复提交：比如点击后按钮禁用，或者加个遮罩层转圈等。
后端防重复提交：分布式锁/本地锁（根据部署环境）。

本文我们主要介绍分布式锁，因为应用的项目是微服务项目，可能会部署集群。

二.Redis分布式锁实现防重复提交（若依项目）

若依项目的防重复提交后端是使用Redis分布式锁+注解实现，使用的话就在controller中的方法加上注解就行。

1.RepeatSubmit注解

@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatSubmit
{
    /**
     * 间隔时间(ms)，小于此时间视为重复提交
     */
    public int interval() default 5000;

    /**
     * 提示消息
     */
    public String message() default "不允许重复提交，请稍候再试";
}

2.前端请求监听类

若依项目使用拦截器拦截所有使用了@RepeatSubmit注解的方法，判断是否是重复提交，如果是的话就直接返回错误信息，否则就放过。

@Component
public abstract class RepeatSubmitInterceptor implements HandlerInterceptor
{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
    {
        if (handler instanceof HandlerMethod)
        {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            //判断是否添加了防重复提交的注解
            RepeatSubmit annotation = method.getAnnotation(RepeatSubmit.class);
            if (annotation != null)
            {
            	//判断该请求是否重复提交
                if (this.isRepeatSubmit(request, annotation))
                {
                    //封装错误信息，直接返回
                    AjaxResult ajaxResult = AjaxResult.error(annotation.message());
                    ServletUtils.renderString(response, JSON.toJSONString(ajaxResult));
                    return false;
                }
            }
            return true;
        }
        else
        {
            return true;
        }
    }

    /**
     * 验证是否重复提交由子类实现具体的防重复提交的规则
     *
     * @param request
     * @return
     * @throws Exception
     */
    public abstract boolean isRepeatSubmit(HttpServletRequest request, RepeatSubmit annotation);
}

3.防重复提交实现类

@Override
public boolean isRepeatSubmit(HttpServletRequest request, RepeatSubmit annotation)
{
    String nowParams = "";
    if (request instanceof RepeatedlyRequestWrapper)
    {
        RepeatedlyRequestWrapper repeatedlyRequest = (RepeatedlyRequestWrapper) request;
        nowParams = HttpHelper.getBodyString(repeatedlyRequest);
    }
    //获取请求参数
    // body参数为空，获取Parameter的数据
    if (StringUtils.isEmpty(nowParams))
    {
        nowParams = JSON.toJSONString(request.getParameterMap());
    }
    Map<String, Object> nowDataMap = new HashMap<String, Object>();
    nowDataMap.put(REPEAT_PARAMS, nowParams);
    nowDataMap.put(REPEAT_TIME, System.currentTimeMillis());

    // 请求地址（作为存进Redis的key值），没有使用url是因为所有请求的前缀都是一样的（http://ip地址:端口号），微服务
    项目使用nginx所在服务器的IP地址和端口号，之后再转发到网关。
    String url = request.getRequestURI();
    // 唯一值（没有消息头则使用请求地址）
    String submitKey = StringUtils.trimToEmpty(request.getHeader(header));

    // 唯一标识（指定key + url + 消息头） 消息头相当于登录用户的唯一标识，唯一标识主要靠token区分。
    String cacheRepeatKey = CacheConstants.REPEAT_SUBMIT_KEY + url + submitKey;
    //从Redis获取锁
    Object sessionObj = redisCache.getCacheObject(cacheRepeatKey);
    if (sessionObj != null)
    {
        Map<String, Object> sessionMap = (Map<String, Object>) sessionObj;
        if (sessionMap.containsKey(url))
        {
            Map<String, Object> preDataMap = (Map<String, Object>) sessionMap.get(url);
            //如果请求地址相同、请求参数相同而且时间间隔小于间隔时间，则视为重复请求，直接返回。
            if (compareParams(nowDataMap, preDataMap) && compareTime(nowDataMap, preDataMap, annotation.interval()))
            {
                return true;
            }
        }
    }
    //如果不是重复请求则将锁存进Redis中，过期时间为所设定的时间间隔然后返回。
    Map<String, Object> cacheMap = new HashMap<String, Object>();
    cacheMap.put(url, nowDataMap);
    redisCache.setCacheObject(cacheRepeatKey, cacheMap, annotation.interval(), TimeUnit.MILLISECONDS);
    return false;
}

/**
 * 判断参数是否相同
 */
private boolean compareParams(Map<String, Object> nowMap, Map<String, Object> preMap)
{
    String nowParams = (String) nowMap.get(REPEAT_PARAMS);
    String preParams = (String) preMap.get(REPEAT_PARAMS);
    return nowParams.equals(preParams);
}

/**
 * 判断两次间隔时间
 */
private boolean compareTime(Map<String, Object> nowMap, Map<String, Object> preMap, int interval)
{
    long time1 = (Long) nowMap.get(REPEAT_TIME);
    long time2 = (Long) preMap.get(REPEAT_TIME);
    if ((time1 - time2) < interval)
    {
        return true;
    }
    return false;
}

总结一下：注解+Redis分布式锁解决防重复提交分为以下几步

1.编写防重复提交注解@RepeatSubmit

2.使用拦截器（Spring的AOP也可以）拦截所有加了该注解的方法。

3.在拦截器中判断是否是请求重复提交，判断逻辑如下。

4. 初始化Redis分布式锁的key和value，key为请求地址+用户唯一标识，value为一个Map，里面是请求参数和请求抵达时间。

5.通过key获取Redis中的锁，如果满足（获取到了锁、value相同、两次请求间隔时间小于指定的间隔时间）这三个条件则视为重复请求，如果没获取到视为非重复请求，将key和value存进Redis，过期时间为所设定的时间间隔，然后结束。