目录一、摘要二、方案实践2.1、引入redis组件2.2、添加redis环境配置2.3、编写获取请求唯一ID的接口，同时将唯一ID存入redis2.4、编写服务验证逻辑，通过aop代理方式...
目录
一、摘要二、方案实践
2.1、引入 Redis 组件
2.2、添加 redis 环境配置
2.3、编写获取请求唯一ID的接口，同时将唯一ID存入redis
2.4、编写服务验证逻辑，通过 aop 代理方式实现
2.5、在相关的业务接口上，增加SubmitToken注解即可
三、小结
一、摘要
在上一篇文章中，我们详细的介绍了对于下单流量不算高的系统，可以通过请求唯一ID+数据表增加唯一索引约束这种方案来实现防止接口重复提交！
随着业务的快速增长，每一秒的下单请求次数，可能从几十上升到几百甚至几千。
面对这种下单流量越来越高的场景，此时数据库的访问压力会急剧上升，上面这套方案全靠数据库来解决，会特别吃力！
对于这样的场景，我们可以选择引入缓存中间件来解决，可选的组件有 redis、memcache 等。
下面，我们以引入redis缓存数据库服务器，向大家介绍具体的解决方案！
二、方案实践
我们先来看一张图，这张图就是本次方案的核心流程图。
实现的逻辑，流程如下：
1.当用户进入订单提交界面的时候，调用后端获取请求唯一 ID，同时后端将请求唯一ID存储到redis中再返回给前端，前端将唯一 ID 值埋点在页面里面
2.当用户点击提交按钮时，后端检查这个请求唯一 ID 是否存在，如果不存在，提示错误信息；如果存在，继续后续检查流程
3.使用
redis的分布式锁服务，对请求 ID 在限定的时间内进行加锁，如果加锁成功，继续后续流程；如果加锁失败，说明服务正在处理，请勿重复提交4.最后一步，如果加锁成功后，需要将锁手动释放掉，以免再次请求时，提示同样的信息；同时如果任务执行成功，需要将
redis中的请求唯一 ID 清理掉5.至于数据库是否需要增加字段唯一索引，理论上可以不用加，如果加了更保险
引入缓存服务，防止重复提交的大体思路如上，实践代码如下！
2.1、引入 redis 组件
小编的项目是基于SpringBoot版本进行构建，添加相关的redis依赖环境如下：
<!--引入springboot--> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.0.RELEASE</version> </parent> ...... <!--Redis相关依赖包，采用jedis作为客户端--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <exclusions> <exclusion> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </exclusion> <exclusion> <artifactId>lettuce-core</artifactId> <groupId>io.lettuce</groupId> </exclusion> </exclusions> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency>
特别注意：由于每个项目环境不一样，具体的依赖包需要和工程版本号匹配！
2.2、添加 redis 环境配置
在全局配置application.properties文件中，添加redis相关服务配置如下
#Redis数据库索引（默认为0） spring.redis.database=1 #Redis服务器地址 spring.redis.host=127.0.0.1 #Redis服务器连接端口 spring.redis.port=6379 #Redis服务器连接密码（默认为空） spring.redis.password= #Redis服务器连接超时配置 spring.redis.timeout=1000 #js连接池配置 spring.redis.jedis.pool.max-active=8 spring.redis.jedis.pool.max-wait=1000 spring.redis.jedis.pool.max-idle=8 spring.redis.jedis.pool.min-idle=0 spring.redis.jedis.pool.time-between-eviction-runs=100
在使用redis之前，请确保redis服务器是启动状态，并且能正常访问！
2.3、编写获取请求唯一ID的接口，同时将唯一ID存入redis
@RestController
@RequestMapping("api")
publicclassSubmitTokenController{
/**
*SubmitToken过期时间
*/
privatestaticfinalIntegerEXPIRE_TIME=60;
@Autowired
privateStringRedisTemplatestringRedisTemplate;
/**
*获取getSubmitToken
*@return
*/
@RequestMapping("getSubmitToken")
publicResResultgetSubmitToken(){
Stringuuid=UUID.randomUUID().toString();
//存入redis
stringRedisTemplate.opsForValue().set(uuid,uuid,EXPIRE_TIME,TimeUnit.SECONDS);
returnResResult.getSuccess(uuid);
}
}
2.4、编写服务验证逻辑，通过 aop 代理方式实现
首先创建一个@SubmitToken注解，通过这个注解来进行方法代理拦截！
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public@interfaceSubmitToken{
}
编写方法代理服务，增加防止重复提交的验证，实现了逻辑如下！
@Order(1)
@ASPect
@Component
publicclassSubmitTokenAspect{
privatestaticfinalLoggerLOGGER=LoggerFactory.getLogger(SubmitTokenAspect.class);
/**
*获取分布式锁等待时间，单位秒
*/
privatestaticfinalLongLOCK_REDIS_WAIT_TIME=3L;
/**
*分布式锁前缀
*/
privatestaticfinalStringLOCK_KEY_PREFIX="SUBMIT:TOKEN:LOCK";
/**
*默认锁对应的值
*/
privatestaticfinalStringDEFAULT_LOCK_VALUE="DEFAULT_LOCK_VALUE";
@Autowired
privateStringRedisTemplatestringRedisTemplate;
@Autowired
privateRedisLockServiceredisLockService;
/**
*方法调用环绕拦截
*/
@Around(value="@annotation(com.example.submittoken.config.annotation.SubmitToken)")
publicObjectdoAround(ProceedingJoinPointjoinPoint){
HttpServletRequestrequest=getHttpServletRequest();
if(Objects.isNull(request)){
returnResResult.getSysError("请求参数不能为空！");
}
StringsubmitToken=request.getHeader("submitToken");
if(StringUtils.isEmpty(submitToken)){
returnResResult.getSysError("submitToken不能为空！");
}
//检查submitToken是否存在
StringsubmitTokenValue=stringRedisTemplate.opsForValue().get(submitToken);
if(StringUtils.isEmpty(submitTokenValue)){
returnResResult.getSysError(ResResultEnum.SUBMIT_ERROR_MESSAGE);
}
//尝试加锁
StringlockKey=LOCK_KEY_PREFIX+submitToken;
booleanlock=redisLockService.tryLock(lockKey,DEFAULT_LOCK_VALUE,Duration.ofSeconds(LOCK_REDIS_WAIT_TIME));
if(!lock){
returnResResult.getSysError("服务正在处理，请勿重复提交！");
}
try{
//继续执行后续流程
Objectresult=joinPoint.proceed();
//任务执行成功，清除submitToken缓存
stringRedisTemplate.delete(submitToken);
returnresult;
}catch(CommonExceptione){
returnResResult.getSysError(e.getMessage());
}catch(Throwablee){
LOGGER.error("业务处理发生异常，错误信息：",e);
returnResResult.getSysError(ResResultEnum.DEFAULT_ERROR_MESSAGE);
}finally{
//执行完毕之后，手动将锁释放
redisLockService.releaseLock(lockKey,DEFAULT_LOCK_VALUE);
}
}
/**
*获取请求对象
*@return
*/
privateHttpServletRequestgetHttpServletRequest(){
RequestAttributesra=RequestContextHolder.getRequestAttributes();
ServletRequestAttributessra=(ServletRequestAttributes)ra;
HttpServletRequestrequest=sra.getRequest();
returnrequest;
}
}
部分校验逻辑用到了redis分布式锁，具体实现逻辑如下：
/**
*redis分布式锁服务类
*采用Lua脚本实现，保证加锁、解锁操作原子性
*
*/
@Component
publicclassRedisLockService{
/**
*分布式锁过期时间，单位秒
*/
privatestaticfinalLongDEFAULT_LOCK_EXPIRE_TIME=60L;
@Autowired
privateStringRedisTemplatestringRedisTemplate;
/**
*尝试在指定时间内加锁
*@paramkey
*@paramvalue
*@paramtimeout锁等待时间
*@return
*/
publicbooleantryLock(Stringkey,Stringvalue,Durationtimeout){
longwaitMills=timeout.toMillis();
longcurrentTimeMillis=System.currentTimeMillis();
do{
booleanlock=lock(key,value,DEFAULT_LOCK_EXPIRE_TIME);
if(lock){
returntrue;
}
try{
Thread.sleep(1L);
}catch(InterruptedExceptione){
Thread.interrupted();
}
}while(System.currentTimeMillis()<currentTimeMillis+waitMills);
returnfalse;
}
/**
*直接加锁
*@paramkey
*@paramvalue
*@paramexpire
*@return
*/
publicbooleanlock(Stringkey,Stringvalue,Longexpire){
StringluaScript="ifredis.call('setnx',KEYS[1],ARGV[1])==1thenreturnredis.call('expire',KEYS[1],ARGV[2])elsereturn0end";
RedisScript<Long>redisScript=newDefaultRedisScript<>(luaScript,Long.class);
Longresult=stringRedisTemplate.execute(redisScript,Collections.singletonList(key),value,String.valueOf(expire));
returnresult.equals(Long.valueOf(1));
}
/**
*释放锁
*@paramkey
*@paramvalue
*@return
*/
publicbooleanreleaseLock(Stringkey,Stringvalue){
StringluaScript="ifredis.call('get',KEYS[1])==ARGV[1]thenreturnredis.call('del',KEYS[1])elsereturn0end";
RedisScript<Long>redisScript=newDefaultRedisScript<>(luaScript,Long.class);
Longresult=stringRedisTemplate.execute(redisScript,Collections.singletonList(key),value);
returnresult.equals(Long.valueOf(1));
}
}
2.5、在相关的业务接口上，增加SubmitToken注解即可
@RestController
@RequestMapping("order")
publicclassOrderController{
@Autowired
privateOrderServiceorderService;
/**
*下单
*@paramrequest
*@return
*/
@SubmitToken
@PostMapping(value="confirm")
publicResResultconfirm(@RequestBodyOrderConfirmRequestrequest){
//调用订单下单相关逻辑
orderService.confirm(request);
returnResResult.getSuccess();
}
}
整套方案完全基于redis来实现，同时结合redis的分布式锁来实现请求限流，之所以选择redis，是因为它是一个内存数据库，性能比关系型数据库强太多，即使每秒的下单请求量在几千，也能很好的应对，为关系型数据库起到降压作用！
特别注意的地方：使用redis的分布式锁，推荐单机环境，如果redis是集群环境，可能会导致锁短暂无效！
三、小结
随着下单流量逐渐上升，通过查询数据库来检查当前服务请求是否重复提交这种方式，可能会让数据库的请求查询频率变得非常高，数据库的压力会倍增。
此时我们可以引入redis缓存，将通过查询数据库来检查当前请求是否重复提交这种方式，转移到通过查询缓存来检查当前请求是否重复提交，可以很好的给数据库降压！
到此这篇关于Java利用redis实现防止接口重复提交的文章就介绍到这了,更多相关Java redis接口防重复提交内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
