封装redis分布式锁

封装redis分布式锁

import com.yonghui.core.exception.RRException;
import com.yonghui.yh.rme.srm.common.enums.BizError;
import com.yonghui.yh.rme.srm.common.util.CheckUtils;
import lombok.extern.slf4j.Slf4j;
import org.redisson.RedissonMultiLock;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * 分布式锁
 */
@Component
@Slf4j
public class RedisDistributeLock {

    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private TransactionTemplate transactionTemplate;


    private static final String CACHE_LOCK= "yh:suppliercenter:view:";

    /**
     * 默认等待续期锁
     * @param lockKey 锁key
     * @param t 参数
     * @param function 任务
     * @param <T> 任务参数
     * @param <R> 任务返回值
     * @return 
     */
    public <T, R> R lock(String lockKey, T t, Function<T, R> function) {
        CheckUtils.isBlank(lockKey, BizError.REDIS_KEY_NOT_NULL);
        RLock lock = redissonClient.getLock(lockKey);
        try {
            log.error("DistributeLock process Lock already exists! lockKey = {}", lockKey);
            CheckUtils.isTrue(!lock.tryLock(), BizError.REDIS_CACHE_LOCKED);
            return function.apply(t);
        } finally {
            if (lock.isHeldByCurrentThread()) {  //如果当前线程占用锁，则释放锁
                lock.unlock(); // 释放锁
            }
        }
    }

    /**
     * 无等待续期锁
     * @param lockKey 锁key
     * @param t 参数
     * @param function 任务
     * @param <T> 任务参数
     * @param <R> 任务返回值
     * @return
     */
    public <T, R> R lockNoWait(String lockKey, T t, Function<T, R> function) {
        CheckUtils.isBlank(lockKey, BizError.REDIS_KEY_NOT_NULL);
        RLock lock = redissonClient.getLock(lockKey);
        try {
            log.error("DistributeLock process Lock already exists! lockKey = {}", lockKey);
            CheckUtils.isTrue(!lock.tryLock(-1, TimeUnit.MILLISECONDS), BizError.REDIS_CACHE_LOCKED);
            return function.apply(t);
        } catch (InterruptedException e) {
            e.printStackTrace();
            throw new RRException(BizError.REDIS_ERROR_LOCKED);
        }finally {
            if (lock.isHeldByCurrentThread()) {  //如果当前线程占用锁，则释放锁
                lock.unlock(); // 释放锁
            }
        }
    }
    
    /**
     * 联锁
     * @param lockKeys 锁key
     * @param t 参数
     * @param function 任务
     * @param <T> 任务参数
     * @param <R> 任务返回值
     * @return
     */
    public <T, R> R multiLock(List<String> lockKeys, T t, Function<T, R> function) {
        CheckUtils.isEmpty(lockKeys, BizError.REDIS_KEY_NOT_NULL);
        List<RLock> locks = lockKeys.stream().map(o -> {
            RLock rLock = redissonClient.getLock(o);
            return rLock;
        }).collect(Collectors.toList());
        RLock[] rLocks = locks.toArray(new RLock[locks.size()]);
        RedissonMultiLock lock = new RedissonMultiLock(rLocks);
        try {
            log.error("DistributeLock process Lock already exists! lockKey = {}", lockKeys);
            CheckUtils.isTrue(!lock.tryLock(), BizError.REDIS_CACHE_LOCKED);
            return function.apply(t);
        } finally {
            lock.unlock(); // 释放锁
        }
    }
    
    /**
     * 供给型锁
     * @param lockKey 锁key
     * @param supplier 任务
     * @param <R> 任务返回值
     * @return
     */
    public <R> R lockSupplier(String lockKey, Supplier<R> supplier) {
        CheckUtils.isBlank(lockKey, BizError.REDIS_KEY_NOT_NULL);
        RLock lock = redissonClient.getLock(CACHE_LOCK + lockKey);
        try {
            log.error("DistributeLock process Lock already exists! lockKey = {}", lockKey);
            CheckUtils.isTrue(!lock.tryLock(), BizError.REDIS_CACHE_LOCKED);
            return supplier.get();
        } finally {
            if (lock.isHeldByCurrentThread()) {  //如果当前线程占用锁，则释放锁
                lock.unlock(); // 释放锁
            }
        }
    }

    /**
     * 加锁并且执行时带上事务
     * @param lockKey 锁key
     * @param t 参数
     * @param function 任务
     * @param <T> 任务参数
     * @param <R> 任务返回值
     * @return
     */
    public <T, R> R lockTransaction(String lockKey, T t, Function<T, R> function) {
        CheckUtils.isBlank(lockKey, BizError.REDIS_KEY_NOT_NULL);
        RLock lock = redissonClient.getLock(CACHE_LOCK +lockKey);
        try {
            log.error("DistributeLock process Lock already exists! lockKey = {}", lockKey);
            CheckUtils.isTrue(!lock.tryLock(), BizError.REDIS_CACHE_LOCKED);
            return transactionTemplate.execute(status -> {
                return function.apply(t);
            });
        } finally {
            if (lock.isHeldByCurrentThread()) {  //如果当前线程占用锁，则释放锁
                lock.unlock(); // 释放锁
            }
        }
    }
}