// 給按鈕加個(gè)“冷靜debuff”
let isSubmitting = false;

function submitOrder() {
    if (isSubmitting) {
        alert("客官您點(diǎn)得太快了，喝口茶歇歇~");
        return;
    }
    
    isSubmitting = true;
    // 提交請(qǐng)求...
    
    // 3秒后才能再次點(diǎn)擊
    setTimeout(() => {
        isSubmitting = false;
    }, 3000);
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PreventDuplicateSubmit {
    /**
     * 防抖時(shí)間（秒），默認(rèn)3秒
     */
    int lockTime() default 3;
    
    /**
     * 鎖的key，支持SpEL表達(dá)式
     */
    String key() default "";
    
    /**
     * 提示信息
     */
    String message() default "請(qǐng)勿重復(fù)提交";
}

@Aspect
@Component
@Slf4j
public class DuplicateSubmitAspect {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private HttpServletRequest request;
    
    @Pointcut("@annotation(preventDuplicateSubmit)")
    public void pointcut(PreventDuplicateSubmit preventDuplicateSubmit) {
    }
    
    @Around("pointcut(preventDuplicateSubmit)")
    public Object around(ProceedingJoinPoint joinPoint, 
                        PreventDuplicateSubmit preventDuplicateSubmit) throws Throwable {
        
        // 1. 構(gòu)造鎖的key
        String lockKey = buildLockKey(joinPoint, preventDuplicateSubmit);
        
        // 2. 嘗試加鎖（setnx操作）
        Boolean success = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, "LOCKED", 
                           preventDuplicateSubmit.lockTime(), TimeUnit.SECONDS);
        
        if (Boolean.TRUE.equals(success)) {
            // 加鎖成功，執(zhí)行方法
            try {
                return joinPoint.proceed();
            } finally {
                // 可以根據(jù)業(yè)務(wù)決定是否立即刪除鎖
                // redisTemplate.delete(lockKey);
            }
        } else {
            // 加鎖失敗，說(shuō)明重復(fù)提交了
            throw new RuntimeException(preventDuplicateSubmit.message());
        }
    }
    
    private String buildLockKey(ProceedingJoinPoint joinPoint, 
                               PreventDuplicateSubmit annotation) {
        StringBuilder keyBuilder = new StringBuilder("SUBMIT:LOCK:");
        
        // 如果有自定義key
        if (StringUtils.isNotBlank(annotation.key())) {
            keyBuilder.append(parseKey(joinPoint, annotation.key()));
        } else {
            // 默認(rèn)使用：方法名 + 用戶(hù)ID + 參數(shù)hash
            keyBuilder.append(joinPoint.getSignature().toShortString());
            
            // 加上用戶(hù)ID（如果有登錄）
            String userId = getCurrentUserId();
            if (userId != null) {
                keyBuilder.append(":").append(userId);
            }
            
            // 加上參數(shù)摘要
            Object[] args = joinPoint.getArgs();
            if (args.length > 0) {
                String argsHash = DigestUtils.md5DigestAsHex(
                    Arrays.deepToString(args).getBytes()
                ).substring(0, 8);
                keyBuilder.append(":").append(argsHash);
            }
        }
        
        return keyBuilder.toString();
    }
    
    private String getCurrentUserId() {
        // 從Token或Session中獲取用戶(hù)ID
        // 這里簡(jiǎn)化處理
        return (String) request.getSession().getAttribute("userId");
    }
}

@RestController
@RequestMapping("/order")
public class OrderController {
    
    @PostMapping("/create")
    @PreventDuplicateSubmit(lockTime = 5, message = "訂單正在處理中，請(qǐng)勿重復(fù)提交")
    public ApiResult createOrder(@RequestBody OrderDTO orderDTO) {
        // 業(yè)務(wù)邏輯
        orderService.create(orderDTO);
        return ApiResult.success("下單成功");
    }
    
    @PostMapping("/pay")
    @PreventDuplicateSubmit(
        key = "'PAY:' + #orderNo + ':' + T(com.example.util.UserUtil).getCurrentUserId()",
        lockTime = 10,
        message = "支付請(qǐng)求已提交，請(qǐng)勿重復(fù)操作"
    )
    public ApiResult payOrder(String orderNo) {
        // 支付邏輯
        return ApiResult.success("支付成功");
    }
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    // 業(yè)務(wù)唯一號(hào)：時(shí)間戳 + 用戶(hù)ID + 隨機(jī)數(shù)
    @Column(name = "order_no", unique = true, nullable = false)
    private String orderNo;
    
    // 或者使用請(qǐng)求ID作為防重
    @Column(name = "request_id", unique = true)
    private String requestId;
    
    // ...其他字段
}

@Service
@Slf4j
public class OrderService {
    
    @Transactional(rollbackFor = Exception.class)
    public void createOrder(OrderDTO dto) {
        // 生成唯一請(qǐng)求ID（前端傳遞或后端生成）
        String requestId = dto.getRequestId();
        if (StringUtils.isBlank(requestId)) {
            requestId = UUID.randomUUID().toString();
        }
        
        // 檢查是否已處理過(guò)該請(qǐng)求
        if (orderRepository.existsByRequestId(requestId)) {
            log.warn("重復(fù)請(qǐng)求被攔截：{}", requestId);
            throw new BusinessException("訂單已提交，請(qǐng)勿重復(fù)操作");
        }
        
        // 創(chuàng)建訂單
        Order order = new Order();
        order.setRequestId(requestId);
        order.setOrderNo(generateOrderNo());
        // ...設(shè)置其他字段
        
        try {
            orderRepository.save(order);
        } catch (DataIntegrityViolationException e) {
            // 捕獲唯一約束異常
            throw new BusinessException("訂單已存在，請(qǐng)勿重復(fù)提交");
        }
    }
}

@Component
public class LocalDuplicateChecker {
    
    // Guava緩存，3秒自動(dòng)過(guò)期
    private final Cache<String, Boolean> submitCache = CacheBuilder.newBuilder()
            .expireAfterWrite(3, TimeUnit.SECONDS)
            .maximumSize(10000)
            .build();
    
    /**
     * 檢查是否重復(fù)提交
     * @param key 請(qǐng)求唯一標(biāo)識(shí)
     * @return true=重復(fù)提交, false=首次提交
     */
    public boolean isDuplicate(String key) {
        try {
            // 如果key不存在，則放入緩存并返回null
            // 如果key存在，則返回緩存的值
            return submitCache.get(key, () -> {
                // 這個(gè)lambda只在key不存在時(shí)執(zhí)行
                return false;
            });
        } catch (ExecutionException e) {
            return true;
        }
    }
    
    /**
     * 手動(dòng)放入緩存（用于防止并發(fā)時(shí)多次通過(guò)檢查）
     */
    public void markAsSubmitted(String key) {
        submitCache.put(key, true);
    }
}

// 使用方式
@RestController
public class ApiController {
    
    @Autowired
    private LocalDuplicateChecker duplicateChecker;
    
    @PostMapping("/api/submit")
    public ApiResult submitData(@RequestBody SubmitData data, 
                               HttpServletRequest request) {
        
        // 構(gòu)造唯一key：IP + 用戶(hù)ID + 數(shù)據(jù)摘要
        String clientIp = request.getRemoteAddr();
        String userId = getCurrentUserId();
        String dataHash = DigestUtils.md5DigestAsHex(
            JSON.toJSONString(data).getBytes()
        ).substring(0, 8);
        
        String lockKey = String.format("SUBMIT:%s:%s:%s", 
                                      clientIp, userId, dataHash);
        
        if (duplicateChecker.isDuplicate(lockKey)) {
            return ApiResult.error("請(qǐng)勿重復(fù)提交");
        }
        
        // 標(biāo)記為已提交
        duplicateChecker.markAsSubmitted(lockKey);
        
        // 執(zhí)行業(yè)務(wù)邏輯
        return processData(data);
    }
}

@RestController
public class TokenController {
    
    @GetMapping("/api/getToken")
    public ApiResult getToken() {
        String token = UUID.randomUUID().toString();
        
        // 存入Redis，有效期5分鐘
        redisTemplate.opsForValue().set(
            "SUBMIT_TOKEN:" + token, 
            "VALID", 
            5, TimeUnit.MINUTES
        );
        
        return ApiResult.success(token);
    }
}

@Aspect
@Component
public class TokenCheckAspect {
    
    @Pointcut("@annotation(needTokenCheck)")
    public void pointcut(NeedTokenCheck needTokenCheck) {
    }
    
    @Around("pointcut(needTokenCheck)")
    public Object checkToken(ProceedingJoinPoint joinPoint, 
                            NeedTokenCheck needTokenCheck) throws Throwable {
        
        HttpServletRequest request = ((ServletRequestAttributes) 
            RequestContextHolder.getRequestAttributes()).getRequest();
        
        String token = request.getHeader("X-Submit-Token");
        if (StringUtils.isBlank(token)) {
            throw new RuntimeException("提交令牌缺失");
        }
        
        String redisKey = "SUBMIT_TOKEN:" + token;
        String value = (String) redisTemplate.opsForValue().get(redisKey);
        
        if (!"VALID".equals(value)) {
            throw new RuntimeException("無(wú)效的提交令牌");
        }
        
        // 刪除令牌（一次性使用）
        redisTemplate.delete(redisKey);
        
        return joinPoint.proceed();
    }
}

// 提交前先獲取令牌
async function submitWithToken(data) {
    // 1. 獲取令牌
    const token = await fetch('/api/getToken').then(r => r.json());
    
    // 2. 攜帶令牌提交
    const result = await fetch('/api/submit', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'X-Submit-Token': token
        },
        body: JSON.stringify(data)
    });
    
    return result;
}

// 最佳實(shí)踐：組合拳！
@PostMapping("/important/submit")
@PreventDuplicateSubmit(lockTime = 5)
@Transactional(rollbackFor = Exception.class)
public ApiResult importantSubmit(@RequestBody @Valid RequestDTO dto) {
    // 1. 檢查請(qǐng)求ID是否重復(fù)
    checkRequestId(dto.getRequestId());
    
    // 2. 執(zhí)行業(yè)務(wù)
    // 3. 數(shù)據(jù)庫(kù)唯一約束兜底
    
    return ApiResult.success();
}