devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

8种方案解决重复提交问题_前端重复提交

作者：小蓝xlanll | 2024-03-14 12:37:41

赞

踩

前端重复提交

1.什么是幂等

在我们编程中常见幂等

  • select查询天然幂等

  • delete删除也是幂等,删除同一个多次效果一样

  • update直接更新某个值的,幂等

  • update更新累加操作的,非幂等

  • insert非幂等操作,每次新增一条

2.产生原因

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

  • 点击提交按钮两次;

  • 点击刷新按钮;

  • 使用浏览器后退按钮重复之前的操作，导致重复提交表单;

  • 使用浏览器历史记录重复提交表单;

  • 浏览器重复的HTTP请;

  • nginx重发等情况;

  • 分布式RPC的try重发等;

3.解决方案

1)前端js提交禁止按钮可以用一些js组件

2)使用Post/Redirect/Get模式

在提交后执行页面重定向，这就是所谓的Post-Redirect-Get (PRG)模式。简言之，当用户提交了表单后，你去执行一个客户端的重定向，转到提交成功信息页面。这能避免用户按F5导致的重复提交，而其也不会出现浏览器表单重复提交的警告，也能消除按浏览器前进和后退按导致的同样问题。

3)在session中存放一个特殊标志

在服务器端，生成一个唯一的标识符，将它存入session，同时将它写入表单的隐藏字段中，然后将表单页面发给浏览器，用户录入信息后点击提交，在服务器端，获取表单中隐藏字段的值，与session中的唯一标识符比较，相等说明是首次提交，就处理本次请求，然后将session中的唯一标识符移除；不相等说明是重复提交，就不再处理。

4)其他借助使用header头设置缓存控制头Cache-control等方式

比较复杂 不适合移动端APP的应用 这里不详解

5)借助数据库

insert使用唯一索引 update使用 乐观锁 version版本法

这种在大数据量和高并发下效率依赖数据库硬件能力,可针对非核心业务

6)借助悲观锁

使用select … for update ,这种和 synchronized 锁住先查再insert or update一样,但要避免死锁,效率也较差

针对单体 请求并发不大 可以推荐使用

7)借助本地锁(本文重点)

原理:

使用了 ConcurrentHashMap 并发容器 putIfAbsent 方法,和 ScheduledThreadPoolExecutor 定时任务,也可以使用guava cache的机制, gauva中有配有缓存的有效时间也是可以的key的生成 

Content-MD5 

Content-MD5 是指 Body 的 MD5 值，只有当 Body 非Form表单时才计算MD5，计算方式直接将参数和参数名称统一加密MD5

MD5在一定范围类认为是唯一的 近似唯一 当然在低并发的情况下足够了

本地锁只适用于单机部署的应用.

①配置注解

  1. import java.lang.annotation.*;
  2.  
  3. @Target(ElementType.METHOD)
  4. @Retention(RetentionPolicy.RUNTIME)
  5. @Documented
  6. public @interface Resubmit {
  7.  
  8.     /**
  9.      * 延时时间 在延时多久后可以再次提交
  10.      *
  11.      * @return Time unit is one second
  12.      */
  13.     int delaySeconds() default 20;
  14. }

②实例化锁

  1. import com.google.common.cache.Cache;
  2. import com.google.common.cache.CacheBuilder;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.apache.commons.codec.digest.DigestUtils;
  5.  
  6. import java.util.Objects;
  7. import java.util.concurrent.ConcurrentHashMap;
  8. import java.util.concurrent.ScheduledThreadPoolExecutor;
  9. import java.util.concurrent.ThreadPoolExecutor;
  10. import java.util.concurrent.TimeUnit;
  11.  
  12. /**
  13.  * @author lijing
  14.  * 重复提交锁
  15.  */
  16. @Slf4j
  17. public final class ResubmitLock {
  18.  
  19.  
  20.     private static final ConcurrentHashMap<String, Object> LOCK_CACHE = new ConcurrentHashMap<>(200);
  21.     private static final ScheduledThreadPoolExecutor EXECUTOR = new ScheduledThreadPoolExecutor(5, new ThreadPoolExecutor.DiscardPolicy());
  22.  
  23.  
  24.    // private static final Cache<String, Object> CACHES = CacheBuilder.newBuilder()
  25.             // 最大缓存 100 个
  26.    //          .maximumSize(1000)
  27.             // 设置写缓存后 5 秒钟过期
  28.    //         .expireAfterWrite(5, TimeUnit.SECONDS)
  29.    //         .build();
  30.  
  31.  
  32.     private ResubmitLock() {
  33.     }
  34.  
  35.     /**
  36.      * 静态内部类 单例模式
  37.      *
  38.      * @return
  39.      */
  40.     private static class SingletonInstance {
  41.         private static final ResubmitLock INSTANCE = new ResubmitLock();
  42.     }
  43.  
  44.     public static ResubmitLock getInstance() {
  45.         return SingletonInstance.INSTANCE;
  46.     }
  47.  
  48.  
  49.     public static String handleKey(String param) {
  50.         return DigestUtils.md5Hex(param == null ? "" : param);
  51.     }
  52.  
  53.     /**
  54.      * 加锁 putIfAbsent 是原子操作保证线程安全
  55.      *
  56.      * @param key   对应的key
  57.      * @param value
  58.      * @return
  59.      */
  60.     public boolean lock(final String key, Object value) {
  61.         return Objects.isNull(LOCK_CACHE.putIfAbsent(key, value));
  62.     }
  63.  
  64.     /**
  65.      * 延时释放锁 用以控制短时间内的重复提交
  66.      *
  67.      * @param lock         是否需要解锁
  68.      * @param key          对应的key
  69.      * @param delaySeconds 延时时间
  70.      */
  71.     public void unLock(final boolean lock, final String key, final int delaySeconds) {
  72.         if (lock) {
  73.             EXECUTOR.schedule(() -> {
  74.                 LOCK_CACHE.remove(key);
  75.             }, delaySeconds, TimeUnit.SECONDS);
  76.         }
  77.     }
  78. }

③AOP 切面

  1. import com.alibaba.fastjson.JSONObject;
  2. import com.cn.xxx.common.annotation.Resubmit;
  3. import com.cn.xxx.common.annotation.impl.ResubmitLock;
  4. import com.cn.xxx.common.dto.RequestDTO;
  5. import com.cn.xxx.common.dto.ResponseDTO;
  6. import com.cn.xxx.common.enums.ResponseCode;
  7. import lombok.extern.log4j.Log4j;
  8. import org.aspectj.lang.ProceedingJoinPoint;
  9. import org.aspectj.lang.annotation.Around;
  10. import org.aspectj.lang.annotation.Aspect;
  11. import org.aspectj.lang.reflect.MethodSignature;
  12. import org.springframework.stereotype.Component;
  13.  
  14. import java.lang.reflect.Method;
  15.  
  16. /**
  17.  * @ClassName RequestDataAspect
  18.  * @Description 数据重复提交校验
  19.  * @Author lijing
  20.  * @Date 2019/05/16 17:05
  21.  **/
  22. @Log4j
  23. @Aspect
  24. @Component
  25. public class ResubmitDataAspect {
  26.  
  27.     private final static String DATA = "data";
  28.     private final static Object PRESENT = new Object();
  29.  
  30.     @Around("@annotation(com.cn.xxx.common.annotation.Resubmit)")
  31.     public Object handleResubmit(ProceedingJoinPoint joinPoint) throws Throwable {
  32.         Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
  33.         //获取注解信息
  34.         Resubmit annotation = method.getAnnotation(Resubmit.class);
  35.         int delaySeconds = annotation.delaySeconds();
  36.         Object[] pointArgs = joinPoint.getArgs();
  37.         String key = "";
  38.         //获取第一个参数
  39.         Object firstParam = pointArgs[0];
  40.         if (firstParam instanceof RequestDTO) {
  41.             //解析参数
  42.             JSONObject requestDTO = JSONObject.parseObject(firstParam.toString());
  43.             JSONObject data = JSONObject.parseObject(requestDTO.getString(DATA));
  44.             if (data != null) {
  45.                 StringBuffer sb = new StringBuffer();
  46.                 data.forEach((k, v) -> {
  47.                     sb.append(v);
  48.                 });
  49.                 //生成加密参数 使用了content_MD5的加密方式
  50.                 key = ResubmitLock.handleKey(sb.toString());
  51.             }
  52.         }
  53.         //执行锁
  54.         boolean lock = false;
  55.         try {
  56.             //设置解锁key
  57.             lock = ResubmitLock.getInstance().lock(key, PRESENT);
  58.             if (lock) {
  59.                 //放行
  60.                 return joinPoint.proceed();
  61.             } else {
  62.                 //响应重复提交异常
  63.                 return new ResponseDTO<>(ResponseCode.REPEAT_SUBMIT_OPERATION_EXCEPTION);
  64.             }
  65.         } finally {
  66.             //设置解锁key和解锁时间
  67.             ResubmitLock.getInstance().unLock(lock, key, delaySeconds);
  68.         }
  69.     }
  70. }

④注解使用案例

  1. @ApiOperation(value = "保存我的帖子接口", notes = "保存我的帖子接口")
  2.     @PostMapping("/posts/save")
  3.     @Resubmit(delaySeconds = 10)
  4.     public ResponseDTO<BaseResponseDataDTO> saveBbsPosts(@RequestBody @Validated RequestDTO<BbsPostsRequestDTO> requestDto) {
  5.         return bbsPostsBizService.saveBbsPosts(requestDto);
  6.     }

以上就是本地锁的方式进行的幂等提交 使用了Content-MD5 进行加密 只要参数不变,参数加密 密值不变,key存在就阻止提交

当然也可以使用 一些其他签名校验 在某一次提交时先 生成固定签名 提交到后端 根据后端解析统一的签名作为 每次提交的验证token 去缓存中处理即可.

8)借助分布式redis锁 （参考其他）

也可以参考这篇：基于redis的分布式锁的分析与实践

在 pom.xml 中添加上 starter-web、starter-aop、starter-data-redis 的依赖即可

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-web</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-aop</artifactId>
  9.     </dependency>
  10.     <dependency>
  11.         <groupId>org.springframework.boot</groupId>
  12.         <artifactId>spring-boot-starter-data-redis</artifactId>
  13.     </dependency>
  14. </dependencies>

属性配置 在 application.properites 资源文件中添加 redis 相关的配置项

  1. spring.redis.host=localhost
  2. spring.redis.port=6379
  3. spring.redis.password=123456

主要实现方式:

熟悉 Redis 的朋友都知道它是线程安全的，我们利用它的特性可以很轻松的实现一个分布式锁，如 opsForValue().setIfAbsent(key,value)它的作用就是如果缓存中没有当前 Key 则进行缓存同时返回 true 反之亦然；

当缓存后给 key 在设置个过期时间，防止因为系统崩溃而导致锁迟迟不释放形成死锁；那么我们是不是可以这样认为当返回 true 我们认为它获取到锁了，在锁未释放的时候我们进行异常的抛出…

  1. package com.battcn.interceptor;
  2.  
  3. import com.battcn.annotation.CacheLock;
  4. import com.battcn.utils.RedisLockHelper;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.reflect.MethodSignature;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.util.StringUtils;
  12.  
  13. import java.lang.reflect.Method;
  14. import java.util.UUID;
  15.  
  16. /**
  17.  * redis 方案
  18.  *
  19.  * @author Levin
  20.  * @since 2018/6/12 0012
  21.  */
  22. @Aspect
  23. @Configuration
  24. public class LockMethodInterceptor {
  25.  
  26.     @Autowired
  27.     public LockMethodInterceptor(RedisLockHelper redisLockHelper, CacheKeyGenerator cacheKeyGenerator) {
  28.         this.redisLockHelper = redisLockHelper;
  29.         this.cacheKeyGenerator = cacheKeyGenerator;
  30.     }
  31.  
  32.     private final RedisLockHelper redisLockHelper;
  33.     private final CacheKeyGenerator cacheKeyGenerator;
  34.  
  35.  
  36.     @Around("execution(public * *(..)) && @annotation(com.battcn.annotation.CacheLock)")
  37.     public Object interceptor(ProceedingJoinPoint pjp) {
  38.         MethodSignature signature = (MethodSignature) pjp.getSignature();
  39.         Method method = signature.getMethod();
  40.         CacheLock lock = method.getAnnotation(CacheLock.class);
  41.         if (StringUtils.isEmpty(lock.prefix())) {
  42.             throw new RuntimeException("lock key don't null...");
  43.         }
  44.         final String lockKey = cacheKeyGenerator.getLockKey(pjp);
  45.         String value = UUID.randomUUID().toString();
  46.         try {
  47.             // 假设上锁成功，但是设置过期时间失效，以后拿到的都是 false
  48.             final boolean success = redisLockHelper.lock(lockKey, value, lock.expire(), lock.timeUnit());
  49.             if (!success) {
  50.                 throw new RuntimeException("重复提交");
  51.             }
  52.             try {
  53.                 return pjp.proceed();
  54.             } catch (Throwable throwable) {
  55.                 throw new RuntimeException("系统异常");
  56.             }
  57.         } finally {
  58.             // TODO 如果演示的话需要注释该代码;实际应该放开
  59.             redisLockHelper.unlock(lockKey, value);
  60.         }
  61.     }
  62. }

RedisLockHelper 通过封装成 API 方式调用，灵活度更加高

  1. package com.battcn.utils;
  2.  
  3. import org.springframework.boot.autoconfigure.AutoConfigureAfter;
  4. import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.connection.RedisStringCommands;
  7. import org.springframework.data.redis.core.RedisCallback;
  8. import org.springframework.data.redis.core.StringRedisTemplate;
  9. import org.springframework.data.redis.core.types.Expiration;
  10. import org.springframework.util.StringUtils;
  11.  
  12. import java.util.concurrent.Executors;
  13. import java.util.concurrent.ScheduledExecutorService;
  14. import java.util.concurrent.TimeUnit;
  15. import java.util.regex.Pattern;
  16.  
  17. /**
  18.  * 需要定义成 Bean
  19.  *
  20.  * @author Levin
  21.  * @since 2018/6/15 0015
  22.  */
  23. @Configuration
  24. @AutoConfigureAfter(RedisAutoConfiguration.class)
  25. public class RedisLockHelper {
  26.  
  27.  
  28.     private static final String DELIMITER = "|";
  29.  
  30.     /**
  31.      * 如果要求比较高可以通过注入的方式分配
  32.      */
  33.     private static final ScheduledExecutorService EXECUTOR_SERVICE = Executors.newScheduledThreadPool(10);
  34.  
  35.     private final StringRedisTemplate stringRedisTemplate;
  36.  
  37.     public RedisLockHelper(StringRedisTemplate stringRedisTemplate) {
  38.         this.stringRedisTemplate = stringRedisTemplate;
  39.     }
  40.  
  41.     /**
  42.      * 获取锁（存在死锁风险）
  43.      *
  44.      * @param lockKey lockKey
  45.      * @param value   value
  46.      * @param time    超时时间
  47.      * @param unit    过期单位
  48.      * @return true or false
  49.      */
  50.     public boolean tryLock(final String lockKey, final String value, final long time, final TimeUnit unit) {
  51.         return stringRedisTemplate.execute((RedisCallback<Boolean>) connection -> connection.set(lockKey.getBytes(), value.getBytes(), Expiration.from(time, unit), RedisStringCommands.SetOption.SET_IF_ABSENT));
  52.     }
  53.  
  54.     /**
  55.      * 获取锁
  56.      *
  57.      * @param lockKey lockKey
  58.      * @param uuid    UUID
  59.      * @param timeout 超时时间
  60.      * @param unit    过期单位
  61.      * @return true or false
  62.      */
  63.     public boolean lock(String lockKey, final String uuid, long timeout, final TimeUnit unit) {
  64.         final long milliseconds = Expiration.from(timeout, unit).getExpirationTimeInMilliseconds();
  65.         boolean success = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, (System.currentTimeMillis() + milliseconds) + DELIMITER + uuid);
  66.         if (success) {
  67.             stringRedisTemplate.expire(lockKey, timeout, TimeUnit.SECONDS);
  68.         } else {
  69.             String oldVal = stringRedisTemplate.opsForValue().getAndSet(lockKey, (System.currentTimeMillis() + milliseconds) + DELIMITER + uuid);
  70.             final String[] oldValues = oldVal.split(Pattern.quote(DELIMITER));
  71.             if (Long.parseLong(oldValues[0]) + 1 <= System.currentTimeMillis()) {
  72.                 return true;
  73.             }
  74.         }
  75.         return success;
  76.     }
  77.  
  78.  
  79.     /**
  80.      * @see <a href="http://redis.io/commands/set">Redis Documentation: SET</a>
  81.      */
  82.     public void unlock(String lockKey, String value) {
  83.         unlock(lockKey, value, 0, TimeUnit.MILLISECONDS);
  84.     }
  85.  
  86.     /**
  87.      * 延迟unlock
  88.      *
  89.      * @param lockKey   key
  90.      * @param uuid      client(最好是唯一键的)
  91.      * @param delayTime 延迟时间
  92.      * @param unit      时间单位
  93.      */
  94.     public void unlock(final String lockKey, final String uuid, long delayTime, TimeUnit unit) {
  95.         if (StringUtils.isEmpty(lockKey)) {
  96.             return;
  97.         }
  98.         if (delayTime <= 0) {
  99.             doUnlock(lockKey, uuid);
  100.         } else {
  101.             EXECUTOR_SERVICE.schedule(() -> doUnlock(lockKey, uuid), delayTime, unit);
  102.         }
  103.     }
  104.  
  105.     /**
  106.      * @param lockKey key
  107.      * @param uuid    client(最好是唯一键的)
  108.      */
  109.     private void doUnlock(final String lockKey, final String uuid) {
  110.         String val = stringRedisTemplate.opsForValue().get(lockKey);
  111.         final String[] values = val.split(Pattern.quote(DELIMITER));
  112.         if (values.length <= 0) {
  113.             return;
  114.         }
  115.         if (uuid.equals(values[1])) {
  116.             stringRedisTemplate.delete(lockKey);
  117.         }
  118.     }
  119.  
  120. }

redis的提交参照

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/234479?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号