?一、摘要
在上一篇文章中，我們詳細(xì)的介紹了對于下單流量不算高的系統(tǒng)，可以通過?請求唯一ID?+?數(shù)據(jù)表增加唯一索引約束?這種方案來實現(xiàn)防止接口重復(fù)提交！
隨著業(yè)務(wù)的快速增長，每一秒的下單請求次數(shù)，可能從幾十上升到幾百甚至幾千。
面對這種下單流量越來越高的場景，此時數(shù)據(jù)庫的訪問壓力會急劇上升，上面這套方案全靠數(shù)據(jù)庫來解決，會特別吃力！
對于這樣的場景，我們可以選擇引入緩存中間件來解決，可選的組件有 redis、memcache 等。
下面，我們以引入redis緩存數(shù)據(jù)庫服務(wù)器，向大家介紹具體的解決方案！
二、方案實踐
我們先來看一張圖，這張圖就是本次方案的核心流程圖。
實現(xiàn)的邏輯，流程如下：
1.當(dāng)用戶進(jìn)入訂單提交界面的時候，調(diào)用后端獲取請求唯一 ID，同時后端將請求唯一ID存儲到redis中再返回給前端，前端將唯一 ID 值埋點在頁面里面
2.當(dāng)用戶點擊提交按鈕時，后端檢查這個請求唯一 ID 是否存在，如果不存在，提示錯誤信息；如果存在，繼續(xù)后續(xù)檢查流程
3.使用redis的分布式鎖服務(wù)，對請求 ID 在限定的時間內(nèi)進(jìn)行加鎖，如果加鎖成功，繼續(xù)后續(xù)流程；如果加鎖失敗，說明服務(wù)正在處理，請勿重復(fù)提交
4.最后一步，如果加鎖成功后，需要將鎖手動釋放掉，以免再次請求時，提示同樣的信息；同時如果任務(wù)執(zhí)行成功，需要將redis中的請求唯一 ID 清理掉
5.至于數(shù)據(jù)庫是否需要增加字段唯一索引，理論上可以不用加，如果加了更保險
引入緩存服務(wù)，防止重復(fù)提交的大體思路如上，實踐代碼如下！
2.1、引入 redis 組件
小編的項目是基于SpringBoot?版本進(jìn)行構(gòu)建，添加相關(guān)的redis依賴環(huán)境如下：
<!-- 引入springboot -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.0.RELEASE</version>
</parent>
......
<!-- Redis相關(guān)依賴包，采用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>
特別注意：由于每個項目環(huán)境不一樣，具體的依賴包需要和工程版本號匹配！
2.2、添加 redis 環(huán)境配置
在全局配置application.properties?文件中，添加redis相關(guān)服務(wù)配置如下
# Redis數(shù)據(jù)庫索引（默認(rèn)為0）
spring.redis.database=1
# Redis服務(wù)器地址
spring.redis.host=127.0.0.1
# Redis服務(wù)器連接端口
spring.redis.port=6379
# Redis服務(wù)器連接密碼（默認(rèn)為空）
spring.redis.password=
# Redis服務(wù)器連接超時配置
spring.redis.timeout=1000
# 連接池配置
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服務(wù)器是啟動狀態(tài)，并且能正常訪問！
2.3、編寫獲取請求唯一ID的接口，同時將唯一ID存入redis
@RestController
@RequestMapping("api")
public class SubmitTokenController {
/**
* SubmitToken過期時間
*/
private static final Integer EXPIRE_TIME = 60;
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 獲取getSubmitToken
* @return
*/
@RequestMapping("getSubmitToken")
public ResResult getSubmitToken(){
String uuid = UUID.randomUUID().toString();
//存入redis
stringRedisTemplate.opsForValue().set(uuid, uuid, EXPIRE_TIME, TimeUnit.SECONDS);
return ResResult.getSuccess(uuid);
}
}
2.4、編寫服務(wù)驗證邏輯，通過 aop 代理方式實現(xiàn)
首先創(chuàng)建一個@SubmitToken注解，通過這個注解來進(jìn)行方法代理攔截！
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface SubmitToken {
}
編寫方法代理服務(wù)，增加防止重復(fù)提交的驗證，實現(xiàn)了邏輯如下！
@Order(1)
@Aspect
@Component
public class SubmitTokenAspect {
private static final Logger LOGGER = LoggerFactory.getLogger(SubmitTokenAspect.class);
/**
* 獲取分布式鎖等待時間，單位秒
*/
private static final Long LOCK_REDIS_WAIT_TIME = 3L;
/**
* 分布式鎖前綴
*/
private static final String LOCK_KEY_PREFIX = "SUBMIT:TOKEN:LOCK";
/**
* 默認(rèn)鎖對應(yīng)的值
*/
private static final String DEFAULT_LOCK_VALUE = "DEFAULT_LOCK_VALUE";
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisLockService redisLockService;
/**
* 方法調(diào)用環(huán)繞攔截
*/
@Around(value = "@annotation(com.example.submittoken.config.annotation.SubmitToken)")
public Object doAround(ProceedingJoinPoint joinPoint){
HttpServletRequest request = getHttpServletRequest();
if(Objects.isNull(request)){
return ResResult.getSysError("請求參數(shù)不能為空！");
}
String submitToken = request.getHeader("submitToken");
if(StringUtils.isEmpty(submitToken)){
return ResResult.getSysError("submitToken不能為空！");
}
//檢查submitToken是否存在
String submitTokenValue = stringRedisTemplate.opsForValue().get(submitToken);
if(StringUtils.isEmpty(submitTokenValue)){
return ResResult.getSysError(ResResultEnum.SUBMIT_ERROR_MESSAGE);
}
//嘗試加鎖
String lockKey = LOCK_KEY_PREFIX + submitToken;
boolean lock = redisLockService.tryLock(lockKey, DEFAULT_LOCK_VALUE, Duration.ofSeconds(LOCK_REDIS_WAIT_TIME));
if(!lock){
return ResResult.getSysError("服務(wù)正在處理，請勿重復(fù)提交！");
}
try {
//繼續(xù)執(zhí)行后續(xù)流程
Object result = joinPoint.proceed();
//任務(wù)執(zhí)行成功，清除submitToken緩存
stringRedisTemplate.delete(submitToken);
return result;
} catch (CommonException e) {
return ResResult.getSysError(e.getMessage());
} catch (Throwable e) {
LOGGER.error("業(yè)務(wù)處理發(fā)生異常，錯誤信息：",e);
return ResResult.getSysError(ResResultEnum.DEFAULT_ERROR_MESSAGE);
} finally {
//執(zhí)行完畢之后，手動將鎖釋放
redisLockService.releaseLock(lockKey, DEFAULT_LOCK_VALUE);
}
}
/**
* 獲取請求對象
* @return
*/
private HttpServletRequest getHttpServletRequest(){
RequestAttributes ra = RequestContextHolder.getRequestAttributes();
ServletRequestAttributes sra = (ServletRequestAttributes)ra;
HttpServletRequest request = sra.getRequest();
return request;
}
}
部分校驗邏輯用到了redis分布式鎖，具體實現(xiàn)邏輯如下：
/**
* redis分布式鎖服務(wù)類
* 采用LUA腳本實現(xiàn)，保證加鎖、解鎖操作原子性
*
*/
@Component
public class RedisLockService {
/**
* 分布式鎖過期時間，單位秒
*/
private static final Long DEFAULT_LOCK_EXPIRE_TIME = 60L;
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 嘗試在指定時間內(nèi)加鎖
* @param key
* @param value
* @param timeout 鎖等待時間
* @return
*/
public boolean tryLock(String key,String value, Duration timeout){
long waitMills = timeout.toMillis();
long currentTimeMillis = System.currentTimeMillis();
do {
boolean lock = lock(key, value, DEFAULT_LOCK_EXPIRE_TIME);
if (lock) {
return true;
}
try {
Thread.sleep(1L);
} catch (InterruptedException e) {
Thread.interrupted();
}
} while (System.currentTimeMillis() < currentTimeMillis + waitMills);
return false;
}
/**
* 直接加鎖
* @param key
* @param value
* @param expire
* @return
*/
public boolean lock(String key,String value, Long expire){
String luaScript = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then return redis.call('expire', KEYS[1], ARGV[2]) else return 0 end";
RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
Long result = stringRedisTemplate.execute(redisScript, Collections.singletonList(key), value, String.valueOf(expire));
return result.equals(Long.valueOf(1));
}
/**
* 釋放鎖
* @param key
* @param value
* @return
*/
public boolean releaseLock(String key,String value){
String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
Long result = stringRedisTemplate.execute(redisScript, Collections.singletonList(key),value);
return result.equals(Long.valueOf(1));
}
}
2.5、在相關(guān)的業(yè)務(wù)接口上，增加SubmitToken注解即可
@RestController
@RequestMapping("order")
public class OrderController {
@Autowired
private OrderService orderService;
/**
* 下單
* @param request
* @return
*/
@SubmitToken
@PostMapping(value = "confirm")
public ResResult confirm(@RequestBody OrderConfirmRequest request){
//調(diào)用訂單下單相關(guān)邏輯
orderService.confirm(request);
return ResResult.getSuccess();
}
}
整套方案完全基于?redis?來實現(xiàn)，同時結(jié)合?redis?的分布式鎖來實現(xiàn)請求限流，之所以選擇?redis?，是因為它是一個內(nèi)存數(shù)據(jù)庫，性能比關(guān)系型數(shù)據(jù)庫強太多，即使每秒的下單請求量在幾千，也能很好的應(yīng)對，為關(guān)系型數(shù)據(jù)庫起到降壓作用！
特別注意的地方：使用?redis?的分布式鎖，推薦單機環(huán)境，如果?redis?是集群環(huán)境，可能會導(dǎo)致鎖短暫無效！
三、小結(jié)
隨著下單流量逐漸上升，通過查詢數(shù)據(jù)庫來檢查當(dāng)前服務(wù)請求是否重復(fù)提交這種方式，可能會讓數(shù)據(jù)庫的請求查詢頻率變得非常高，數(shù)據(jù)庫的壓力會倍增。
此時我們可以引入redis緩存，將通過查詢數(shù)據(jù)庫來檢查當(dāng)前請求是否重復(fù)提交這種方式，轉(zhuǎn)移到通過查詢緩存來檢查當(dāng)前請求是否重復(fù)提交，可以很好的給數(shù)據(jù)庫降壓！
