SpringBoot 整合Lock4j 分布式锁深度使用案例讲解

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 + " : 获取到了锁，准备执行业务逻辑");
        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的锁，准备执行业务逻辑");
    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的分布式锁执行器 , 使用curatorframework作为zookeeper客户端，实现锁的获取和释放。
 */
@component
public class myzookeeperlockexecutor extends abstractlockexecutor<interprocessmutex> {
    private final curatorframework curatorframework;
    /**
     * 尝试获取分布式锁
     *
     * @param lockkey 锁的关键字，用于在zookeeper中创建锁节点的路径。
     * @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的自定义锁执行器");
        // 检查curatorframework实例是否已启动
        if (!curatorframeworkstate.started.equals(curatorframework.getstate())) {
            log.warn("instance must be started before calling this method");
            return null;
        }
        // 构建锁节点的路径
        string nodepath = "/curator/lock4j/%s";
        try {
            // 创建interprocessmutex实例，并尝试获取锁
            interprocessmutex mutex = new interprocessmutex(curatorframework, string.format(nodepath, lockkey));
            final boolean locked = mutex.acquire(acquiretimeout, timeunit.milliseconds);
            // 根据获取锁的结果，返回相应的锁实例或null
            return obtainlockinstance(locked, mutex);
        } catch (exception e) {
            // 获取锁过程中发生异常，返回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的自定义锁执行器释放锁");
        try {
            // 直接释放锁
            lockinstance.release();
        } catch (exception e) {
            // 释放锁过程中发生异常，记录日志并返回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的锁，准备执行业务逻辑");
    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模板锁执行器，实现基于redis的分布式锁,使用stringredistemplate和lua脚本实现锁的获取和释放，提高锁操作的原子性
 */
@slf4j
@requiredargsconstructor
@component
public class myredistemplatelockexecutor extends abstractlockexecutor<string> {
    /**
     * 获取锁的lua脚本。
     * 该脚本用于尝试以nx选项设置键值对，实现锁的获取。
     */
    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字符串模板，用于执行redis操作。
     */
    private final stringredistemplate redistemplate;
    /**
     * 尝试获取锁
     * 使用lua脚本在redis中执行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中执行验证和删除操作，以确保只有锁的持有者才能释放锁
     *
     * @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的锁，准备执行业务逻辑");
    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, ".", "", "");
    }
}