防重复提交

简介：
（1）客户端访问时，拦截访问数据，
（2）进行验证是否是配置的时间内（如下例子：ttl = 10），有相同的参数访问，
（3）如果有就相当于数据重复访问，直接返回。
（4）以下两种方法供大家参考，每个人都有自己喜欢的方式去使用
实例<一>：
引入jia包：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

后台代码

	//防重复提交，表示10秒之内的不允许有相同的ps数据，也就是说10秒之内不允许有相同的ps = {"req.mobile"}
    @RequestMapping("/request")
    @Recommit(ttl = 10, ps = {"req.mobile"}, type = 2)
    public Result applyFranchiseStore(Req req) {
        try {
            return userMemberApplyService.applyIdentity(req);
        } catch (Exception e) {
            log.error("申请代理人或者加盟店异常" + req.toString(), e);
            return Result.buildFail("申请失败");
        }
    }

配置重复提交

package dorago.yiqiancms.biz.common.recommit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

    /**
     * 参与重复提交计算的请求参数
     * @return
     */
    String[] ps() default {};

    /**
     * 周期内参数相同的提交判定为重复提交
     * 单位: 秒
     * @return
     */
    int ttl() default 1;

    /**
     * 使用方区分:1.app 2.h5   如果不需要区分 此参数可以不要
     * @return
     */
    int type() default 1;

}

请求拦截，检查重复性

package com.dorago.common.interceptor.recommit;

import com.alibaba.fastjson.JSON;
import com.dorago.common.Result;
import com.dorago.common.SpringUtil;
import com.dorago.common.interceptor.log.MethodLogAspect;
import com.dorago.syj.biz.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.Arrays;

@Aspect
@Component
@Slf4j
@Order(1)
public class RecommitAspect {

    @Resource
    RedisUtil redisUtil;

    @Pointcut("@annotation(com.dorago.common.interceptor.recommit.Recommit)")
    public void recommitPointcut(){}

    @Around("recommitPointcut()")
    public Object doAround(ProceedingJoinPoint jp) throws Throwable {
        boolean recommited = false;
        Object result;
        try {
            MethodSignature signature = (MethodSignature) jp.getSignature();
            Method m = signature.getMethod();
            Recommit rr = m.getAnnotation(Recommit.class);
            String ps = rr.ps();
            Object[] args = jp.getArgs();
            StringBuilder sb = new StringBuilder();
            if (args == null || args.length == 0) {
                sb.append("NOARGS");
            } else if (StringUtils.isBlank(ps)) {
                Arrays.stream(args).forEach(a->sb.append(JSON.toJSONString(a)).append("-"));
            } else {
                String[] ns = ps.split(",");
                if (ns.length > args.length) {
                    throw new Exception("ps param count invalid!");
                }
                for (String p : ns){
                    if(!NumberUtils.isDigits(p) || Integer.parseInt(p)>args.length){
                        throw new Exception("ps param value invalid!");
                    }
                    int idx = Integer.parseInt(p);
                    sb.append(JSON.toJSONString(args[idx-1])).append("-");
                }
            }
            int ttl = rr.ttl();
            String key = sb.toString();
            String md5 = DigestUtils.md5Hex(key);
            String appName = SpringUtil.getProperty("spring.application.name");
            String cacheKey = "RR-" + appName + "-" + m.getDeclaringClass().getName() + "." + m.getName() + "-" + md5;
            //boolean exist = redisUtil.hasKey(cacheKey);
            recommited = !redisUtil.setIfAbsent(cacheKey, "", ttl);
        }catch (Exception e){
            log.error("RecommitAspect.doAround error:",e);
        }finally {
            if(!recommited) {
                result = jp.proceed();
            }else{
                result = Result.with(111, "重复提交");
            }
        }
        return result;
    }

}

其实我们使用下面一种方式也是可以的。
实例<二>
后台方法

    @Recommit(ttl=10) //此处这样写表示在10秒之内  如果有相同的参数orderId访问这个方法，那么就是重复提交的。
    public Result<Void> confirmNew(Long orderId) {
        String errMsg = null;
        Result<Void> result = Result.empty();
       //业务逻辑
       }

提交配置

package com.dorago.common.interceptor.recommit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

    /**
     * 参与重复提交计算的请求参数索引集合,逗号分隔
     * 例: 第1,2个参数则设置为"1,2",全部参数则用默认值即可
     * @return
     */
    String ps() default "";

    /**
     * 周期内参数相同的提交判定为重复提交
     * 单位: 秒
     * @return
     */
    int ttl() default 1;

}

请求拦截进行验证

import com.alibaba.fastjson.JSON;
import com.dorago.common.Result;
import com.dorago.common.SpringUtil;
import com.dorago.common.interceptor.log.MethodLogAspect;
import com.dorago.syj.biz.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.Arrays;

@Aspect
@Component
@Slf4j
@Order(1)
public class RecommitAspect {

    @Resource
    RedisUtil redisUtil;
    @Pointcut("@annotation(com.dorago.common.interceptor.recommit.Recommit)")
    public void recommitPointcut(){}

    @Around("recommitPointcut()")
    public Object doAround(ProceedingJoinPoint jp) throws Throwable {
        boolean recommited = false;
        Object result;
        try {
            MethodSignature signature = (MethodSignature) jp.getSignature();
            Method m = signature.getMethod();
            Recommit rr = m.getAnnotation(Recommit.class);
            String ps = rr.ps();
            Object[] args = jp.getArgs();
            StringBuilder sb = new StringBuilder();
            if (args == null || args.length == 0) {
                sb.append("NOARGS");
            } else if (StringUtils.isBlank(ps)) {
                Arrays.stream(args).forEach(a->sb.append(JSON.toJSONString(a)).append("-"));
            } else {
                String[] ns = ps.split(",");
                if (ns.length > args.length) {
                    throw new Exception("ps param count invalid!");
                }
                for (String p : ns){
                    if(!NumberUtils.isDigits(p) || Integer.parseInt(p)>args.length){
                        throw new Exception("ps param value invalid!");
                    }
                    int idx = Integer.parseInt(p);
                    sb.append(JSON.toJSONString(args[idx-1])).append("-");
                }
            }
            int ttl = rr.ttl();
            String key = sb.toString();
            String md5 = DigestUtils.md5Hex(key);
            //获取配置文件的值
            String appName = SpringUtil.getProperty("spring.application.name");
            String cacheKey = "RR-" + appName + "-" + m.getDeclaringClass().getName() + "." + m.getName() + "-" + md5;
            //boolean exist = redisUtil.hasKey(cacheKey);
            recommited = !redisUtil.setIfAbsent(cacheKey, "", ttl);
        }catch (Exception e){
            log.error("RecommitAspect.doAround error:",e);
        }finally {
            if(!recommited) {
                result = jp.proceed();
            }else{
                result = Result.with(111, "重复提交");
            }
        }
        return result;
    }

}

总结：不管是1还是2的实例，主要就是配置Recommit的地方。配置好了之后，就在对应的方法上加上这个注解既可。

问题描述

1.在我们项目开发过程中会出现用户保存操作时候快速点击两次会出现一条数据在数据库保存多条数据。

2.遇见上述问题我们首先跟前端开发沟通，在前端开发过程中可以将操作按钮在操作完后就行置灰操作，虽然这样做了，但是不能从根们解决问题（前端和后端都防止，这样就可以根本解决问题），然后需要后端进行提交接口进行重复提交处理。

解决思路

1.前端利用js操作或者vue操作进行按钮置灰，防止二次点击！
2.java后端利用redis进行防止重复操作！

每次请求提交保存数据需要提前请求接口获取token，然后在提交请求将获取token放入需要提交数据的接口头部，然后将保存操作接口放入注解@ExtApiIdempotent(ConstantUtils.EXTAPIHEAD)，后端会先进入aop中在头部找到token来判断redis是否存在当前redis，如果存在说明没有重复然后进行删除redis缓存数据，如果你连续点击第二次时候其实这个token已经被上一个请求给删除掉了，所以就是重复提交，不明白可以在下面评论，我都会回复

代码解释

1.在前端请求接口之前先请求获取一个token，我们java端将token生成完返给前端后，放入redis中，token作为key和token作为value 设置失效时间为200秒。

@RequestMapping("/redisToken")
public String getRedisToken() {
          return token.getToken();
  }

这是token工具类

package com.example.test.framework.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.UUID;

@Component
public class RedisToken {

    @Autowired
    private BaseRedisService baseRedisService;

    @Autowired
    private RedisUtil redisUtil;

    /** 缓存指定时间200秒 */
    private static final long TOKENTIMEOUT = 200;

    /**
     * 生成Token
     */
    public String getToken(){
        String token = UUID.randomUUID().toString();
        token=token.replaceAll("-", "");
        // 将token放到Redis中，用UUID保证唯一性
        baseRedisService.setString(token, token, TOKENTIMEOUT);
        return token;
    }

    public synchronized boolean findToken(String tokenKey) {
        String tokenValue = (String) redisUtil.get(tokenKey);
        // 如果能够获取该(从redis获取令牌)令牌(将当前令牌删除掉) 就直接执行该访问的业务逻辑
        if (StringUtils.isEmpty(tokenValue)) {
            return false;
        }
        // 保证每个接口对应的token 只能访问一次，保证接口幂等性问题，用完直接删掉
        redisUtil.delete(tokenValue);
        return true;
    }
}

2.前端获取到token后，然后每次操作接口时候需要将token放入每次请求head中，后端需要利用AOP面向切面对请求token进行校验

package com.example.test.framework.annotion;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 带参数的，一般在前后端分离时候使用，就可以将token放入请求头部，就可以直接在接口处设置ConstantUtils.EXTAPIHEAD类型就可以了
 */
 //RetentionPolicy.RUNTIME:注解保留在程序运行期间,此时可以通过反射获得定义在某个类上的所有注解.
 //ElementType.METHOD：说明该注解只能被声明在一个类的方法前。
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtApiIdempotent {
    //也就是接口中注解携带的参数，在我这里用的是请求方式类型 举例：@ExtApiIdempotent(ConstantUtils.EXTAPIHEAD)
    String value();
}

package com.example.test.framework.annotion;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 不带参数的一般在前后端没有分离，我们假如在controller跳转某个页面，然后在页面进行form表单提交，那就需要在跳转页面接口用@ExtApiToken这个注解，然后在页面用<input type="hidden" name="token" value="${token}">将token放入form标签内哦
 */
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtApiToken {


}

package com.example.test.framework.aop;

import com.example.test.framework.annotion.ExtApiIdempotent;
import com.example.test.framework.annotion.ExtApiToken;
import com.example.test.framework.redis.RedisToken;
import com.example.test.framework.redisservice.ConstantUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Aspect
@Component
public class ExtApiAopIdempotent {

    @Autowired
    private RedisToken redisToken;

    // 1.使用AOP环绕通知拦截所有test下面某某文件下controller的方法
    // 2.这里是你需要拦截的controller位置，设置一个我们上层公共位置可以了，
    @Pointcut("execution(* com.example.test.*.controller.*.*(..)))")
    public void rlAop() {

    }

    /**
     * 封装数据-在请求连接中获取需要的参数，例如：请求头中token
     */
    public HttpServletRequest getRequest() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        return request;
    }

    /**
     * 前置通知-不带参数的一般在前后端没有分离，我们假如在controller跳转某个页面，然后在页面进行form表单提交，那就需要在跳转页面接口用@ExtApiToken这个注解，然后在页面用<input type="hidden" name="token" value="${token}">将token放入form标签内哦
     */
    @Before("rlAop()")
    public void before(JoinPoint point) {
        // 获取被增强的方法相关信息 - 查看方法上是否有次注解

        MethodSignature signature = (MethodSignature) point.getSignature();
        ExtApiToken extApiToken = signature.getMethod().getDeclaredAnnotation(ExtApiToken.class);
        if (extApiToken != null) {
            // 可以放入到AOP代码 前置通知
            getRequest().setAttribute("token", redisToken.getToken());
        }
    }

    /**
     * 环绕通知
     */
    @Around("rlAop()")
    public Object doBefore(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        // 获取被增强的方法相关信息 - 查看方法上是否有次注解
        MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
        ExtApiIdempotent declaredAnnotation = methodSignature.getMethod().getDeclaredAnnotation(ExtApiIdempotent.class);
        if (declaredAnnotation != null) {
            String values = declaredAnnotation.value();
            String token = null;
            HttpServletRequest request = getRequest();
            if (values.equals(ConstantUtils.EXTAPIHEAD)) {
                token = request.getHeader("token");
            } else {
                token = request.getParameter("token");
            }

            // 获取不到token
            if (StringUtils.isEmpty(token)) {
                return "获取不到token";
            }

            // 接口获取对应的令牌,如果能够获取该(从redis获取令牌)令牌(将当前令牌删除掉) 就直接执行该访问的业务逻辑
            boolean isToken = redisToken.findToken(token);
            // 接口获取对应的令牌,如果获取不到该令牌 直接返回请勿重复提交
            if (!isToken) {
                return "请勿重复提交!";
            }
        }
        Object proceed = proceedingJoinPoint.proceed();
        return proceed;
    }
}

设置请求属于哪种类型可以是http-from两种请求

package com.example.test.framework.redisservice;

public interface ConstantUtils {

    /**
     * http 中携带的请求
     */
    static final String EXTAPIHEAD = "head";
    /**
     * from 中提交的请求
     */
    static final String EXTAPIFROM = "from";
}

controller层代码-如果你不是from表单提交就不要考虑ConstantUtils.EXTAPIFROM参数

package com.example.test.systemmo.controller;


import com.example.test.framework.annotion.ExtApiIdempotent;
import com.example.test.framework.annotion.ExtApiToken;
import com.example.test.framework.redis.RedisToken;
import com.example.test.framework.redisservice.ConstantUtils;
import com.example.test.systemmo.pojo.SysLcfLog;
import com.example.test.systemmo.service.imp.SysLcfLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Array;
import java.util.ArrayList;

/**
 * <p>
 * 操作日志 前端控制器
 * </p>
 *
 * @author lcf
 * @since 2020-04-24
 */
@RestController
@RequestMapping("/systemmo/sss")
public class SysLcfLogController {
        @Autowired
        private SysLcfLogService syslcflogservice;

        @Autowired
        private RedisToken token;

        @RequestMapping("/redisToken")
        public String getRedisToken() {
            return token.getToken();
        }

        /**
         * http请求增加日志
         * @param syslsflog
         * @return
         */
        @RequestMapping("/add")
        @ExtApiIdempotent(ConstantUtils.EXTAPIHEAD)
        public Object add(SysLcfLog syslsflog){
            //你的业务逻辑操作
         return "ok";
        }


        /**
         * 跳转页面，我们需要将token给你在跳转时候传送给你的页面，这样就可以在form表单提交时候直接传入给fromAdd接口
         * @param req
         * @return
         */
        @RequestMapping("/logPage")
        @ExtApiToken
        public String logPage(HttpServletRequest req) {
            return "logPage";
        }



    /**
     * form增加日志
     * @param syslsflog
     * @return
     */
    @RequestMapping("/fromAdd")
    @ExtApiIdempotent(ConstantUtils.EXTAPIFROM)
    public Object fromAdd(SysLcfLog syslsflog){
        //你的业务逻辑操作
        return "ok";
    }

        @RequestMapping("/select")
        public Object select(){
            ArrayList<SysLcfLog> log=new ArrayList<SysLcfLog>();
            log=syslcflogservice.select();
            return log;
        }
}

防止重复提交进行根据http请求和from表单提交进行总结分析，遇见问题时候也是在网上找资料，总结成自己的语言分享给大，大家哪里不懂，我会一一回复，后期会更新更多硬货，都是在实战项目中遇见的

核心逻辑阐述：
1.定义注解 NoRepeatSubmit，包含可重复提交时间间隔；使用时标记在controller需要防重复提交的类或者方法上；
2.定义AOP切面NoRepeatSubmitAspect切NoRepeatSubmit注解；
3.对请求方法query参数和body参数分别做MD5，作为redis中的key；
4.如果在redis中找到了就算重复，抛出异常；
5.如果未重复，放到redis中并设置下次可提交的时间；

注意：
为了防止并发出现问题，判断redis是否重复时需要加锁；
改进：
参加计算重复的参数可选；
将query和body做到一起；

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface NoRepeatSubmit {

    /**
     * 默认限制重复提交时间单位
     */
    TimeUnit lockTimeUnit() default TimeUnit.SECONDS;

    /**
     * 默认限制重复提交时间
     */
    long lockTime()  default 30;
}

@Aspect
@Component
@Order
public class NoRepeatSubmitAspect {

    @Resource
    private RedisComponent redisComponent;

    @Pointcut("@annotation(com.guazi.opl.dealer.tool.application.aop.NoRepeatSubmit)")
    public void noRepeatSubmit() {
    }

    @Around(value = "noRepeatSubmit()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) attributes;
        if (Objects.isNull(sra)) {
            return joinPoint.proceed();
        }
        NoRepeatSubmit noRepeatSubmit = this.getAnnotation(joinPoint);
        if (Objects.isNull(noRepeatSubmit)) {
            return joinPoint.proceed();
        }
        HttpServletRequest request = sra.getRequest();
        String queryString = request.getQueryString();
        //计算query参数的cache key
        String queryKey = this.calcQueryKey(queryString);
        String noRepeatQueryKey = this.getNoRepeatQueryKey(queryKey, request);
        //此args中不止含有body，如果还有requestParam、multipartfile指定的参数
        Object[] args = joinPoint.getArgs();
        String paramKey = this.calcParamKey(args);
        String noRepeatParamKey = this.getNoRepeatParamKey(paramKey, request);
        synchronized (this) {
            //判断queryKey是否在redis中存在，如果存在说明重复
            boolean queryRepeatFlag = this.judgeAndSetRepeat(noRepeatQueryKey, noRepeatSubmit);
            //先判断paramKey是否在redis中存在，如果存在说明已经重复
            boolean paramRepeatFlag = this.judgeAndSetRepeat(noRepeatParamKey, noRepeatSubmit);
            if (queryRepeatFlag && paramRepeatFlag) {
                throw new BusinessException(-1, "正在处理，请勿重复操作");
            }
        }
        return joinPoint.proceed();
    }

    /**
     * 获取防重复提交注解
     */
    private NoRepeatSubmit getAnnotation(ProceedingJoinPoint joinPoint) {
        //先从方法上获取
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        NoRepeatSubmit annotation = method.getAnnotation(NoRepeatSubmit.class);
        //获取不到再到类上找
        if (Objects.isNull(annotation)) {
            annotation = joinPoint.getTarget().getClass().getAnnotation(NoRepeatSubmit.class);
        }
        return annotation;
    }


    /**
     * 计算queryString对应的Md5值为value
     */
    private String calcQueryKey(String queryString) throws Exception {
        if (StringUtils.isBlank(queryString)) {
            return StringUtils.EMPTY;
        }
        return SignatureUtils.md5(queryString).substring(5, 15);
    }


    /**
     * 计算queryString对应的Md5最为value
     */
    private String calcParamKey(Object[] args) throws Exception {
        TreeSet<String> paramTree = new TreeSet<>();
        for (Object arg : args) {
            if (arg instanceof BindingResult || arg instanceof HttpServletResponse || arg instanceof HttpServletRequest) {
                //requestURL参数，这直接返回
                continue;
            }
            //转成json字符串
            String jsonArg = JsonUtils.toJsonString(arg);
            paramTree.add(jsonArg);
        }

        if (paramTree.isEmpty()) {
            return StringUtils.EMPTY;
        }
        //获取有序body json后的参数
        List<String> paramList = new ArrayList<>(paramTree);
        //连在一起
        String bodyJson = String.join("", paramList);
        return SignatureUtils.md5(bodyJson).substring(5, 15);
    }


    /**
     * 获取防重复提交query的key
     */
    private String getNoRepeatQueryKey(String queryKey, HttpServletRequest request) {
        if (StringUtils.isBlank(queryKey)) {
            return StringUtils.EMPTY;
        }
        String noRepeatSubmitPrefix = RedisKeyConstant.NO_REPEAT_QUERY_SUBMIT_PREFIX + request.getRequestURL();
        return noRepeatSubmitPrefix + queryKey;
    }

    /**
     * 获取防重复提交body的key
     */
    private String getNoRepeatParamKey(String paramKey, HttpServletRequest request) {
        if (StringUtils.isBlank(paramKey)) {
            return StringUtils.EMPTY;
        }
        String noRepeatSubmitPrefix = RedisKeyConstant.NO_REPEAT_QUERY_SUBMIT_PREFIX + request.getRequestURL();
        return noRepeatSubmitPrefix + paramKey;
    }

    /**
     * 如果不重复 则设置下次可提交时间 返回false
     * 否则返回true
     */
    private boolean judgeAndSetRepeat(String cacheKey, NoRepeatSubmit noRepeatSubmit) {
        if (StringUtils.isBlank(cacheKey)) {
            return true;
        }
        String value = redisComponent.getString(cacheKey);
        if (Objects.isNull(value)) {
            redisComponent.setString(cacheKey, cacheKey, noRepeatSubmit.lockTime(), noRepeatSubmit.lockTimeUnit());
            return false;
        }
        return true;
    }
}