一个注解实现分布式锁

RLock lock = redissonClient.getLock(key);
boolean lockSuccess = lock.tryLock(waitTime, timeUnit);
if (lockSuccess) {
    执行业务代码...
} final {
    lock.unlock();
}

@Service
@Slf4j
public class LockService {
    
    /**
     * 使用分布式锁执行给定的操作
     *
     * @param key 锁的键
     * @param waitTime 等待锁的时间
     * @param timeUnit 时间单位
     * @param supplier 执行的操作
     * @param <T> 操作返回的类型
     * @return 操作的结果
     */
    public <T> T executeWithLock(String key, int waitTime, TimeUnit timeUnit, Supplier<T> supplier) {
        RLock lock = redissonClient.getLock(key);
        boolean lockSuccess = lock.tryLock(waitTime, timeUnit);
        AssertUtil.isTrue(lockSuccess, SystemCommonErrorEnum.LOCK_LIMIT);
        try {
            return supplier.get();
        } finally {
            if (lock.isLocked() && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

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

/**
 * 使用分布式锁执行给定操作，默认不重试
 * @param key
 * @param supplier
 * @return {@link T}
 */
public <T> T executeWithLock(String key, Supplier<T> supplier) {
    return executeWithLock(key, -1, TimeUnit.MILLISECONDS, supplier);
}	

/**
 * 分布式锁注解
 * @author Ershi
 * @date 2024/12/08
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RedissonLock {

    /**
     * key的前缀,默认取当前方法的全限定名，除非希望在不同方法上对同一个资源做分布式锁，就自己指定
     *
     * @return key的前缀
     */
    String prefixKey() default "";

    /**
     * 锁的主要key值，使用springEl表达式
     *
     * @return 表达式
     */
    String key();

    /**
     * 等待锁的时间，默认-1，不等待
     *
     * @return 单位秒
     */
    int waitTime() default -1;

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

/**
 * Redisson分布式锁切面类
 *
 * @author Ershi
 * @date 2024/12/08
 */
@Aspect
@Component
@Order(0) // 分布式锁要在事务注解前执行
public class RedissonLockAspect {

    @Autowired
    private LockService lockService;

    /**
     * 为打上@RedissonLock注解的方法启用Redisson分布式锁，并设置key
     *
     * @param joinPoint
     * @return {@link Object}
     */
    @Around("@annotation(com.ershi.hichat.common.common.annotation.RedissonLock)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取被拦截方法的方法对象
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        // 获取方法上的RedissonLock注解
        RedissonLock redissonLock = method.getAnnotation(RedissonLock.class);
        // 确定锁的前缀key：如果注解的prefixKey属性为空，则使用SpEl表达式获取“类名#方法名”；否则使用prefixKey属性值
        String prefix = StrUtil.isBlank(redissonLock.prefixKey()) ? SpElUtils.getMethodKey(method) : redissonLock.prefixKey();//默认方法限定名+注解排名（可能多个）
        // 解析SpEl表达式，获取锁的键值
        String key = SpElUtils.parseMethodArgsSpEl(method, joinPoint.getArgs(), redissonLock.key());
        // 执行拦截方法，加分布式锁
        return lockService.executeWithLockThrows(prefix + ":" + key, redissonLock.waitTime(), redissonLock.timeUnit(), joinPoint::proceed);
    }
}

public <T> T executeWithLockThrows(String key, int waitTime, TimeUnit timeUnit, SupplierThrow<T> supplier) throws Throwable

/**
 * Spring EL表达式解析工具类
 * 提供方法参数解析和方法键获取功能
 * @author Ershi
 * @date 2024/12/08
 */
public class SpElUtils {

    // 使用SpelExpressionParser作为表达式解析器
    private static final ExpressionParser parser = new SpelExpressionParser();
    // 使用DefaultParameterNameDiscoverer来发现参数名
    private static final DefaultParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

    /**
     * 解析SpringEL表达式，动态获取方法指定参数的值
     *
     * @param method 要解析的方法
     * @param args 方法的参数值数组
     * @param spEl SpEL表达式字符串 -> 要获取值的参数名
     * @return 解析后的字符串结果，返回目标参数的值
     */
    public static String parseMethodArgsSpEl(Method method, Object[] args, String spEl) {
        // 解析方法参数名，如果无法解析则使用空数组
        String[] params = Optional.ofNullable(parameterNameDiscoverer.getParameterNames(method)).orElse(new String[]{});
        // 创建标准的EL上下文对象
         EvaluationContext context = new StandardEvaluationContext();
        // 将方法参数名-参数值绑定到EL上下文中
        for (int i = 0; i < params.length; i++) {
            context.setVariable(params[i], args[i]);
        }
        // 解析SpEL表达式
        Expression expression = parser.parseExpression(spEl);
        // 返回表达式解析结果
        return expression.getValue(context, String.class);
    }

    /**
     * 生成方法的唯一键
     *
     * @param method 方法对象
     * @return 方法的唯一键，格式为：类名#方法名
     */
    public static String getMethodKey(Method method) {
        // 拼接方法所属类和方法名作为方法键
        return method.getDeclaringClass() + "#" + method.getName();
    }
}

@RedissonLock(key = "#idempotentId", waitTime = 5000)