超越@Transactional！自定义@DistributedLock注解深度实战

原创 于 2025-11-06 17:39:23 发布 · 947 阅读 · 27 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redis #redisson #aop #spring #spring boot #spring cloud #aspect

目录

种一棵树最好的时间是10年前，其次就是现在，加油！
                                                                                   --by蜡笔小柯南

还在每个方法里重复写着 RLock lock = redissonClient.getLock(key) 这样的模板代码吗？不仅繁琐，还容易忘记释放锁导致死锁。

想象一下，如果能像使用@Transactional一样简单地使用分布式锁，会是怎样的体验？本文将带你实现功能更强大的@DistributeLock注解，支持SpEL表达式等高级特性！

依赖导入

需要导入Redisson、Aspect 等依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.20.1</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.21</version>
        </dependency>

自定义注解

创建DistributeLock注解，并配置此注解可以使用的范围，@Target和@Retention是Java中的元注解， @Target说明了注解所能使用的范围，即注解可以用在哪些地方，@Retention用于描述注解的生命周期，即注解在什么范围内有效。

  • @Target: 表示注解可以用在哪里

    • ElementType.METHOD： 方法声明，表示用在方法上
    • ElementType.TYPE：用于类、接口（包括注解接口）、枚举或记录声明
    • ElementType.FIELD：字段声明（包括枚举常量），用于字段上
    • ElementType.PARAMETER：形参声明，用于参数上
    • ElementType.CONSTRUCTOR：构造声明，用于构造方法上
    • ElementType.LOCAL_VARIABLE：局部变量声明，用于局部变量上
    • ElementType.ANNOTATION_TYPE：注解接口声明
    • ElementType.PACKAGE：包声明
    • ElementType.TYPE_PARAMETER：类型参数声明
    • ElementType.TYPE_USE：类型的使用
    • ElementType.MODULE：模块声明
    • ElementType.RECORD_COMPONENT：记录组件

  • @Retention：表述注解的生命周期

    • RetentionPolicy.SOURCE：只保留在源文件，编译成class时将丢弃
    • CLASS：被保留在class文件中，但在运行时不会保留，即在运行时无法获取，这是默认的生命周期策略
    • RUNTIME：不但在class文件中存在，运行时也存在，因此可以通过反射去获取

我们自定义的DistributeLock注解用于方法上，所以将@Target定义为ElementType.METHOD，在运行时需要获取注解的相关信息，所以将@Retention定义为RetentionPolicy.RUNTIME

/**
 * 分布式锁注解
 * @author 蜡笔小柯南
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DistributeLock {

    /**
     * 锁的key
     */
    public String key() default DistributeLockConstant.NONE_KEY;
    
    /**
     * 锁的使用场景
     */
    public String scene();

    /**
     * key的SPEL表达式
     */
    public String keyExpression() default DistributeLockConstant.NONE_KEY;

    /**
     * 超时时间，毫秒
     * 默认情况下不设置超时时间，会自动续期
     */
    public int expireTime() default DistributeLockConstant.DEFAULT_EXPIRE_TIME;

    /**
     * 加锁等待时长，毫秒
     * 默认情况下不设置等待时长，会一直等待直到获取到锁
     */
    public int waitTime() default DistributeLockConstant.DEFAULT_WAIT_TIME;
}

自定义注解常量类

创建名为DistributeLockConstant的常量类，用于设置默认值

/**
 * 分布式锁常量
 *
 * @author 蜡笔小柯南
 */
public class DistributeLockConstant {

    /**
     * 默认的key名称
     */
    public static final String NONE_KEY = "NONE";

    /**
     * 默认超时时间，默认值：-1
     */
    public static final int DEFAULT_EXPIRE_TIME = -1;

    /**
     * 默认枷锁等待时间，默认值：-1
     */
    public static final int DEFAULT_WAIT_TIME = -1;
}

自定义切面类

创建名为DistributeLockAspect的切面，使得自定义注解生效

/**
 * 分布式锁切面
 *
 * @author 蜡笔小柯南
 */
@Component
@Aspect
public class DistributeLockAspect {

    @Autowired
    private RedissonClient redissonClient;

    @Around("@annotation(com.yogurt.lock.DistributeLock)")
    public Object process(ProceedingJoinPoint pjp) throws Exception {
        // 获取方法
        Method method = ((MethodSignature) pjp.getSignature()).getMethod();
        // 获取方法上的注解
        DistributeLock distributeLock = method.getAnnotation(DistributeLock.class);
        // key 先尝试获取key,如果key有值,则使用key;如果key是NONE,则尝试获取keyExpression
        String key = distributeLock.key();
        if (DistributeLockConstant.NONE_KEY.equals(key)) {
            // SpEL表达式
            String keyExpression = distributeLock.keyExpression();
            // 如果keyExpression是NONE,则抛出异常,提示错误信息
            if (DistributeLockConstant.NONE_KEY.equals(keyExpression)) {
                throw new RuntimeException("key和keyExpression不能同时为空");
            }
            EvaluationContext context = new StandardEvaluationContext();
            // 获取运行时参数的名称
            DefaultParameterNameDiscoverer discoverer
                    = new DefaultParameterNameDiscoverer();
            // 获取参数名称
            String[] parameterNames = discoverer.getParameterNames(method);
            // 将参数绑定到context中
            if (parameterNames != null) {
                // 获取参数值,如果参数是对象，则获取的是对象的地址
                Object[] args = pjp.getArgs();
                for (int i = 0; i < parameterNames.length; i++) {
                    context.setVariable(parameterNames[i], args[i]);
                }
            }
            // 解析SpEL表达式
            SpelExpressionParser parser = new SpelExpressionParser();
            Expression expression = parser.parseExpression(keyExpression);
            // 解析表达式，获取结果
            key = expression.getValue(context, String.class);
        }
        // 获取锁的场景
        String scene = distributeLock.scene();
        // 锁的key,锁的场景+key
        String lockKey = scene + "#" + key;
        // 锁的过期时间
        int expireTime = distributeLock.expireTime();
        // 锁的等待时间
        int waitTime = distributeLock.waitTime();
        // 获取锁
        RLock rLock= redissonClient.getLock(lockKey);
        Object result = null;
        try {
            // 加锁是否成功标识 true:成功 false:失败
            boolean lockFlag = false;
            // 如果等待时间是默认值，说明没有设置等待时间
            if (waitTime == DistributeLockConstant.DEFAULT_WAIT_TIME) {
                // 锁的过期时间是默认值，说明没有设置锁的过期时间
                if (expireTime == DistributeLockConstant.DEFAULT_EXPIRE_TIME) {
                    // 加锁,无任何参数
                    rLock.lock();
                } else {
                    // 说明锁的过期时间不是默认值,则设置锁的过期时间
                    rLock.lock(expireTime, TimeUnit.MILLISECONDS);
                }
                lockFlag = true;
            } else {
                // 等待时间不是默认值,说明设置了等待时间,继续判断锁的过期时间是否是默认值
                // 过期时间如果是默认值，则只设置锁的等待时间
                if (expireTime == DistributeLockConstant.DEFAULT_EXPIRE_TIME) {
                    lockFlag = rLock.tryLock(waitTime, TimeUnit.MILLISECONDS);
                } else {
                    // 锁的过期时间不是默认值,则设置锁的等待时间和锁的过期时间
                    lockFlag = rLock.tryLock(waitTime, expireTime, TimeUnit.MILLISECONDS);
                }
            }
            if (!lockFlag) {
                throw new RuntimeException("获取锁失败... key : " + lockKey);
            }
            // 实际方法执行
            result = pjp.proceed();
        } catch (Throwable e) {
            throw new Exception(e);
        } finally {
            if (rLock.isHeldByCurrentThread()) {
                // 释放锁
                rLock.unlock();
            }
        }
        return result;
    }
}

使用@Around环绕通知的方式，其中@Around注解中，使用@annotation(com.yogurt.mp.lock.DistributeLock)，@annotation中指定我们自定义注解的全限定类名，如：我的在com.yogurt.mp.lock包下。

表示我们这个AOP切面，在标注了@DistributeLock注解的情况下，才会生效。

整个AOP切面的作用是，在实际方法执行之前，先去获取锁，成功获取到锁后，再调用pjp.proceed()执行实际的方法，在finally块中释放锁，最终返回数据。

测试

使用key的方式

创建Controller，名为GoodsController

/**
 * @author 蜡笔小柯南
 */
@RestController
@RequestMapping("/goods")
public class GoodsController {

    @PostMapping("/test")
    @DistributeLock(scene = "goods", key = "1001")
    public void test(@RequestBody Goods goods) {
        System.out.println("商品ID：" + goods.getId());
        System.out.println("商品名称：" + goods.getGoodsName());
        System.out.println("商品数量：" + goods.getGoodsCount());
        System.out.println("商品价格：" + goods.getPrice());
    }
}

使用@DistributeLock注解，设置scene和key

测试数据入参：

{
  "goodsName": "橙子",
  "goodsCount": 1,
  "price": "3"
}

以debug的方式启动，在redis中会以Hash的形式保存一个键值对，键为：goods#1001，即scene + # + key，在注解中，scene设置的是goods，key设置的是1001，所以最终保存到redis中的key就是goods#1001。

在这里插入图片描述

使用key的方式，我们发现key的值，是在标注注解的时候，就写死的，如：@DistributeLock(scene = "goods", key = "1001")，可以看到，key被固定写成了1001，如果所有的请求需要获取同一把锁，只有获取成功才能继续后续处理，这种方式可以实现。

而如果我们需要根据商品的id来锁，比如：多个请求都是要访问商品id为1的数据，要为商品id为1的加锁，谁获取锁成功，谁能继续执行后续逻辑，其余的请求等待锁的释放。这时，一个新请求要访问商品id为2的数据，商品id为2的数据从来没有被访问过，那么这个新的请求就能成功获取到锁，进行执行后续逻辑。

如果使用固定key的方式，就是不管访问哪个商品的数据，都要去竞争同一把锁，即便是请求1要访问商品id为1的数据，请求2要访问商品id为2的数据，在请求1获取锁成功还未释放锁时，请求2只能等待锁的释放。

接下来，使用SpEL表达式的方式实现！

Spel表达式方式

将注解中的key替换为keyExpression

    @PostMapping("/test")
    @DistributeLock(scene = "goods", keyExpression = "#goods.id")
    public void test(@RequestBody Goods goods) {
        System.out.println("商品ID：" + goods.getId());
        System.out.println("商品名称：" + goods.getGoodsName());
        System.out.println("商品数量：" + goods.getGoodsCount());
        System.out.println("商品价格：" + goods.getPrice());
    }

#是SpEL表达式的固定写法，goods.id 表示取 goods 对象中的 id 属性值

goods需要和形参列表中的参数名称保持一致，#goods.id是通过get方法来获取的，要保证对象中有对应属性的get方法

如：

  • #goods.id：需要有getId()方法
  • #goods.goodsName：需要有getGoodsName()方法

测试数据入参，添加id字段

{
  "id": 1,
  "goodsName": "菠萝",
  "goodsCount": 20,
  "price": "66"
}

我们看redis中保存的键值对，key是：goods#1，入参的参数中，id的值为1，所以拼接好最后的key就是goods#1

在这里插入图片描述

如果将入参中id的值修改为2，我们再看redis中是如何保存的

{
  "id": 2,
  "goodsName": "榴莲",
  "goodsCount": 20,
  "price": "666"
}

可以看到，key是：goods#2，根据我们传入id参数的不同，能够动态的改变

在这里插入图片描述

控制台输出结果

商品ID：2
商品名称：榴莲
商品数量：20
商品价格：666

两种方式的区别

key的方式：

如果需要获取同一把锁，则可以使用固定key的方式

SpEL表达式方式：

如果需要根据参数的不同，获取不同的锁，可以使用SpEL表达式的方式


现在，你的武器库里又多了一件神器。@DistributedLock注解的强大超乎你的想象！

不管在任何时候，我希望你永远不要害怕挑战，不要畏惧失败。每一个错误都是向成功迈出的一步，每一个挑战都是成长的机会，因为每一次的努力，都会使我们离梦想更近一点。只要你行动起来，任何时候都不算晚。最后，把座右铭送给大家：种一棵树最好的时间是10年前，其次就是现在，加油！共勉 💪。
【@Transactional + Lock】失效及解决方案
吉光片羽的博客
11-06 1205
超卖现象、事务套锁导致失效超卖，常用解决方案
自定义注解实现分布式锁 @DistributedLock
yyh695809001的博客
10-16 480
Slf4j@Aspect@Resource//校验表达式try {} else {throw new RuntimeException("操作进行中");/*** 解析key* @return*/if (!return key;i++) {try {throw new IllegalArgumentException("SPEL表达式解析结果为null");
Spring @Transactional工作原理详解
08-28
主要介绍了Spring @Transactional工作原理详解，具有一定借鉴价值，需要的朋友可以参考下。
distributed-lock:三种方式实现分布式锁
05-08
Distributed Lock 三种方式实现分布式锁 基于Redis 实现
DistributedLock:使用Redis的分布式锁
06-10
分布式锁 使用Redis的分布式锁。 要运行演示 - 生成本地 redis 集群，克隆此存储库并运行单元测试
自定义注解实现分布式锁
qq_37205211的博客
12-25 1850
自定义注解实现分布式锁中间件
分布式锁(Distributed Lock)理论介绍
云原生Java Web领域技术博客
10-16 6272
在多线程环境中，线程之间通常使用互斥锁实现共享资源的独占访问。在多进程环境，特别是分布式环境，常使用分布式锁来实现共享资源的独占访问。简单来说，分布式锁就是指在分布式环境下，通过加解锁实现多节点对共享资源的互斥访问。
Java注解@Transactional事务类内调用不生效问题及解决办法
08-19
Java注解@Transactional事务类内调用不生效问题及解决办法 Java注解@Transactional是Java中的一种注解，主要用于标记事务边界。然而，在某些情况下，@Transactional注解可能不会生效，例如在同一个类中的方法调用...
手写一个@Transactional注解，实现事务回滚
最新发布
刻苦的樊同学
11-14 356
*** 自定义事务注解* 空注解，用来标识*//*** 将自定义的事务注解，使用AOP的方式，来增强它的功能*/@Aspect@Component@Autowired/*** 让标记着@myTransactional注解的方法，不直接调用，而是在该方法前后增加代码，增强该方法功能。
Transactional注解+自定义注解实现事务回滚
m0_63300795的博客
10-30 932
前言比如我们做复杂的业务的时候、难免会产生多张表的交互、为了不让他少我多的情况下、小编就写了这篇文章来做为解决方案！
distributeLock:分布式锁和配置管理中心的实现，采用zookeeper的全局有序的特性来实现
06-06
#分布式锁和配置管理中心的实现 ##distributelock包下实现了分布式锁，利用zookeeper，创建一个临时时序的节点类型，采用zookeeper的全局有序的特性来实现。 ###具体步骤： 1.客户端调用create()方法创建名为“grouplock/sub”的节点，需要注意的是，这里节点的创建类型需要设置为EPHEMERAL_SEQUENTIAL。 2.客户端调用getChildren(“grouplock”)方法来获取所有已经创建的子节点，注意，这里不注册任何Watcher。 3.客户端获取到所有子节点path之后，如果发现自己在步骤1中创建的节点序号最小，那么就认为这个客户端获得了锁。 如果在步骤3中发现自己并非所有子节点中最小的，说明自己还没有获取到锁。此时客户端需要找到比自己小的那个节点，然后对其调用exist()方法，同时注册事件监听。 之后当这个被关注的节点被移
distributed_lock:分布式锁
06-28
分布式锁 分布式锁：使用mysql和zookeeper实现 mysql_lock.py：Mysql 分布式锁zk_lock.py：zookeeper 分布式锁（需要 python 模块 'kazoo'） test_mysql_lock.py：测试Mysql分布式锁test_zookeeper_lock.py：测试zookeeper分布式锁
distributed-lock:使用Spring的分布式锁定
05-05
分布式锁 分布式锁定可确保您的方法无法从多个JVM（服务器，微服务集群等）并行运行。 它使用公用存储来跟踪已使用的锁，并且您的方法需要获取一个或多个锁才能运行。 默认情况下，锁遵循方法的生命周期，它们是在方法开始时获得并在方法结束时释放的。 支持手动控制，本文档后面将对此进行说明。 在此项目中，由锁实现实现的所有锁将在10秒后过期，如果在两次重试之间无法获取锁并Hibernate50毫秒，则将在1秒后超时。 这些选项可根据注释自定义。 使用锁 要锁定您的方法，您需要首先启用上一节中所述的锁定。 Spring 将处理所有@Locked方法，包括它们的别名。 type字段描述要使用的锁的实现。 如果您打算使用相同的实现（大多数人通常会这样做），则为了避免重复您自己，我添加了别名支持。 它们包装@Locked批注并定义使用的类型。 每个锁都需要定义用于获取锁的表达式。 要了解有关Spri
一个注解实现分布式锁
qq_34874784的博客
08-13 940
否则，节点需要等待或执行相应的逻辑。等到获得锁的线程或实例执行完成后，释放锁，其它等待的线程或实例才能获取锁并执行相应的业务逻辑。需要注意的是，分布式锁的实现需要考虑一系列问题，例如锁的超时处理、可重入性、死锁检测等。通过以上方式，节点可以通过锁服务获取到分布式锁，并根据锁服务的协调来保证资源的互斥访问。当节点不再需要锁时，它会向锁服务发送释放锁的请求，锁服务将会删除相应的节点。需要注意的是，使用 Redis 实现分布式锁时，需要确保 Redis 服务的高可用性和可靠性，以避免单点故障导致的锁失效问题。
分布式锁原理探究
彬正的博客
07-18 5402
一、前言 在同一个 JVM 进程中，我们可以使用 JUC 提供的一些锁来解决多个线程竞争同一个共享资源时候的线程安全问题，但是当多个不同 JVM 进程中的线程共同竞争同一个共享资源时候，JUC 包的锁就无能无力了，这时候就需要分布式锁了。 本 Chat 主要讲解几种常见的分布式锁实现方案以及原理，主要内容如下： 分布式锁与 JUC 包锁的不同； 使用数据库锁来实现分布式锁； 使用 Red...
一个注解搞定redis分布式锁
Null
03-29 1056
首先自定义注解：@DistributeLock。
分布式锁（Distributed Lock）介绍（基于数据库（mysql）；基于缓存（redis）；基于ZooKeeper等分布式协调服务）
Dontla的博客
01-28 4248
分布式锁是一种在分布式环境下，对共享资源提供访问限制的方法。其主要目的是防止多个进程同时操作同一资源，造成数据的不一致性。分布式锁通过在多个节点上运行的进程之间引入协调机制，来解决这个问题。分布式锁是一种有效的协调在分布式环境中运行的并发进程的机制。它可以帮助我们避免因并发操作而导致的数据不一致性。然而，设计和实现一个可靠、高效且公平的分布式锁是一项具有挑战性的任务。
分布式系统常用的三注解：@DS，@DistributeLock，@GlobalTransactional【开发实践】
qq_40656637的博客
06-04 6943
读写分离是一种基于主从复制的数据库读写策略，在应用程序层面（如在代码中或使用中间件）区分读写操作，主节点负责所有的写操作（增、删、改）和实时性较高的读操作（查），从节点负责实时性较低的读操作。分库：单个服务器的磁盘存储容量和CPU处理能力是有极限的，随着存储数据量的增大或请求并发数的增多，单个服务器将无法满足需求。之前使用（非必须）。分布式事务是指跨越多个分布式系统或服务的事务操作，需要保证这些操作作为一个整体，要么全部成功，要么全部失败，以此来维护数据的一致性和完整性。方法的数据源失效，使用的是外层的。
spring @transactional和自定义aop
04-16
Spring中的@Transactional注解是用于声明事务的，它可以应用在方法或类级别上。当@Transactional注解应用在方法上时，表示该方法需要在一个事务中执行。当应用在类级别上时，表示该类的所有方法都需要在一个事务中执行。 自定义AOP（面向切面编程）是Spring框架提供的一种机制，用于在程序运行期间动态地将代码织入到目标方法中。通过自定义AOP，我们可以实现一些横切关注点的功能，例如日志记录、性能监控、事务管理等。 在Spring中，自定义AOP主要通过以下几个步骤来实现： 1. 定义切面：切面是一个类，其中包含了一些通知（Advice）和切点（Pointcut）。 2. 定义通知：通知是在目标方法执行前、执行后或抛出异常时执行的代码块。 3. 定义切点：切点是一个表达式，用于匹配目标方法。 4. 配置AOP：将切面和切点配置到Spring的配置文件中。 5. 启用AOP：在Spring的配置文件中启用AOP。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

蜡笔小柯南

多谢投喂，感恩家人

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值