8种解决重复提交的⽅案，你知道哪⼏种？
1、什么是幂等
在我们编程中常见幂等
select查询天然幂等
delete删除也是幂等，删除同⼀个多次效果⼀样
update直接更新某个值的，幂等
update更新累加操作的,⾮幂等
insert⾮幂等操作，每次新增⼀条
2、产⽣原因
由于重复点击或者⽹络重发:
点击提交按钮两次;
点击刷新按钮;
使⽤浏览器后退按钮重复之前的操作，导致重复提交表单;
使⽤浏览器历史记录重复提交表单;
浏览器重复的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.*;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Resubmit {
/**
* 延时时间在延时多久后可以再次提交
*
* @return Time unit is one second
*/
int delaySeconds() default 20;
}
2. 实例化锁
lemon.cache.Cache;
lemon.cache.CacheBuilder;
slf4j.Slf4j;
import dec.digest.DigestUtils;
import java.util.Objects;
import urrent.ConcurrentHashMap;
import urrent.ScheduledThreadPoolExecutor;
import urrent.ThreadPoolExecutor;
import urrent.TimeUnit;
/
**
* @author lijing
* 重复提交锁
*/
@Slf4j
public final class ResubmitLock {
private static final ConcurrentHashMap<String, Object> LOCK_CACHE = new ConcurrentHashMap<>(200);
private static final ScheduledThreadPoolExecutor EXECUTOR = new ScheduledThreadPoolExecutor(5, new ThreadPoolExecutor.DiscardPolicy()); // private static final Cache<String, Object> CACHES = wBuilder()
// 最⼤缓存 100 个
/
/ .maximumSize(1000)
// 设置写缓存后 5 秒钟过期
// .expireAfterWrite(5, TimeUnit.SECONDS)
// .build();
private ResubmitLock() {
}
/**
* 静态内部类单例模式
*
* @return
*/
private static class SingletonInstance {
private static final ResubmitLock INSTANCE = new ResubmitLock();
}
public static ResubmitLock getInstance() {
return SingletonInstance.INSTANCE;
}
public static String handleKey(String param) {
return DigestUtils.md5Hex(param == null ? "" : param);
}
/**
* 加锁 putIfAbsent 是原⼦操作保证线程安全
*
* @param key 对应的key
* @param value
* @return
*/
public boolean lock(final String key, Object value) {
return Objects.isNull(LOCK_CACHE.putIfAbsent(key, value));
}
/**
* 延时释放锁⽤以控制短时间内的重复提交
*
* @param lock 是否需要解锁
* @param key 对应的key
* @param delaySeconds 延时时间
*/
public void unLock(final boolean lock, final String key, final int delaySeconds) {
if (lock) {
EXECUTOR.schedule(() -> {
ve(key);
}, delaySeconds, TimeUnit.SECONDS);
}
}
}
3. AOP 切⾯
import com.alibaba.fastjson.JSONObject;
annotation.Resubmit;
annotation.impl.ResubmitLock;
dto.RequestDTO;
dto.ResponseDTO;
ums.ResponseCode;
log4j.Log4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.flect.MethodSignature;
import org.springframework.stereotype.Component;
import flect.Method;
/**
* @ClassName RequestDataAspect
* @Description 数据重复提交校验
* @Author lijing
* @Date 2019/05/16 17:05
**/
@Log4j
@Aspect
@Component
public class ResubmitDataAspect {
private final static String DATA = "data";
private final static Object PRESENT = new Object();
@Around("@annotation.Resubmit)")
public Object handleResubmit(ProceedingJoinPoint joinPoint) throws Throwable {
Method method = ((MethodSignature) Signature()).getMethod();
//获取注解信息
Resubmit annotation = Annotation(Resubmit.class);
int delaySeconds = annotation.delaySeconds();
Object[] pointArgs = Args();
String key = "";
//获取第⼀个参数
Object firstParam = pointArgs[0];
if (firstParam instanceof RequestDTO) {
//解析参数
JSONObject requestDTO = JSONObject.String());
JSONObject data = JSONObject.String(DATA));
if (data != null) {
StringBuffer sb = new StringBuffer();
data.forEach((k, v) -> {
单例模式的几种实现方式sb.append(v);
});
//⽣成加密参数使⽤了content_MD5的加密⽅式
key = ResubmitLock.String());
}
}
//执⾏锁
boolean lock = false;
try {
//设置解锁key
lock = Instance().lock(key, PRESENT);
if (lock) {
//放⾏
return joinPoint.proceed();
} else {
//响应重复提交异常
return new ResponseDTO<>(ResponseCode.REPEAT_SUBMIT_OPERATION_EXCEPTION);
}
} finally {
//设置解锁key和解锁时间
}
}
}
4. 注解使⽤案例
@ApiOperation(value = "保存我的帖⼦接⼝", notes = "保存我的帖⼦接⼝")
@PostMapping("/posts/save")
@Resubmit(delaySeconds = 10)
public ResponseDTO<BaseResponseDataDTO> saveBbsPosts(@RequestBody @Validated RequestDTO<BbsPostsRequestDTO> requestDto) {
return bbsPostsBizService.saveBbsPosts(requestDto);
}
以上就是本地锁的⽅式进⾏的幂等提交使⽤了Content-MD5 进⾏加密只要参数不变，参数加密密值不变,key存在就阻⽌提交
当然也可以使⽤⼀些其他签名校验在某⼀次提交时先⽣成固定签名提交到后端根据后端解析统⼀的签名作为每次提交的验证token 去缓存中处理即可.
8. 借助分布式redis锁（参考其他）
在 l 中添加上 starter-web、starter-aop、starter-data-redis 的依赖即可
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>
属性配置在 application.properites 资源⽂件中添加 redis 相关的配置项
主要实现⽅式:
熟悉 Redis 的朋友都知道它是线程安全的，我们利⽤它的特性可以很轻松的实现⼀个分布式锁，如 opsForValue().setIfAbsent(key,value)它的作⽤就是如果缓存中没有当前 Key 则进⾏缓存同时返回 true 反之亦然；
当缓存后给 key 在设置个过期时间，防⽌因为系统崩溃⽽导致锁迟迟不释放形成死锁；那么我们是不是可以这样认为当返回 true 我们认为它获取到锁了，在锁未释放的时候我们进⾏异常的抛出…
package com.battcn.interceptor;
import com.battcn.annotation.CacheLock;
import com.battcn.utils.RedisLockHelper;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.flect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import t.annotation.Configuration;
import org.springframework.util.StringUtils;
import flect.Method;
import java.util.UUID;
/**
* redis ⽅案
*
* @author Levin
* @since 2018/6/12 0012
*/
@Aspect
@Configuration
public class LockMethodInterceptor {
@Autowired
public LockMethodInterceptor(RedisLockHelper redisLockHelper, CacheKeyGenerator cacheKeyGenerator) {
this.cacheKeyGenerator = cacheKeyGenerator;
}
private final RedisLockHelper redisLockHelper;
private final CacheKeyGenerator cacheKeyGenerator;
@Around("execution(public * *(..)) && @annotation(com.battcn.annotation.CacheLock)")
public Object interceptor(ProceedingJoinPoint pjp) {
MethodSignature signature = (MethodSignature) Signature();
Method method = Method();
CacheLock lock = Annotation(CacheLock.class);
if (StringUtils.isEmpty(lock.prefix())) {
throw new RuntimeException("lock key don'");
}
final String lockKey = LockKey(pjp);
String value = UUID.randomUUID().toString();
try {
// 假设上锁成功，但是设置过期时间失效，以后拿到的都是 false
final boolean success = redisLockHelper.lock(lockKey, value, pire(), lock.timeUnit());
if (!success) {
throw new RuntimeException("重复提交");
}
try {
return pjp.proceed();
} catch (Throwable throwable) {
throw new RuntimeException("系统异常");
}
} finally {
// TODO 如果演⽰的话需要注释该代码；实际应该放开
redisLockHelper.unlock(lockKey, value);
}
}
}
RedisLockHelper 通过封装成 API ⽅式调⽤，灵活度更加⾼
package com.battcn.utils;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.dis.RedisAutoConfiguration;
import t.annotation.Configuration;
import org.tion.RedisStringCommands;
import org.RedisCallback;
import org.StringRedisTemplate;
import org.pes.Expiration;
import org.springframework.util.StringUtils;
import urrent.Executors;
import urrent.ScheduledExecutorService;
import urrent.TimeUnit;
import Pattern;
/**
* 需要定义成 Bean
*
* @author Levin
* @since 2018/6/15 0015
*/
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisLockHelper {
private static final String DELIMITER = "|";
/**
* 如果要求⽐较⾼可以通过注⼊的⽅式分配
*/
private static final ScheduledExecutorService EXECUTOR_SERVICE = wScheduledThreadPool(10);
private final StringRedisTemplate stringRedisTemplate;
public RedisLockHelper(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
/**
* 获取锁（存在死锁风险）
*
* @param lockKey lockKey
* @param value value
* @param time 超时时间
* @param unit 过期单位
* @return true or false
*/
public boolean tryLock(final String lockKey, final String value, final long time, final TimeUnit unit) {
ute((RedisCallback<Boolean>) connection -> connection.Bytes(), Bytes(), Expiration.from(time, unit), RedisStringCommands.SetOption.SET_IF_ABSENT)); }
/**
* 获取锁
*
* @param lockKey lockKey
* @param uuid UUID
* @param timeout 超时时间
* @param unit 过期单位
* @return true or false
*/
public boolean lock(String lockKey, final String uuid, long timeout, final TimeUnit unit) {
final long milliseconds = Expiration.from(timeout, unit).getExpirationTimeInMilliseconds();
boolean success = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, (System.currentTimeMillis() + milliseconds) + DELIMITER + uuid); if (success) {
} else {
String oldVal = stringRedisTemplate.opsForValue().getAndSet(lockKey, (System.currentTimeMillis() + milliseconds) + DELIMITER + uuid); final String[] oldValues = oldVal.split(Pattern.quote(DELIMITER));
if (Long.parseLong(oldValues[0]) + 1 <= System.currentTimeMillis()) {
return true;
}
}
return success;
}
/**
* @see <a href="redis.io/commands/set">Redis Documentation: SET</a>
*/
public void unlock(String lockKey, String value) {
unlock(lockKey, value, 0, TimeUnit.MILLISECONDS);
}
/
**
* 延迟unlock
*
* @param lockKey key
* @param uuid client(最好是唯⼀键的)
* @param delayTime 延迟时间
* @param unit 时间单位
*/
public void unlock(final String lockKey, final String uuid, long delayTime, TimeUnit unit) {
if (StringUtils.isEmpty(lockKey)) {
return;
}
if (delayTime <= 0) {
doUnlock(lockKey, uuid);
} else {
EXECUTOR_SERVICE.schedule(() -> doUnlock(lockKey, uuid), delayTime, unit);
}
}
/**
* @param lockKey key
* @param uuid client(最好是唯⼀键的)
*/
private void doUnlock(final String lockKey, final String uuid) {
String val = stringRedisTemplate.opsForValue().get(lockKey);
final String[] values = val.split(Pattern.quote(DELIMITER));
if (values.length <= 0) {
return;
}
if (uuid.equals(values[1])) {
stringRedisTemplate.delete(lockKey);
}
}
}
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论