Aspect切面实现Redisson的Lock和TryLock

 

Aspect切面是一种编程范式，主要用于在程序中横切关注点（cross-cutting concerns），例如日志、事务管理、权限控制等。在Java中，AspectJ是一个常用的实现Aspect切面的工具。

Redisson是一个用于在Java中操作Redis的框架，提供了一些分布式锁的功能。在分布式系统中，锁的管理变得更加复杂，需要考虑多个节点之间的同步。Aspect切面可以用于在代码中以一种优雅的方式实现对Redisson分布式锁的切面功能。

1. 代码解耦： AOP允许将横切关注点（如分布式锁的获取和释放）从核心业务逻辑中解耦。这样，业务代码可以保持简洁，不必包含与分布式锁相关的详细实现。

2. 可维护性提高： 通过AOP，可以将分布式锁的管理逻辑集中在一个切面中，而不是分散在业务代码中。这有助于提高代码的可维护性，因为所有与锁相关的逻辑都在同一个地方进行管理。

3. 可重用性增强： AOP切面可以在多个业务模块中重用，而不需要在每个模块中重复实现相同的锁管理逻辑。这有助于避免复制粘贴代码，提高代码的可重用性。

4. 集中式管理锁策略： AOP允许在一个地方定义锁的获取和释放策略，使得对分布式锁的管理更加集中。这有助于确保在整个应用程序中使用一致的锁策略，避免出现不一致的情况。

5. 易于维护和修改： 当需要修改锁管理逻辑时，只需在AOP切面中进行修改，而不必修改业务代码。这降低了引入错误的风险，并简化了对锁逻辑的维护。

6. 透明的锁管理： 通过AOP，锁的获取和释放可以在业务代码中变得透明。业务逻辑不需要关心锁的具体实现，从而使业务代码更加清晰和易于理解。

总体而言，使用AOP实现Redisson的Lock和TryLock可以提高代码的可读性、可维护性，并降低引入错误的风险。这种方式使得分布式锁的管理变得更加优雅和集中化。

通过注解实现分布式锁可以避免事务未提交锁就已经释放了，通过注解切面可以减少代码量。

1、RedissonLock注解类

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

/**
 * RedissonLock锁
 * @date 2023/6/28 15:49
 * @author luohao
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedissonLock {
    /**
     * key（SpEL表达式）
     * @return
     */
    String key() default "";

    /**
     * 失效时间（默认-1启动看门狗机制）
     * @return
     */
    long leaseTime() default -1;

    /**
     * 时间单位（默认秒）
     * @return
     */
    TimeUnit unit() default TimeUnit.SECONDS;
}

2、RedissonTryLock注解类

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

/**
 * RedissonTryLock锁
 * @date 2023/6/28 15:49
 * @author luohao
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedissonTryLock {
    /**
     * key（SpEL表达式）
     * @return
     */
    String key() default "";

    /**
     * 等待时间（默认-1不等待）
     * @return
     */
    long waitTime() default -1;

    /**
     * 失效时间（默认-1启动看门狗机制）
     * @return
     */
    long leaseTime() default -1;

    /**
     * 时间单位（默认秒）
     * @return
     */
    TimeUnit unit() default TimeUnit.SECONDS;

    /**
     * 错误提示信息（没有获取到锁）
     * @return
     */
    String message() default ErrorMessageConstants.REDISSON_TRY_LOCK_ERROR;
}

3、RedissonAspect切面类

import com.scm.boss.common.annotation.RedissonLock;
import com.scm.boss.common.annotation.RedissonTryLock;
import com.scm.boss.common.exception.ApiException;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import org.springframework.expression.Expression;
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 javax.annotation.Resource;
import java.lang.reflect.Method;

/**
 * Redisson锁
 * @date 2023/6/28 16:27
 * @author luohao
 */
@Aspect
@Component
@Order(-1)
public class RedissonAspect {

    @Value("${spring.application.name}")
    private String appName;

    @Resource
    private RedissonClient redissonClient;

    @Around("@annotation(com.scm.boss.common.annotation.RedissonLock)")
    public Object aroundLock(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        RedissonLock redissonLock = method.getAnnotation(RedissonLock.class);
        String key = getKey(point, signature, redissonLock.key());
        String strClassName = point.getTarget().getClass().getName();
        String strMethodName = point.getSignature().getName();
        RLock lock = redissonClient.getLock(appName+":"+strClassName+":"+strMethodName+":"+key);
        try {
            lock.lock(redissonLock.leaseTime(),redissonLock.unit());
            return point.proceed();
        } finally {
            lock.unlock();
        }
    }

    @Around("@annotation(com.scm.boss.common.annotation.RedissonTryLock)")
    public Object aroundTryLock(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        RedissonTryLock redissonTryLock = method.getAnnotation(RedissonTryLock.class);
        String key = getKey(point, signature, redissonTryLock.key());
        String strClassName = point.getTarget().getClass().getName();
        String strMethodName = point.getSignature().getName();
        RLock lock = redissonClient.getLock(appName+":"+strClassName+":"+strMethodName+":"+key);
        try {
            boolean tryLock = lock.tryLock(redissonTryLock.waitTime(), redissonTryLock.leaseTime(), redissonTryLock.unit());
            if(!tryLock){
                throw new ApiException(redissonTryLock.message());
            }
            return point.proceed();
        } finally {
            lock.unlock();
        }
    }

    /**
     * SpEL表达式获取参数
     * @param point
     * @param signature
     * @param key
     * @return
     */
    private static String getKey(ProceedingJoinPoint point, MethodSignature signature, String key) {
        String[] parameterNames = signature.getParameterNames();
        Object[] args = point.getArgs();
        try {
            ExpressionParser parser = new SpelExpressionParser();
            Expression expression = parser.parseExpression(key);
            StandardEvaluationContext ctx = new StandardEvaluationContext();
            for (int i = 0; i < parameterNames.length; i++) {
                ctx.setVariable(parameterNames[i], args[i]);
            }
            return expression.getValue(ctx).toString();
        }catch (Exception e){
            return key;
        }
    }
}