掌握Redisson分布式锁，轻松驾驭并发处理

后端

2023-06-24 06:56:15

分布式锁在 Spring Boot 中的使用：利用 Redisson 确保数据一致性

简介

随着互联网的蓬勃发展，分布式应用已成为主流。在分布式系统中，分布式锁必不可少，它可以确保在同一时间内，只有一个节点可以访问共享资源，防止并发访问导致的数据不一致问题。

什么是 Redisson？

Redisson 是 Spring Boot 应用程序中一个流行的分布式锁实现库。它提供了一系列丰富的功能，包括分布式锁、分布式集合、分布式事件发布和订阅等。

在 Spring Boot 中使用 Redisson 实现分布式锁

1. 添加 Redisson 依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.17.1</version>
</dependency>

2. 创建 Redisson 客户端

@Bean
public RedissonClient redissonClient() {
    Config config = new Config();
    config.useSingleServer().setAddress("redis://127.0.0.1:6379");
    return Redisson.create(config);
}

3. 定义 DistributedLock 注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DistributedLock {

    /**
     * 锁的名称
     * @return
     */
    String lockName();

    /**
     * 锁的过期时间(毫秒)
     * @return
     */
    long expire() default 30000;

    /**
     * 是否等待锁
     * @return
     */
    boolean waitLock() default true;

    /**
     * 尝试获取锁的最大等待时间(毫秒)
     * @return
     */
    long leaseTime() default 10000;
}

4. 创建 DistributedLockAspect 切面

@Aspect
@Component
public class DistributedLockAspect {

    @Autowired
    private RedissonClient redissonClient;

    @Around("@annotation(distributedLock)")
    public Object around(ProceedingJoinPoint joinPoint, DistributedLock distributedLock) throws Throwable {
        RLock lock = redissonClient.getLock(distributedLock.lockName());
        // 尝试获取锁
        boolean locked = lock.tryLock(distributedLock.leaseTime(), distributedLock.expire(), TimeUnit.MILLISECONDS);
        if (!locked && distributedLock.waitLock()) {
            // 等待获取锁
            locked = lock.lock(distributedLock.expire(), TimeUnit.MILLISECONDS);
        }
        if (locked) {
            try {
                return joinPoint.proceed();
            } finally {
                lock.unlock();
            }
        } else {
            throw new RuntimeException("获取锁失败");
        }
    }
}

5. 示例代码

@Service
public class OrderService {

    @DistributedLock(lockName = "order_lock", expire = 10000)
    public void createOrder(Order order) {
        // 创建订单逻辑
    }
}