// 提交后禁用按鈕
function submitForm() {
    const submitBtn = document.getElementById('submitBtn');
    submitBtn.disabled = true;
    // 執(zhí)行提交邏輯
    document.forms[0].submit();
}

// 顯示加載狀態(tài)
function submitForm() {
    const submitBtn = document.getElementById('submitBtn');
    submitBtn.innerHTML = '<i class="loading"></i> 提交中...';
    submitBtn.disabled = true;
}

public class OrderService {
    private final Object lock = new Object();
    
    public Result createOrder(OrderDTO orderDTO) {
        synchronized(lock) {
            // 業(yè)務(wù)邏輯
            return processOrder(orderDTO);
        }
    }
}

-- 為訂單號(hào)添加唯一索引
ALTER TABLE orders ADD UNIQUE INDEX uk_order_no (order_no);

-- 或者為業(yè)務(wù)關(guān)鍵字段添加聯(lián)合唯一索引
ALTER TABLE orders ADD UNIQUE INDEX uk_business_key (user_id, product_id, create_date);

@Mapper
public interface OrderMapper {
    // 通過(guò)版本號(hào)控制
    @Update("UPDATE orders SET status = #{status}, version = version + 1 " +
            "WHERE id = #{id} AND version = #{version}")
    int updateWithVersion(Order order);
}

@Service
@Transactional
public class OrderService {
    public Result createOrder(OrderDTO orderDTO) {
        // 1. 查詢當(dāng)前版本號(hào)
        Order order = orderMapper.selectById(orderDTO.getId());
        
        // 2. 業(yè)務(wù)處理...
        
        // 3. 更新時(shí)校驗(yàn)版本號(hào)
        int count = orderMapper.updateWithVersion(order);
        if (count == 0) {
            throw new RuntimeException("訂單已處理，請(qǐng)勿重復(fù)提交");
        }
        return Result.success();
    }
}

@Component
public class TokenUtil {
    
    private static final String TOKEN_PREFIX = "submit_token:";
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    /**
     * 生成Token
     */
    public String generateToken(String key) {
        String token = UUID.randomUUID().toString();
        String redisKey = TOKEN_PREFIX + key + ":" + token;
        redisTemplate.opsForValue().set(redisKey, "1", Duration.ofMinutes(5));
        return token;
    }
    
    /**
     * 驗(yàn)證Token
     */
    public boolean validateToken(String key, String token) {
        String redisKey = TOKEN_PREFIX + key + ":" + token;
        Boolean result = redisTemplate.delete(redisKey);
        return Boolean.TRUE.equals(result);
    }
}

@RestController
public class OrderController {
    
    @Autowired
    private TokenUtil tokenUtil;
    
    /**
     * 獲取提交Token
     */
    @GetMapping("/token")
    public Result<String> getToken() {
        String token = tokenUtil.generateToken("order");
        return Result.success(token);
    }
    
    /**
     * 提交訂單
     */
    @PostMapping("/order")
    public Result createOrder(@RequestBody OrderDTO orderDTO, 
                             @RequestHeader("X-Submit-Token") String token) {
        // 驗(yàn)證Token
        if (!tokenUtil.validateToken("order", token)) {
            return Result.fail("請(qǐng)勿重復(fù)提交");
        }
        
        // 業(yè)務(wù)邏輯
        return orderService.createOrder(orderDTO);
    }
}

// 獲取Token
async function getToken() {
    const response = await fetch('/token');
    const result = await response.json();
    return result.data;
}

// 提交訂單
async function submitOrder(orderData) {
    const token = await getToken();
    
    const response = await fetch('/order', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'X-Submit-Token': token
        },
        body: JSON.stringify(orderData)
    });
    
    return response.json();
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PreventDuplicateSubmit {
    /**
     * 防重key，支持SpEL表達(dá)式
     */
    String key() default "";
    
    /**
     * 過(guò)期時(shí)間（秒）
     */
    int expire() default 5;
    
    /**
     * 提示消息
     */
    String message() default "請(qǐng)勿重復(fù)提交";
}

@Aspect
@Component
public class PreventDuplicateSubmitAspect {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private HttpServletRequest request;
    
    private static final String LOCK_PREFIX = "submit_lock:";
    
    @Around("@annotation(preventDuplicateSubmit)")
    public Object around(ProceedingJoinPoint joinPoint, 
                        PreventDuplicateSubmit preventDuplicateSubmit) throws Throwable {
        
        String lockKey = generateLockKey(joinPoint, preventDuplicateSubmit);
        
        // 嘗試獲取鎖
        Boolean success = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, "1", Duration.ofSeconds(preventDuplicateSubmit.expire()));
        
        if (Boolean.TRUE.equals(success)) {
            try {
                // 獲取鎖成功，執(zhí)行方法
                return joinPoint.proceed();
            } finally {
                // 刪除鎖（可選，等自動(dòng)過(guò)期也行）
                // redisTemplate.delete(lockKey);
            }
        } else {
            // 獲取鎖失敗，重復(fù)提交
            throw new RuntimeException(preventDuplicateSubmit.message());
        }
    }
    
    /**
     * 生成鎖的Key
     */
    private String generateLockKey(ProceedingJoinPoint joinPoint, 
                                 PreventDuplicateSubmit preventDuplicateSubmit) {
        String key = preventDuplicateSubmit.key();
        
        if (StringUtils.hasText(key)) {
            // 解析SpEL表達(dá)式
            return LOCK_PREFIX + parseSpel(key, joinPoint);
        } else {
            // 默認(rèn)生成方式：方法名 + 參數(shù)
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            String methodName = signature.getMethod().getName();
            String args = Arrays.toString(joinPoint.getArgs());
            String userAgent = request.getHeader("User-Agent");
            
            return LOCK_PREFIX + methodName + ":" + 
                   DigestUtils.md5DigestAsHex((args + userAgent).getBytes());
        }
    }
    
    /**
     * 解析SpEL表達(dá)式
     */
    private String parseSpel(String expression, ProceedingJoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        EvaluationContext context = new StandardEvaluationContext();
        
        // 設(shè)置參數(shù)
        String[] parameterNames = signature.getParameterNames();
        Object[] args = joinPoint.getArgs();
        
        for (int i = 0; i < parameterNames.length; i++) {
            context.setVariable(parameterNames[i], args[i]);
        }
        
        ExpressionParser parser = new SpelExpressionParser();
        return parser.parseExpression(expression).getValue(context, String.class);
    }
}

@RestController
public class OrderController {
    
    @PreventDuplicateSubmit(key = "#orderDTO.userId + ':' + #orderDTO.productId", 
                           expire = 10, 
                           message = "訂單正在處理中，請(qǐng)勿重復(fù)提交")
    @PostMapping("/order")
    public Result createOrder(@RequestBody OrderDTO orderDTO) {
        // 業(yè)務(wù)邏輯
        return orderService.createOrder(orderDTO);
    }
    
    @PreventDuplicateSubmit(expire = 30)
    @PostMapping("/payment")
    public Result payment(@RequestParam String orderNo) {
        // 支付邏輯
        return paymentService.processPayment(orderNo);
    }
}

@Component
public class RedisDistributedLock {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    private static final String LOCK_PREFIX = "global_lock:";
    
    /**
     * 嘗試獲取鎖
     */
    public boolean tryLock(String key, long expireSeconds) {
        String lockKey = LOCK_PREFIX + key;
        String value = UUID.randomUUID().toString();
        
        Boolean result = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, value, Duration.ofSeconds(expireSeconds));
        
        return Boolean.TRUE.equals(result);
    }
    
    /**
     * 釋放鎖
     */
    public void unlock(String key) {
        String lockKey = LOCK_PREFIX + key;
        redisTemplate.delete(lockKey);
    }
}

@Component
public class RedissonLockService {
    
    @Autowired
    private RedissonClient redissonClient;
    
    public <T> T executeWithLock(String lockKey, long waitTime, long leaseTime, 
                                Supplier<T> supplier) {
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            // 嘗試獲取鎖
            boolean locked = lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
            if (locked) {
                return supplier.get();
            } else {
                throw new RuntimeException("系統(tǒng)繁忙，請(qǐng)稍后重試");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("獲取鎖失敗", e);
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

// 使用示例
@Service
public class OrderService {
    
    @Autowired
    private RedissonLockService lockService;
    
    public Result createOrder(OrderDTO orderDTO) {
        String lockKey = "order_submit:" + orderDTO.getUserId();
        
        return lockService.executeWithLock(lockKey, 3, 10, () -> {
            // 業(yè)務(wù)邏輯
            return processOrder(orderDTO);
        });
    }
}

@Component
public class RateLimitService {
    
    private final Map<String, RateLimiter> limiterMap = new ConcurrentHashMap<>();
    
    /**
     * 嘗試獲取令牌
     */
    public boolean tryAcquire(String key, int permitsPerSecond) {
        RateLimiter limiter = limiterMap.computeIfAbsent(key, 
            k -> RateLimiter.create(permitsPerSecond));
        return limiter.tryAcquire();
    }
}

// 使用示例
@RestController
public class ApiController {
    
    @Autowired
    private RateLimitService rateLimitService;
    
    @PostMapping("/api/submit")
    public Result submitData(@RequestBody RequestData data) {
        String clientId = getClientId(); // 獲取客戶端標(biāo)識(shí)
        
        if (!rateLimitService.tryAcquire(clientId, 5)) {
            return Result.fail("請(qǐng)求過(guò)于頻繁，請(qǐng)稍后重試");
        }
        
        // 處理業(yè)務(wù)
        return processData(data);
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SubmitProtection {
    /** 防重提交key */
    String key() default "";
    /** 鎖過(guò)期時(shí)間 */
    int lockExpire() default 10;
    /** 限流配置：每秒允許的請(qǐng)求數(shù) */
    double rateLimit() default 1.0;
    /** 提示消息 */
    String message() default "請(qǐng)求過(guò)于頻繁，請(qǐng)稍后重試";
}

@Aspect
@Component
public class SubmitProtectionAspect {
    
    @Autowired
    private RedissonClient redissonClient;
    
    private final Map<String, RateLimiter> rateLimiterMap = new ConcurrentHashMap<>();
    
    @Around("@annotation(protection)")
    public Object around(ProceedingJoinPoint joinPoint, SubmitProtection protection) throws Throwable {
        String protectionKey = generateProtectionKey(joinPoint, protection);
        
        // 1. 限流檢查
        if (protection.rateLimit() > 0) {
            RateLimiter limiter = rateLimiterMap.computeIfAbsent(
                protectionKey, k -> RateLimiter.create(protection.rateLimit()));
            if (!limiter.tryAcquire()) {
                throw new RuntimeException(protection.message());
            }
        }
        
        // 2. 分布式鎖防重
        RLock lock = redissonClient.getLock("submit_protection:" + protectionKey);
        try {
            if (lock.tryLock(0, protection.lockExpire(), TimeUnit.SECONDS)) {
                return joinPoint.proceed();
            } else {
                throw new RuntimeException("請(qǐng)求正在處理中，請(qǐng)勿重復(fù)提交");
            }
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
    
    private String generateProtectionKey(ProceedingJoinPoint joinPoint, SubmitProtection protection) {
        // 生成key的邏輯，參考前面的AOP方案
        return "default_key";
    }
}