【Redisson分布式锁】基于redisson的分布式锁

redisson分布式锁
maven文件：

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.15.3</version>
        </dependency>

实现代码：
分布式锁对象参数（DistributedLock）：

import lombok.Data;

import java.util.concurrent.TimeUnit;

/**
 * 分布式锁对象参数
 */
@Data
public class DistributedLock {
    /**
     * 锁用的key
     */
    private String lockKey;
    /**
     * 等待(尝试)时间，默认3秒
     */
    private long waitTime=3;
    /**
     *加锁的时间,默认20秒
     */
    private long lockTime=20;
    /**
     * 时间单位:默认秒
     */
    private TimeUnit timeUnit= TimeUnit.SECONDS;
}

配置：LockAutoConfig

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.xxx.commons.rlockstater")
public class LockAutoConfig {
    @Bean
    public DistributedLockService distributedLockService(){
        return new DistributedLockServiceImpl();
    }
}

DistributedLockService

import org.redisson.api.RLock;

public interface DistributedLockService {

    /**
     * 获取锁
     * @param distributedLock 分布式锁对象参数
     * @return boolean
     */
    public boolean tryLock(DistributedLock distributedLock);

    /**
     * 解(释放)锁
     * @param distributedLock 分布式锁对象参数
     */
    public void unlock(DistributedLock distributedLock);
    /**
     * 解(释放)锁
     * @param lockKey 锁的key值
     */
    public void unlock(String lockKey);

    /**
     * 解(释放)锁
     * @param lock 锁对象
     */
    public void unlock(RLock lock);
}

实现：
DistributedLockServiceImpl：

import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;

@Slf4j
public class DistributedLockServiceImpl implements DistributedLockService {
    /**
     * 默认的LockKey前缀
     */
    private static final String LOCK_KEY_PREFIX = "tincere:rlock";
    private RedissonClient redissonClient;

    @Autowired
    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public boolean tryLock(DistributedLock distributedLock) {
        try {
            RLock lock = redissonClient.getLock(LOCK_KEY_PREFIX + distributedLock.getLockKey());
            return lock.tryLock(distributedLock.getWaitTime(), distributedLock.getLockTime(), distributedLock.getTimeUnit());
        } catch (Exception e) {
            log.error("获取分布式锁异常", e);
        }
        return false;
    }

    @Override
    public void unlock(DistributedLock distributedLock) {
        RLock lock = redissonClient.getLock(LOCK_KEY_PREFIX + distributedLock.getLockKey());
        unlock(lock);
    }

    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(LOCK_KEY_PREFIX + lockKey);
        unlock(lock);
    }

    @Override
    public void unlock(RLock lock) {
        if(!lock.isLocked()||!lock.isHeldByCurrentThread()){
            log.error("当前Key{}不存在或者不是当前线程持有",lock.getName());
            return;
        }
        lock.unlock();
    }
}