Lock4j支持Redisson，RedisTemplate，zookeeper。

 在ruoyi-common-redis模块的pom中可以看到本项目中使用的方式是基于redssion的,redission支持的锁很多，lock4j继承了其中的可重入锁:

在application-common.yml中可以看到lock4j的全局配置：

acquire-timeout：获取分布式锁超时时间，默认为 3000 毫秒

expire: 分布式锁的超时时间，默认为 30 秒 

获取锁超时：比如发生死锁时，防止其他线程长时间等待。

分布式锁的超时时间：发生网络抖动（释放锁的一瞬断网了）以及Redis宕机。通常Ression自带的看门狗功能会自动审视过期时间内程序是否执行完。

通过默认配置，我们可以仅通过一个@Lock4j注解来实现分布式锁：

SysTenantController#add

demo中有一个专门用于测试锁的controller类：RedisLockController

里面分别介绍了两种lock4j的使用方式：注解的使用与LockTemplate的使用，原理和执行过程是一样的，前者方便，后者灵活，都是通过传递一个Key作为锁,只要Key一致，则表示为一把锁，需要竞争。

package org.dromara.demo.controller;

import com.baomidou.lock.LockInfo;
import com.baomidou.lock.LockTemplate;
import com.baomidou.lock.annotation.Lock4j;
import com.baomidou.lock.executor.RedissonLockExecutor;
import org.dromara.common.core.domain.R;
import lombok.extern.slf4j.Slf4j;
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;

import java.time.LocalTime;


/**
 * 测试分布式锁的样例
 *
 * @author shenxinquan
 */
@Slf4j
@RestController
@RequestMapping("/redisLock")
public class RedisLockController {

    @Autowired
    private LockTemplate lockTemplate;

    /**
     * 测试lock4j 注解
     * acquireTimeout:获取分布式锁超时时间，默认为 3000 毫秒
     * expire:分布式锁的超时时间
     */
    @Lock4j(keys = {"#key"},acquireTimeout = 5000L,expire = 30000L)
    @GetMapping("/testLock4j")
    public R<String> testLock4j(String key, String value) {
        System.out.println("start:" + key + ",time:" + LocalTime.now());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end :" + key + ",time:" + LocalTime.now());
        return R.ok("操作成功", value);
    }

    /**
     * 测试lock4j 工具
     */
    @GetMapping("/testLock4jLockTemplate")
    public R<String> testLock4jLockTemplate(String key, String value) {
        final LockInfo lockInfo = lockTemplate.lock(key, 30000L, 5000L, RedissonLockExecutor.class);
        if (null == lockInfo) {
            throw new RuntimeException("业务处理中,请稍后再试");
        }
        // 获取锁成功，处理业务
        try {
            try {
                Thread.sleep(8000);
            } catch (InterruptedException e) {
                //
            }
            System.out.println("执行简单方法1 , 当前线程:" + Thread.currentThread().getName());
        } finally {
            //释放锁
            lockTemplate.releaseLock(lockInfo);
        }
        //结束
        return R.ok("操作成功", value);
    }

}

可以在GlobalExceptionHandler中配置获取锁超时的异常处理

@ExceptionHandler(DemoModeException.class)
    public R<Void> handleLockException(LockFailureException e) {
        return R.fail("获取锁失败");
    }

也可以参考lock4j源码中提供的案例实现：

package org.dromara.demo.exception;

import com.baomidou.lock.LockFailureStrategy;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.exception.ServiceException;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 自定义获取锁异常处理
 *
 * @author zengzhihong
 */
@Slf4j
@Component
public class CustomLockFailureStrategy implements LockFailureStrategy {

    @Override
    public void onLockFailure(String key, Method method, Object[] arguments) {
        log.error("获取锁失败了,key={},method={},arguments={}", key, method, arguments);
        // 此处可以抛出指定异常，配合全局异常拦截包装统一格式返回给调用端
        throw new ServiceException("请求太快啦~");
    }
}