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

server:
  port: 8080
spring:
  redis:
    host: xxx.xxx.xxx.xxx
    port: 6379
    password: xxxxxx

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class DistributedLock {

    private final StringRedisTemplate redisTemplate;

    // 通過構(gòu)造函數(shù)注入 StringRedisTemplate
    public DistributedLock(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 嘗試獲取分布式鎖
     *
     * @param lockKey    鎖的鍵
     * @param requestId  請(qǐng)求標(biāo)識(shí)，用于區(qū)分不同的鎖持有者
     * @param expireTime 鎖的過期時(shí)間，單位為毫秒
     * @return 如果成功獲取鎖，返回 true；否則返回 false
     */
    public boolean acquireLock(String lockKey, String requestId, long expireTime) {
        // 使用 setIfAbsent 方法嘗試設(shè)置鍵值對(duì)，如果鍵不存在則設(shè)置成功并返回 true，否則返回 false
        Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, expireTime, TimeUnit.MILLISECONDS);
        return result != null && result;
    }

    /**
     * 釋放分布式鎖
     *
     * @param lockKey   鎖的鍵
     * @param requestId 請(qǐng)求標(biāo)識(shí)，用于確保只有鎖的持有者才能釋放鎖
     * @return 如果成功釋放鎖，返回 true；否則返回 false
     */
    public boolean releaseLock(String lockKey, String requestId) {
        // 獲取當(dāng)前鎖的值
        String currentValue = redisTemplate.opsForValue().get(lockKey);
        // 檢查當(dāng)前鎖的值是否等于請(qǐng)求標(biāo)識(shí)，確保只有鎖的持有者才能釋放鎖
        if (currentValue != null && currentValue.equals(requestId)) {
            // 刪除鎖鍵
            return redisTemplate.delete(lockKey);
        }
        return false;
    }
}

import com.wh.demo01.demos.web.utils.DistributedLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
public class MyRedisService {

    private final DistributedLock distributedLock;

    // 通過構(gòu)造函數(shù)注入 DistributedLock
    @Autowired
    public MyRedisService(DistributedLock distributedLock) {
        this.distributedLock = distributedLock;
    }

    /**
     * 模擬需要同步執(zhí)行的方法
     */
    public void someMethod() {
        String lockKey = "myLockKey";
        String requestId = "uniqueRequestId";
        long expireTime = 10000; // 10 seconds

        try {
            // 嘗試獲取鎖
            if (distributedLock.acquireLock(lockKey, requestId, expireTime)) {
                // 獲取到鎖，執(zhí)行需要同步的操作
                System.out.println(new Date() + "獲取鎖成功");
                // 模擬業(yè)務(wù)操作
                Thread.sleep(5000);
            } else {
                System.out.println(new Date() + "獲取鎖失敗");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            // 確保鎖在操作完成后被釋放
            distributedLock.releaseLock(lockKey, requestId);
        }
    }
}

import com.wh.demo01.demos.web.service.MyRedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/redis")
public class RedisController {

    @Autowired
    private MyRedisService service;

    @GetMapping("/test")
    public void TestRedis(){
        service.someMethod();
    }
}