一个注解实现分布式锁

1、原始写法

我们平常使用redisson的分布式锁是怎么做的?

是不是基本都用的这个模板,既然是模板,那为何不把他抽出来呢?

// 尝试加锁,最多等待100秒,上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...业务代码
   } finally {
       lock.unlock();
   }
}

2、抽出分布式锁工具类

我们可以抽出一个LockService方法,把锁的模板写在方法里,调用的时候只需要指定key,把锁内的代码块用supplier函数传进来

@Service
@Slf4j
public class LockService {

    @Autowired
    private RedissonClient redissonClient;

    public <T> T executeWithLock(String key, int waitTime, TimeUnit unit, SupplierThrow<T> supplier) throws Throwable {
        RLock lock = redissonClient.getLock(key);
        boolean lockSuccess = lock.tryLock(waitTime, unit);
        if (!lockSuccess) {
            throw new BusinessException(CommonErrorEnum.LOCK_LIMIT);
        }
        try {
            return supplier.get();//执行锁内的代码逻辑
        } finally {
            lock.unlock();
        }
    }
}

使用起来就方便了

lockService.executeWithLock(key, 10, TimeUnit.SECONDS, ()->{
            //执行业务逻辑
            。。。。。
            return null;
});

如果我们不需要排队等锁,甚至还能重载方法减少两个参数。

lockService.executeWithLock(key, ()->{
            //执行业务逻辑
            。。。。。
            return null;
});

还能不能更简便呢?当然!

3、注解实现分布式锁

其实锁工具类已经是核心功能代码了,用注解只是为了使用方便。就像很多底层sdk,都是有接口调用的方法来实现核心功能,然后再加个注解让使用更加简便。

来想一想场景,我们的分布式锁很多时候都是加在最外层,也就是controller上,或者是service某个方法上。

我们通常加锁需要的key,都是由入参组装的。那是不是可以用el表达式来组装key呢?

1. 创建注解@RedissonLock

/**
 * 分布式锁注解
 */
@Retention(RetentionPolicy.RUNTIME)//运行时生效
@Target(ElementType.METHOD)//作用在方法上
public @interface RedissonLock {
    /**
     * key的前缀,默认取方法全限定名,除非我们在不同方法上对同一个资源做分布式锁,就自己指定
     *
     * @return key的前缀
     */
    String prefixKey() default "";

    /**
     * springEl 表达式
     *
     * @return 表达式
     */
    String key();

    /**
     * 等待锁的时间,默认-1,不等待直接失败,redisson默认也是-1
     *
     * @return 单位秒
     */
    int waitTime() default -1;

    /**
     * 等待锁的时间单位,默认毫秒
     *
     * @return 单位
     */
    TimeUnit unit() default TimeUnit.MILLISECONDS;

}

约定大于配置的思想,我们的大多数参数都是可以默认的。

很多时候我们的锁都是针对方法的,要锁同一处地方,调用同一个方法就好了,这样前缀可以直接默认根据类+方法名来实现,同样针对特例我们也提供了自己指定前缀的入口。

2. 实现切面RedissonLockAspect

@Slf4j
@Aspect
@Component
@Order(0)//确保比事务注解先执行,分布式锁在事务外
public class RedissonLockAspect {
    @Autowired
    private LockService lockService;

    @Around("@annotation(com.annotation.RedissonLock)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        RedissonLock redissonLock = method.getAnnotation(RedissonLock.class);
        String prefix = StrUtil.isBlank(redissonLock.prefixKey()) ? SpElUtils.getMethodKey(method) : redissonLock.prefixKey();//默认方法限定名+注解排名(可能多个)
        String key = SpElUtils.parseSpEl(method, joinPoint.getArgs(), redissonLock.key());
        return lockService.executeWithLockThrows(prefix + ":" + key, redissonLock.waitTime(), redissonLock.unit(), joinPoint::proceed);
    }
}

切面其实很简单,构建key=前缀+el表达式,然后把参数都传进去,调用我们核心功能的工具类LockService

3. 使用

一个注解实现分布式锁_第1张图片

使用起来就非常方便了,发奖的时候,我们需要对uid加锁,直接一个注解搞定。如果需要等待,再加个等待时间就行。

这里需要注意,分布式锁要在事务外层。所以我们锁的切面优先级要高一些。

4. 优化的思考

有的时候,key是由两个参数组成的,比如

@RedissonLock(key = "#uid+'_'+#itemId")
public void acquireItem(Long uid, Long itemId, String businessId) {
    //...
}

自己在el里面拼接就比较不方便。怎么去优化呢?,可以设置key为一个el表达式数组,给传多个参数就行了。

一个注解实现分布式锁_第2张图片

@RedissonLock(key = {"#uid","#itemId"})
public void acquireItem(Long uid, Long itemId, String businessId) {
    //...
}

.(img-74yJqLyy-1703751249954)]

@RedissonLock(key = {"#uid","#itemId"})
public void acquireItem(Long uid, Long itemId, String businessId) {
    //...
}

由切面的代码去拼接两个key。项目目前没用到两个参数,等之后使用到,就会考虑加上该优化。很多代码没必要一步到位,要在迭代中保持小重构的意识。

你可能感兴趣的:(Java,Redis,redis,java)