server:
  port: 8082
lock4j:
  type: redis
  acquire-timeout: 3000  # 獲取鎖超時時間(毫秒)
  expire: 30000   # 鎖過期時間(毫秒)
  retry-interval: 100  # 獲取鎖失敗重試間隔(毫秒)
  #redis的鏈接配置信息
  redis:
    host: localhost
    database: 1
    port: 6379

package com.congge.web;
import com.baomidou.lock.annotation.Lock4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class LockController {
    //localhost:8082/testLock
    @Lock4j(keys = {"#key"}, acquireTimeout = 1000, expire = 10000)
    @GetMapping("/testLock")
    public Object testLock(){
        long threadId = Thread.currentThread().getId();
        System.out.println(threadId + " : 獲取到了鎖，準備執(zhí)行業(yè)務邏輯");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return "testLock";
    }
}

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>lock4j-zookeeper-spring-boot-starter</artifactId>
    <version>2.2.5</version>
</dependency>

#使用redis作為分布式鎖
spring:
  coordinate:
    zookeeper:
      zkServers: 127.0.0.1:2181

//localhost:8082/testZkLock
@Lock4j(keys = {"#key"}, acquireTimeout = 1000, expire = 10000, executor = ZookeeperLockExecutor.class)
@GetMapping("/testZkLock")
public Object testZkLock(){
    long threadId = Thread.currentThread().getId();
    System.out.println(threadId + " : 獲取到了zk的鎖，準備執(zhí)行業(yè)務邏輯");
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return "testLock";
}

package com.congge.config;
import com.baomidou.lock.executor.AbstractLockExecutor;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.imps.CuratorFrameworkState;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@Slf4j
@RequiredArgsConstructor
/**
 * 基于zk的分布式鎖執(zhí)行器 , 使用CuratorFramework作為ZooKeeper客戶端，實現(xiàn)鎖的獲取和釋放。
 */
@Component
public class MyZookeeperLockExecutor extends AbstractLockExecutor<InterProcessMutex> {
    private final CuratorFramework curatorFramework;
    /**
     * 嘗試獲取分布式鎖
     *
     * @param lockKey 鎖的關鍵字，用于在ZooKeeper中創(chuàng)建鎖節(jié)點的路徑。
     * @param lockValue 鎖的值，可以用于進一步標識鎖。
     * @param expire 鎖的過期時間，未使用。
     * @param acquireTimeout 獲取鎖的超時時間。
     * @return 如果成功獲取鎖，返回InterProcessMutex實例；否則返回null。
     */
    @Override
    public InterProcessMutex acquire(String lockKey, String lockValue, long expire, long acquireTimeout) {
        System.out.println("進入了zk的自定義鎖執(zhí)行器");
        // 檢查CuratorFramework實例是否已啟動
        if (!CuratorFrameworkState.STARTED.equals(curatorFramework.getState())) {
            log.warn("instance must be started before calling this method");
            return null;
        }
        // 構建鎖節(jié)點的路徑
        String nodePath = "/curator/lock4j/%s";
        try {
            // 創(chuàng)建InterProcessMutex實例，并嘗試獲取鎖
            InterProcessMutex mutex = new InterProcessMutex(curatorFramework, String.format(nodePath, lockKey));
            final boolean locked = mutex.acquire(acquireTimeout, TimeUnit.MILLISECONDS);
            // 根據(jù)獲取鎖的結果，返回相應的鎖實例或null
            return obtainLockInstance(locked, mutex);
        } catch (Exception e) {
            // 獲取鎖過程中發(fā)生異常，返回null
            return null;
        }
    }
    /**
     * 釋放分布式鎖。
     *
     * @param key 鎖的關鍵字，與獲取鎖時使用的key相同。
     * @param value 鎖的值，與獲取鎖時使用的value相同。
     * @param lockInstance 鎖實例，用于釋放鎖。
     * @return 如果成功釋放鎖，返回true；否則返回false。
     */
    @Override
    public boolean releaseLock(String key, String value, InterProcessMutex lockInstance) {
        System.out.println("進入了zk的自定義鎖執(zhí)行器釋放鎖");
        try {
            // 直接釋放鎖
            lockInstance.release();
        } catch (Exception e) {
            // 釋放鎖過程中發(fā)生異常，記錄日志并返回false
            log.warn("zookeeper lock release error", e);
            return false;
        }
        // 成功釋放鎖，返回true
        return true;
    }
}

//localhost:8082/testZkLock
//@Lock4j(keys = {"#key"}, acquireTimeout = 1000, expire = 10000, executor = ZookeeperLockExecutor.class)
@Lock4j(keys = {"#key"}, acquireTimeout = 1000, expire = 10000, executor  = MyZookeeperLockExecutor.class)
@GetMapping("/testZkLock")
public Object testZkLock(){
    long threadId = Thread.currentThread().getId();
    System.out.println(threadId + " : 獲取到了zk的鎖，準備執(zhí)行業(yè)務邏輯");
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return "testLock";
}

package com.congge.config;
import com.baomidou.lock.executor.AbstractLockExecutor;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;
import java.util.Collections;
/**
 * Redis模板鎖執(zhí)行器，實現(xiàn)基于Redis的分布式鎖,使用StringRedisTemplate和Lua腳本實現(xiàn)鎖的獲取和釋放，提高鎖操作的原子性
 */
@Slf4j
@RequiredArgsConstructor
@Component
public class MyRedisTemplateLockExecutor extends AbstractLockExecutor<String> {
    /**
     * 獲取鎖的Lua腳本。
     * 該腳本用于嘗試以NX選項設置鍵值對，實現(xiàn)鎖的獲取。
     */
    private static final RedisScript<String> SCRIPT_LOCK = new DefaultRedisScript<>("return redis.call('set',KEYS[1]," +
            "ARGV[1],'NX','PX',ARGV[2])", String.class);
    /**
     * 釋放鎖的Lua腳本
     * 首先驗證鎖是否由當前持有者釋放，如果是，則刪除鎖
     */
    private static final RedisScript<String> SCRIPT_UNLOCK = new DefaultRedisScript<>(
            "if redis.call('get',KEYS[1]) " +
            "== ARGV[1] then return tostring(redis.call('del', KEYS[1])==1) else return 'false' end",
            String.class);
    /**
     * 表示鎖獲取成功的固定字符串。
     */
    private static final String LOCK_SUCCESS = "OK";
    /**
     * Redis字符串模板，用于執(zhí)行Redis操作。
     */
    private final StringRedisTemplate redisTemplate;
    /**
     * 嘗試獲取鎖
     * 使用Lua腳本在Redis中執(zhí)行SET命令，嘗試獲取鎖
     *
     * @param lockKey        鍵
     * @param lockValue      值，唯一的標識
     * @param expire         鎖的期時間，單位為毫秒
     * @param acquireTimeout 獲取鎖的超時時間，單位為毫秒
     * @return 一個表示鎖實例的字符串，如果獲取鎖失敗，則為null
     */
    @Override
    public String acquire(String lockKey, String lockValue, long expire, long acquireTimeout) {
        System.out.println("嘗試獲取redis的鎖");
        String lock = redisTemplate.execute(SCRIPT_LOCK,
                redisTemplate.getStringSerializer(),
                redisTemplate.getStringSerializer(),
                Collections.singletonList(lockKey),
                lockValue, String.valueOf(expire));
        final boolean locked = LOCK_SUCCESS.equals(lock);
        return obtainLockInstance(locked, lock);
    }
    /**
     * 釋放鎖
     * 使用Lua腳本在Redis中執(zhí)行驗證和刪除操作，以確保只有鎖的持有者才能釋放鎖
     *
     * @param key          鍵
     * @param value        值，用于驗證鎖的所有權。
     * @param lockInstance 表示鎖實例的字符串
     * @return 表示釋放鎖是否成功的布爾值
     */
    @Override
    public boolean releaseLock(String key, String value, String lockInstance) {
        System.out.println("釋放鎖");
        String releaseResult = redisTemplate.execute(SCRIPT_UNLOCK,
                redisTemplate.getStringSerializer(),
                redisTemplate.getStringSerializer(),
                Collections.singletonList(key), value);
        return Boolean.parseBoolean(releaseResult);
    }
}

//localhost:8082/testRedisLock
@Lock4j(keys = {"#key"}, acquireTimeout = 1000, expire = 10000, executor  = MyRedisTemplateLockExecutor.class)
@GetMapping("/testRedisLock")
public Object testRedisLock(){
    long threadId = Thread.currentThread().getId();
    System.out.println(threadId + " : 獲取到了redis的鎖，準備執(zhí)行業(yè)務邏輯");
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return "testLock";
}

package com.congge.config;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import com.baomidou.lock.LockKeyBuilder;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.expression.BeanFactoryResolver;
import org.springframework.context.expression.MethodBasedEvaluationContext;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.expression.BeanResolver;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
@Component
public class DefaultLockKeyBuilder implements LockKeyBuilder {
    private static final ParameterNameDiscoverer NAME_DISCOVERER = new DefaultParameterNameDiscoverer();
    private static final ExpressionParser PARSER = new SpelExpressionParser();
    private BeanResolver beanResolver;
    public DefaultLockKeyBuilder(BeanFactory beanFactory) {
        this.beanResolver = new BeanFactoryResolver(beanFactory);
    }
    public String buildKey(MethodInvocation invocation, String[] definitionKeys) {
        System.out.println("開始構建自定義的key");
        Method method = invocation.getMethod();
        return definitionKeys.length <= 1 && "".equals(definitionKeys[0]) ? "" : this.getSpelDefinitionKey(definitionKeys, method, invocation.getArguments());
    }
    protected String getSpelDefinitionKey(String[] definitionKeys, Method method, Object[] parameterValues) {
        StandardEvaluationContext context = new MethodBasedEvaluationContext((Object)null, method, parameterValues, NAME_DISCOVERER);
        context.setBeanResolver(this.beanResolver);
        List<String> definitionKeyList = new ArrayList(definitionKeys.length);
        String[] var6 = definitionKeys;
        int var7 = definitionKeys.length;
        for(int var8 = 0; var8 < var7; ++var8) {
            String definitionKey = var6[var8];
            if (definitionKey != null && !definitionKey.isEmpty()) {
                String key = (String)PARSER.parseExpression(definitionKey).getValue(context, String.class);
                definitionKeyList.add(key);
            }
        }
        return StringUtils.collectionToDelimitedString(definitionKeyList, ".", "", "");
    }
}