import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AntiDuplicateSubmit {
    // 防抖時間（默認(rèn)1秒）
    long timeout() default 1;
    // 時間單位（默認(rèn)秒）
    TimeUnit unit() default TimeUnit.SECONDS;
    // 提示信息
    String message() default "操作過于頻繁，請稍后再試！";
}

-- 1. 接收參數(shù)：key=請求標(biāo)識，timeout=過期時間
local key = KEYS[1]
local timeout = ARGV[1]
-- 2. 查鎖：存在則返回1（重復(fù)提交），不存在則加鎖返回0
if redis.call('EXISTS', key) == 1 then
    return 1
else
    redis.call('SET', key, '1', 'EX', timeout)
    return 0
end

import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import java.lang.reflect.Method;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
@Aspect
@Component
@Slf4j
public class AntiDuplicateSubmitAspect {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    private final DefaultRedisScript<Long> antiDuplicateScript;
    // 初始化Lua腳本
    public AntiDuplicateSubmitAspect() {
        antiDuplicateScript = new DefaultRedisScript<>();
        antiDuplicateScript.setLocation(new ClassPathResource("lua/anti_duplicate_submit.lua"));
        antiDuplicateScript.setResultType(Long.class);
    }
    @Around("@annotation(com.example.demo.annotation.AntiDuplicateSubmit)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        AntiDuplicateSubmit annotation = method.getAnnotation(AntiDuplicateSubmit.class);
        // 3. 生成唯一請求標(biāo)識（用戶ID+接口名+參數(shù)摘要）
        String requestKey = generateRequestKey(joinPoint, method);
        long timeout = annotation.unit().toSeconds(annotation.timeout());
        // 4. 執(zhí)行Lua腳本
        Long result = stringRedisTemplate.execute(
                antiDuplicateScript,
                Collections.singletonList(requestKey),
                String.valueOf(timeout)
        );
        // 5. 結(jié)果判斷：1=重復(fù)提交，0=正常執(zhí)行
        if (result != null && result == 1) {
            log.warn("接口重復(fù)提交，key:{}", requestKey);
            throw new RuntimeException(annotation.message());
        }
        // 6. 正常執(zhí)行接口邏輯
        try {
            return joinPoint.proceed();
        } finally {
            // 可選：非冪等接口執(zhí)行完手動釋放鎖（冪等接口可依賴自動過期）
            // stringRedisTemplate.delete(requestKey);
        }
    }
    // 生成唯一請求標(biāo)識：避免不同用戶/不同參數(shù)被誤判為重復(fù)
    private String generateRequestKey(ProceedingJoinPoint joinPoint, Method method) {
        // 獲取用戶ID（實際項目從Token/上下文獲取，這里簡化）
        String userId = "anonymous"; // 替換為真實用戶標(biāo)識
        // 獲取接口名（類名+方法名）
        String methodName = method.getDeclaringClass().getName() + "." + method.getName();
        // 獲取參數(shù)摘要（避免參數(shù)不同但被誤判，用MD5加密）
        String paramDigest = DigestUtils.md5DigestAsHex(
                (joinPoint.getArgs() != null ? joinPoint.getArgs().toString() : "").getBytes(StandardCharsets.UTF_8)
        );
        // 拼接key：redis key前綴+用戶ID+接口名+參數(shù)摘要
        return "anti_duplicate:" + userId + ":" + methodName + ":" + paramDigest;
    }
}

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class OrderController {
    // 下單接口：1秒內(nèi)禁止重復(fù)提交
    @AntiDuplicateSubmit(timeout = 1, message = "下單太頻繁啦，1秒后再試~")
    @PostMapping("/api/order/create")
    public String createOrder(@RequestBody OrderDTO orderDTO) {
        // 下單邏輯（省略）
        return "下單成功，訂單號：" + System.currentTimeMillis();
    }
}

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import jakarta.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@RestController
public class TokenController {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    // 生成防重令牌（前端調(diào)用接口前先獲取）
    @GetMapping("/api/token/get")
    public String getAntiDuplicateToken() {
        // 生成UUID作為令牌
        String token = "anti_duplicate_token:" + UUID.randomUUID().toString().replace("-", "");
        // 存入Redis，過期時間5分鐘（根據(jù)業(yè)務(wù)調(diào)整）
        stringRedisTemplate.opsForValue().set(token, "1", 5, TimeUnit.MINUTES);
        return token;
    }
}

// 在AntiDuplicateSubmitAspect的around方法中新增Token驗證邏輯
private void validateToken(HttpServletRequest request) {
    String token = request.getHeader("Anti-Duplicate-Token");
    if (StringUtils.isEmpty(token)) {
        throw new RuntimeException("缺少防重令牌，請先獲取令牌！");
    }
    // 驗證令牌是否存在，存在則刪除（一次性使用）
    Boolean exists = stringRedisTemplate.delete(token);
    if (exists == null || !exists) {
        throw new RuntimeException("令牌無效或已過期！");
    }
}

// 1. 先獲取令牌
fetch('/api/token/get').then(res => res.text()).then(token => {
    // 2. 帶著令牌調(diào)用下單接口
    fetch('/api/order/create', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Anti-Duplicate-Token': token // 令牌放在請求頭
        },
        body: JSON.stringify({orderNo: 'xxx', amount: 100})
    });
});

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version>
</dependency>

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
public class CaffeineConfig {
    @Bean
    public CacheManager antiDuplicateCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        // 配置緩存：最大容量10萬（防止內(nèi)存溢出），過期時間1秒
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .maximumSize(100000)
                .expireAfterWrite(1, TimeUnit.SECONDS));
        return cacheManager;
    }
}

import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Component;
// 在AntiDuplicateSubmitAspect中注入本地緩存管理器
@Resource(name = "antiDuplicateCacheManager")
private CacheManager cacheManager;
// 替換Lua腳本邏輯，用本地緩存實現(xiàn)
private boolean checkLocalCache(String requestKey) {
    Cache cache = cacheManager.getCache("antiDuplicateCache");
    if (cache == null) {
        throw new RuntimeException("本地緩存初始化失??！");
    }
    // 查緩存：存在則返回true（重復(fù)），不存在則存入緩存
    if (cache.get(requestKey) != null) {
        return true;
    }
    cache.put(requestKey, "1");
    return false;
}

CREATE TABLE `t_order` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `order_no` varchar(64) NOT NULL COMMENT '訂單號（唯一）',
  `user_id` bigint NOT NULL COMMENT '用戶ID',
  `product_id` bigint NOT NULL COMMENT '商品ID',
  `amount` decimal(10,2) NOT NULL COMMENT '金額',
  PRIMARY KEY (`id`),
  -- 唯一索引：訂單號唯一（防止重復(fù)下單）
  UNIQUE KEY `uk_order_no` (`order_no`),
  -- 聯(lián)合唯一索引：同一用戶不能同時買同一商品（根據(jù)業(yè)務(wù)需求）
  UNIQUE KEY `uk_user_product` (`user_id`,`product_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='訂單表';

import org.springframework.dao.DuplicateKeyException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
@RestControllerAdvice
public class GlobalExceptionHandler {
    // 捕獲數(shù)據(jù)庫唯一約束異常，返回友好提示
    @ExceptionHandler(DuplicateKeyException.class)
    public String handleDuplicateKeyException(DuplicateKeyException e) {
        log.error("重復(fù)提交導(dǎo)致唯一約束沖突：", e);
        return "操作失敗，請勿重復(fù)提交！";
    }
}

// 增強AntiDuplicateSubmit注解，支持選擇防抖方式
public @interface AntiDuplicateSubmit {
    // 防抖方式：REDIS/Local_CACHE/TOKEN
    Mode mode() default Mode.REDIS;
    long timeout() default 1;
    TimeUnit unit() default TimeUnit.SECONDS;
    String message() default "操作過于頻繁，請稍后再試！";
    enum Mode {
        REDIS, LOCAL_CACHE, TOKEN
    }
}

@Around("@annotation(antiDuplicateSubmit)")
public Object around(ProceedingJoinPoint joinPoint, AntiDuplicateSubmit antiDuplicateSubmit) throws Throwable {
    String requestKey = generateRequestKey(joinPoint, antiDuplicateSubmit.method());
    AntiDuplicateSubmit.Mode mode = antiDuplicateSubmit.mode();
    // 根據(jù)模式選擇不同方案
    if (mode == AntiDuplicateSubmit.Mode.REDIS) {
        // Redis+Lua方案
        Long result = stringRedisTemplate.execute(antiDuplicateScript, Collections.singletonList(requestKey), String.valueOf(timeout));
        if (result != null && result == 1) {
            throw new RuntimeException(antiDuplicateSubmit.message());
        }
    } else if (mode == AntiDuplicateSubmit.Mode.LOCAL_CACHE) {
        // 本地緩存方案
        if (checkLocalCache(requestKey)) {
            throw new RuntimeException(antiDuplicateSubmit.message());
        }
    } else if (mode == AntiDuplicateSubmit.Mode.TOKEN) {
        // Token方案
        validateToken(request);
    }
    return joinPoint.proceed();
}

// 支付接口：用TOKEN模式（最安全）
@AntiDuplicateSubmit(mode = AntiDuplicateSubmit.Mode.TOKEN, message = "支付請求已提交，請勿重復(fù)操作！")
@PostMapping("/api/pay")
public String pay(@RequestBody PayDTO payDTO) { ... }
// 下單接口：用REDIS模式（分布式高并發(fā)）
@AntiDuplicateSubmit(mode = AntiDuplicateSubmit.Mode.REDIS, timeout = 2)
@PostMapping("/api/order/create")
public String createOrder(@RequestBody OrderDTO orderDTO) { ... }
// 評論接口：用LOCAL_CACHE模式（單機部署）
@AntiDuplicateSubmit(mode = AntiDuplicateSubmit.Mode.LOCAL_CACHE)
@PostMapping("/api/comment/add")
public String addComment(@RequestBody CommentDTO commentDTO) { ... }