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

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

一.防重复提交概述

1.接口幂等性

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

在我们编程中常见幂等

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

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

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

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

3.常用解决方案

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

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

二.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 nowDataMap = new HashMap();
    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 sessionMap = (Map) sessionObj;
        if (sessionMap.containsKey(url))
        {
            Map preDataMap = (Map) sessionMap.get(url);
            //如果请求地址相同、请求参数相同而且时间间隔小于间隔时间，则视为重复请求，直接返回。
            if (compareParams(nowDataMap, preDataMap) && compareTime(nowDataMap, preDataMap, annotation.interval()))
            {
                return true;
            }
        }
    }
    //如果不是重复请求则将锁存进Redis中，过期时间为所设定的时间间隔然后返回。
    Map cacheMap = new HashMap();
    cacheMap.put(url, nowDataMap);
    redisCache.setCacheObject(cacheRepeatKey, cacheMap, annotation.interval(), TimeUnit.MILLISECONDS);
    return false;
}

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

/**
 * 判断两次间隔时间
 */
private boolean compareTime(Map nowMap, Map 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，过期时间为所设定的时间间隔，然后结束。

三.其他实现方案

​ 防重复提交后端常用的解决方案是Redis分布式锁，但是也可以通过mysql分布式锁，zookeeper分布式锁实现，由于性能和可用性的综合考虑所以使用Redis分布式锁的业务场景较多。