<!-- 引入springboot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.0.RELEASE</version>
</parent>

......

<!-- Redis相關(guān)依賴(lài)包，采用jedis作為客戶(hù)端 -->
<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>

# Redis數(shù)據(jù)庫(kù)索引（默認(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ù)器連接超時(shí)配置
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

@RestController
@RequestMapping("api")
public class SubmitTokenController {

    /**
     * SubmitToken過(guò)期時(shí)間
     */
    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);
    }
}

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

}

@Order(1)
@Aspect
@Component
public class SubmitTokenAspect {

    private static final Logger LOGGER = LoggerFactory.getLogger(SubmitTokenAspect.class);

    /**
     * 獲取分布式鎖等待時(shí)間，單位秒
     */
    private static final Long LOCK_REDIS_WAIT_TIME = 3L;

    /**
     * 分布式鎖前綴
     */
    private static final String LOCK_KEY_PREFIX = "SUBMIT:TOKEN:LOCK";

    /**
     * 默認(rèn)鎖對(duì)應(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("請(qǐng)求參數(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ù)正在處理，請(qǐng)勿重復(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ā)生異常，錯(cuò)誤信息：",e);
            return ResResult.getSysError(ResResultEnum.DEFAULT_ERROR_MESSAGE);
        } finally {
            //執(zhí)行完畢之后，手動(dòng)將鎖釋放
            redisLockService.releaseLock(lockKey, DEFAULT_LOCK_VALUE);
        }
    }

    /**
     * 獲取請(qǐng)求對(duì)象
     * @return
     */
    private HttpServletRequest getHttpServletRequest(){
        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes)ra;
        HttpServletRequest request = sra.getRequest();
        return request;
    }
}

/**
 * redis分布式鎖服務(wù)類(lèi)
 * 采用LUA腳本實(shí)現(xiàn)，保證加鎖、解鎖操作原子性
 *
 */
@Component
public class RedisLockService {

    /**
     * 分布式鎖過(guò)期時(shí)間，單位秒
     */
    private static final Long DEFAULT_LOCK_EXPIRE_TIME = 60L;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 嘗試在指定時(shí)間內(nèi)加鎖
     * @param key
     * @param value
     * @param timeout 鎖等待時(shí)間
     * @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));
    }
}

@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();
    }
}