package com.sin.controller;// 需要先在pom.xml中添加Spring Web依賴

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.concurrent.ConcurrentHashMap;

/**
 * @createTime 2024/6/4 11:17
 * @createAuthor SIN
 * @use 時(shí)間戳防抖
 */
@Controller
@RequestMapping("/api")
public class DebounceController {

    // 用于存儲(chǔ)接口請(qǐng)求的時(shí)間戳
    private final ConcurrentHashMap<String, Long> requestTimestamps = new ConcurrentHashMap<>();

    @PostMapping("/submit")
    @ResponseBody
    public String submit() {
        // 接口路徑為"/api/submit"，模擬防抖處理
        String key = "/api/submit";

        // 獲取當(dāng)前時(shí)間戳
        long currentTimestamp = System.currentTimeMillis();

        // 上一次請(qǐng)求的時(shí)間戳
        Long lastTimestamp = requestTimestamps.get(key);

        // 如果上一次請(qǐng)求時(shí)間不為空，并且與當(dāng)前時(shí)間間隔小于5000毫秒（5秒），則認(rèn)為是重復(fù)請(qǐng)求，直接返回提示
        if (lastTimestamp != null && currentTimestamp - lastTimestamp < 5000) {
            return "重復(fù)提交，請(qǐng)稍后再試！";
        }

        // 記錄當(dāng)前請(qǐng)求時(shí)間戳
        requestTimestamps.put(key, currentTimestamp);

        // 返回處理結(jié)果
        return "提交成功！";
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring:
  data:
    redis:
      host: 192.168.226.134
      password: 123456

package com.sin.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

/**
 * @createTime 2024/6/4 11:17
 * @createAuthor SIN
 * @use 分布式緩存（Redis）防抖
 */
@RestController
@RequestMapping("/api")
public class RedisDebounceController {

    private static final String REQUEST_KEY = "submit:request";

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @PostMapping("/redisSubmit")
    public String submit() {
        // 檢查Redis中是否存在請(qǐng)求標(biāo)記
        if (redisTemplate.hasKey(REQUEST_KEY)) {
            return "重復(fù)提交，請(qǐng)稍后再試！";
        }

        // 將請(qǐng)求標(biāo)記寫入Redis，并設(shè)置過(guò)期時(shí)間
        redisTemplate.opsForValue().set(REQUEST_KEY, "1", 5, TimeUnit.SECONDS);

        // 返回處理結(jié)果
        return "提交成功！";
    }
}

package com.sin.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @createTime 2024/6/4 11:29
 * @createAuthor SIN
 * @use 使用分布式鎖防抖
 */
@RestController
@RequestMapping("/api")
public class RedisLockDebounceController {
    private static final long LOCK_EXPIRE_TIME = 10000L; // 鎖的過(guò)期時(shí)間，單位毫秒
    private static final long DEBOUNCE_TIME = 10000L; // 防抖時(shí)間，單位毫秒

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @PostMapping("/redis/lock")
    public String acquireLock(String key) {
        String lockKey = key; // 鎖的鍵名為傳入的 key 參數(shù)
        String requestId = String.valueOf(System.currentTimeMillis()); // 請(qǐng)求 ID 為當(dāng)前時(shí)間戳的字符串形式

        /**
         * Lua 腳本的作用是嘗試獲取分布式鎖。它通過(guò) SETNX 命令嘗試在 Redis 中設(shè)置一個(gè)鍵的值，如果設(shè)置成功，則進(jìn)一步設(shè)置該鍵的過(guò)期時(shí)間，并返回 true 表示獲取鎖成功；如果設(shè)置失敗，則表示鎖已被其他客戶端獲取，返回 false 表示獲取鎖失敗。
         * RedisScript<Boolean>： Spring Data Redis 提供的用于執(zhí)行 Lua 腳本的接口
         * DefaultRedisScript<>(script,Boolean.class)：RedisScript 的實(shí)例化操作，
         *          script 參數(shù)是一個(gè)字符串類型的 Lua 腳本，表示要執(zhí)行的 Redis 操作。
         *          Boolean.class 參數(shù)指定了腳本執(zhí)行后的返回類型為布爾值。
         * if redis.call('SETNX', KEYS[1], ARGV[1]) == 1 then： Redis 的 SETNX 命令，用于在 Redis 中設(shè)置一個(gè)鍵的值，但只有在該鍵不存在時(shí)才設(shè)置成功。
         *          KEYS[1] 表示 Lua 腳本中傳入的鍵的數(shù)組，這里取第一個(gè)鍵。
         *          ARGV[1] 表示 Lua 腳本中傳入的參數(shù)的數(shù)組，這里取第一個(gè)參數(shù)。
         *          如果 SETNX 返回值為 1，表示設(shè)置成功，即之前該鍵不存在，執(zhí)行 then 代碼塊中的操作。
         * redis.call('PEXPIRE', KEYS[1], ARGV[2])：如果 SETNX 操作成功，接著調(diào)用了 Redis 的 PEXPIRE 命令，用于設(shè)置鍵的過(guò)期時(shí)間。
         *          KEYS[1] 表示要設(shè)置過(guò)期時(shí)間的鍵，
         *          ARGV[2] 表示傳入的第二個(gè)參數(shù)，即鎖的過(guò)期時(shí)間。
         * return true：如果 SETNX 操作成功，并且設(shè)置了過(guò)期時(shí)間，最終返回 Lua 腳本執(zhí)行結(jié)果為 true，表示獲取鎖成功。
         * end：結(jié)束 if 條件語(yǔ)句塊。
         * return false：如果 SETNX 操作失敗，即之前該鍵已存在，或者設(shè)置過(guò)程中出現(xiàn)異常，最終返回 Lua 腳本執(zhí)行結(jié)果為 false，表示獲取鎖失敗。
         */
        RedisScript<Boolean> script = new DefaultRedisScript<>(
                "if redis.call('SETNX', KEYS[1], ARGV[1]) == 1 then " +
                        "redis.call('PEXPIRE', KEYS[1], ARGV[2]) " +
                        "return true " +
                        "end " +
                        "return false", Boolean.class);

        // 創(chuàng)建一個(gè)包含元素的列表，該元素時(shí)LockKey即為鎖的鍵名
        List<String> keys = Collections.singletonList(lockKey);
        /**
         * 執(zhí)行redis的操作
         * script：之前創(chuàng)建的RedisScript的對(duì)象，用于執(zhí)行Lua腳本
         * keys：Lua腳本中的Keys參數(shù)，即為鍵的數(shù)組，只有一個(gè)鍵，即鎖的鍵名
         * requestId：Lua 腳本中的 ARGV 參數(shù)，即參數(shù)的數(shù)組，傳入了請(qǐng)求 ID，用于標(biāo)識(shí)這次獲取鎖的請(qǐng)求
         * String.valueOf(LOCK_EXPIRE_TIME)：Lua 腳本中的 ARGV 參數(shù)，即參數(shù)的數(shù)組。傳入了鎖的過(guò)期時(shí)間，以毫秒為單位
         */
        Boolean result = redisTemplate.execute(script, keys, requestId, String.valueOf(LOCK_EXPIRE_TIME));

        // 如果 result 不為 null，并且為真（即成功獲取了鎖）
        if (result != null && result) {
            try {
                // 模擬處理邏輯
                Thread.sleep(1000);

                // 檢查是否在防抖時(shí)間內(nèi)有重復(fù)請(qǐng)求
                if (isDuplicateRequest(key)) {
                    return "重復(fù)提交，請(qǐng)稍后再試！";
                }

                // 返回處理結(jié)果
                return "獲取鎖成功！";
            //捕獲可能發(fā)生的線程中斷異常，
            } catch (InterruptedException e) {
                // 將當(dāng)前線程重新標(biāo)記為中斷狀態(tài)
                Thread.currentThread().interrupt();
                return "獲取鎖時(shí)發(fā)生異常：" + e.getMessage();
            } finally {
                // 釋放鎖
                releaseLock(lockKey, requestId);
            }
        } else {
            return "獲取鎖失敗，請(qǐng)稍后再試！";
        }
    }

    /**
     * 防止重復(fù)請(qǐng)求
     * @param key 鍵，即鎖的鍵名
     * @return
     */
    private boolean isDuplicateRequest(String key) {
        // 檢查是否在防抖時(shí)間內(nèi)有重復(fù)請(qǐng)求
        String lastRequestTime = redisTemplate.opsForValue().get("lastRequestTime:" + key); // 獲取上次請(qǐng)求時(shí)間
        long currentTime = System.currentTimeMillis(); // 當(dāng)前時(shí)間戳
        // 如果上次請(qǐng)求時(shí)間不為 null（即 Redis 中存在上次請(qǐng)求時(shí)間），且當(dāng)前時(shí)間距離上次請(qǐng)求時(shí)間小于防抖時(shí)間 DEBOUNCE_TIME（10000L），則認(rèn)為發(fā)生了重復(fù)請(qǐng)求，返回 true。
        if (lastRequestTime != null && currentTime - Long.parseLong(lastRequestTime) < DEBOUNCE_TIME) { // 如果防抖時(shí)間內(nèi)有重復(fù)請(qǐng)求，則返回 true
            return true;
        } else {
            // 如果沒(méi)有發(fā)生重復(fù)請(qǐng)求，則將當(dāng)前時(shí)間戳保存到 Redis 中，作為上次請(qǐng)求時(shí)間。同時(shí)設(shè)置了過(guò)期時(shí)間 DEBOUNCE_TIME（10000L），以毫秒為單位。
            redisTemplate.opsForValue().set("lastRequestTime:" + key, String.valueOf(currentTime), DEBOUNCE_TIME, TimeUnit.MILLISECONDS); // 否則將當(dāng)前時(shí)間作為上次請(qǐng)求時(shí)間并設(shè)置過(guò)期時(shí)間，返回 false
            return false;
        }
    }

    /**
     * 釋放鎖
     * @param lockKey 接受鎖的鍵
     * @param requestId 請(qǐng)求標(biāo)識(shí)作為參數(shù)
     */
    private void releaseLock(String lockKey, String requestId) {
        // 釋放鎖。腳本中的 KEYS[1] 和 ARGV[1] 會(huì)分別被傳入 keys 和 requestId 參數(shù)替換
        String releaseLockScript = "if redis.call('GET', KEYS[1]) == ARGV[1] then " +
                "return redis.call('DEL', KEYS[1]) " +
                "else " +
                "return 0 " +
                "end";
        // 將 Lua 腳本字符串轉(zhuǎn)換為 RedisScript 對(duì)象，指定了返回類型為 Long
        RedisScript<Long> script = new DefaultRedisScript<>(releaseLockScript, Long.class);
        // 創(chuàng)建了一個(gè)包含鎖鍵的列表，作為 Lua 腳本的 KEYS 參數(shù)。
        List<String> keys = Collections.singletonList(lockKey);
        // 執(zhí)行 Lua 腳本，傳入了腳本對(duì)象、鍵列表和請(qǐng)求標(biāo)識(shí)作為參數(shù)，從而釋放了鎖
        redisTemplate.execute(script, keys, requestId);
    }
}