基于Redisson实现注解式分布式锁的示例代码

更新时间：2023年07月26日 16:08:01 作者：叔牙

这篇文章主要为大家详细介绍了如何基于Redisson实现注解式分布式锁，文中的示例代码讲解详细，具有一定的参考价值，需要的可以了解一下

一、背景

基于redisson的分布式锁实现,我们可以比较容易的控制竞态资源的分布式并发控制,但是使用的时候会出现很多重复的try-catch-finally代码块,获取锁、加锁和释放锁等,用法大致如下:

RLock lock = redissonClient.getLock("lock_name");
try {
    if(lock.tryLock(5,10, TimeUnit.SECONDS)) {
        //do something
    }
} catch (Exception e) {
    log.error("occur error",e);
} finally {
    if (lock.isLocked() && lock.isHeldByCurrentThread()) {
        lock.unlock();
    } 
}

写代码讲究一个优雅和高效,作为一个有追求的程序员,项目中出现大面积重复性的手动加锁解锁以及try-catch-finally代码块是不能接受的。从锁使用方式中,我们可以抽象出通用的部分,try-catch-finally代码块,以及获取锁、加锁和解锁逻辑,那么有没有一种方式把这些逻辑抽取到一个地方管理,然后在需要使用锁的地方,通过简单的方式引入加锁解锁逻辑? 答案是可以的,我们可以结合自定义注解和切面,把加锁逻辑封装起来,然后拦截使用了解锁注解的方法,把加锁解锁逻辑织入进去就可以了。

二、写成starter复用

新建一个starter工程,把加锁逻辑封装到切面,然后通过注解的方式提供给业务使用。

1.引入依赖

引入redis和redisson相关依赖:

<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>
</dependency>

2.定义分布式锁注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface XLock {
    String key() default "";
    @AliasFor("key")
    String value() default "";
    long waitTime() default 5;
    long leaseTime() default 30;
    TimeUnit unit() default  TimeUnit.SECONDS;
}

定义加锁的key,等待时间,锁释放时间和时间单位。

3.定义分布式锁属性

@ConfigurationProperties(prefix = "redisson.redis")
@Data
public class RedissonProperties {
    private String port;
    private String password;
    private int database = 0;
    /**
     * redis服务端类型
     * @see ServerType
     */
    private Integer serverType;
    private SingleServer singleServer;
    private ClusterServers clusterServers;
    private MasterSlaveServers masterSlaveServers;
    private ReplicatedServers replicatedServers;
    private SentinelServers sentinelServers;
    @Data
    public static class SingleServer {
        private String host;
    }
    @Data
    public static class ClusterServers {
        private String hosts;//多个用逗号隔开
    }
    @Data
    public static class MasterSlaveServers {
        private String masterHost;
        private String slaveHosts;//多个用逗号隔开
    }
    @Data
    public static class ReplicatedServers {
        private String hosts;
    }
    @Data
    public static class SentinelServers {
        private String masterName;
        private String hosts;
    }
}

包含了端口,密码，默认数据库,以及redis server各种模式的支持。在使用的时候需要在配置文件中添加如下类似的配置:

redisson:
  redis:
    port: 6379
    password: xxxxxx
    database: 0
    serverType: 1 #2,3,4,5
    singleServer:
      host: 127.0.0.1
    clusterServers:
      hosts: 192.168.0.1,192.168.0.2,192.168.0.3
    masterSlaveServers:
      masterHost: 127.0.0.1
      slaveHosts: 192.168.0.1,192.168.0.2
    replicatedServers:
      hosts: 192.168.0.1,192.168.0.2,192.168.0.3
    sentinelServers:
      masterName: masterNode
      hosts: 192.168.0.1,192.168.0.2,192.168.0.3

4.编写切面逻辑

@Slf4j
@Aspect
@Order(Ordered.LOWEST_PRECEDENCE - 1)
public class XLockInterceptor {
    @Autowired
    private RedissonClient redissonClient;
    private ExpressionParser parser = new SpelExpressionParser();
    private LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
    @Around("@annotation(lock.starter.annotation.XLock)")
    public Object aroundMethod(ProceedingJoinPoint pjp) throws Throwable {
        Object object = null;
        MethodSignature joinPointObject = (MethodSignature) pjp.getSignature();
        Method method = joinPointObject.getMethod();
        XLock xlock = method.getAnnotation(XLock.class);
        if(null == xlock) {
            return pjp.proceed();
        }
        Object[] args = pjp.getArgs();
        String[] params = discoverer.getParameterNames(method);
        EvaluationContext context = new StandardEvaluationContext();
        for (int i = 0; i < params.length; i++) {
            context.setVariable(params[i],args[i]);
        }
        String keySpel = xlock.key();
        Expression keyExpression = parser.parseExpression(keySpel);
        String key = keyExpression.getValue(context,String.class);
        RLock lock = redissonClient.getLock(key);
        long waitTime = xlock.waitTime();
        long leaseTime = xlock.leaseTime();
        TimeUnit unit = xlock.unit();
        try {
            if(lock.tryLock(waitTime,leaseTime,unit)) {
                object = pjp.proceed();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            //锁被持有,并且被当前线程持有
            if (lock.isLocked() && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        return object;
    }
}

切面逻辑使用around拦截模式,解析使用了@XLock注解的方法,然后织入加锁解锁逻辑。

5.定义自动注入配置

@Configuration
@ConditionalOnClass({RedissonClient.class, RedissonLock.class})
@EnableConfigurationProperties(RedissonProperties.class)
@Slf4j
public class XLockAutoConfiguration {
    private RedissonProperties redissonProperties;
    public XLockAutoConfiguration(RedissonProperties redissonProperties) {
        this.redissonProperties = redissonProperties;
    }
    @Bean
    @ConditionalOnMissingBean(RedissonClient.class)
    public RedissonClient redisson() {
        String password = this.redissonProperties.getPassword();
        String port = this.redissonProperties.getPort();
        int database = this.redissonProperties.getDatabase();
        ServerType serverType = ServerType.of(this.redissonProperties.getServerType());
        if(null == serverType) {
            throw new RuntimeException("server type not support;serverType=" + this.redissonProperties.getServerType());
        }
        Config config = new Config();
        if(ServerType.SINGLE_SERVER.equals(serverType)) {
            String address = "redis://" + redissonProperties.getSingleServer().getHost() + ":" + port;
            SingleServerConfig singleServerConfig = config.useSingleServer()
                    .setAddress(address)
                    .setDatabase(database);
            if(null != password) {
                singleServerConfig.setPassword(password);
            }
        } else if(ServerType.CLUSTER_SERVERS.equals(serverType)) {
            ClusterServersConfig clusterServersConfig = config.useClusterServers();
            String hosts = redissonProperties.getClusterServers().getHosts();
            for (String host : hosts.split(",")) {
                clusterServersConfig.addNodeAddress("redis://" + host + ":" + port);
            }
            if(null != password) {
                clusterServersConfig.setPassword(password);
            }
        } else if (ServerType.MASTER_SLAVE_SERVERS.equals(serverType)) {
            MasterSlaveServersConfig masterSlaveServersConfig = config.useMasterSlaveServers()
                    .setDatabase(database);
            masterSlaveServersConfig.setMasterAddress("redis://" + redissonProperties.getMasterSlaveServers().getMasterHost() + ":" + port);
            for (String slaveHost : redissonProperties.getMasterSlaveServers().getSlaveHosts().split(",")) {
                masterSlaveServersConfig.addSlaveAddress("redis://" + slaveHost + ":" + port);
            }
            if(null != password) {
                masterSlaveServersConfig.setPassword(password);
            }
        } else if (ServerType.REPLICATED_SERVERS.equals(serverType)) {
            ReplicatedServersConfig replicatedServersConfig = config.useReplicatedServers()
                    .setDatabase(database);
            for (String host : this.redissonProperties.getReplicatedServers().getHosts().split(",")) {
                replicatedServersConfig.addNodeAddress("redis://" + host + ":" + port);
            }
            if(null != password) {
                replicatedServersConfig.setPassword(password);
            }
        } else if (ServerType.SENTINEL_SERVERS.equals(serverType)) {
            SentinelServersConfig sentinelServersConfig = config.useSentinelServers()
                    .setDatabase(database)
                    .setMasterName(this.redissonProperties.getSentinelServers().getMasterName());
            for (String host : this.redissonProperties.getSentinelServers().getHosts().split(",")) {
                sentinelServersConfig.addSentinelAddress("redis://" + host + ":" + port);
            }
            if(null != password) {
                sentinelServersConfig.setPassword(password);
            }
        }
        return Redisson.create(config);
    }
    @Bean
    @ConditionalOnBean(RedissonClient.class)
    public XLockInterceptor xLockInterceptor() {
        return new XLockInterceptor();
    }
}

在用户项目中如果没有定义或者注入RedissonClient,那么通过starter注入RedissonClient,并且支持singleServer、clusterServers、masterSlave、replicatedServer和sentinelServer等模式。并通过@Bean方式注入暴露锁切面。

6.自动配置

在starter工程的META-INF/spring.factories中定义自动配置:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
lock.starter.config.XLockAutoConfiguration

基于spring的SPI模式在项目启动时自动加载starter的分布式锁相关配置,开启分布式锁能力。然后打成jar包到仓库,业务项目就可以pom依赖引入,使用分布式锁相关能力了。

三、使用

业务项目中使用分布式锁starter的能力比较简单,引入依赖并定义相关配置即可。

1.引入分布式锁starter

<dependency>
    <groupId>xxx.xxx</groupId>
    <artifactId>xlock-redisson-starter</artifactId>
</dependency>

2.添加配置

在项目中添加分布式锁所需的配置,以singleServer模式为例:

redisson:
  redis:
    port: 6379
    password: xxxxxx
    database: 0
    serverType: 1 #2,3,4,5
    singleServer:
      host: 127.0.0.1

3.使用分布式锁

在需要加锁的方法上添加@XLock注解,并填入加锁相关的属性即可.

    @XLock(key = "mylock + #uid",waitTime = 5,leaseTime = 10,unit = TimeUnit.SECONDS)
    public void doSomething(String uid) {
        //do some business...
    }

这样就实现了redisson分布式锁的使用。

到此这篇关于基于Redisson实现注解式分布式锁的示例代码的文章就介绍到这了,更多相关Redisson分布式锁内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

深入dom4j使用selectSingleNode方法报错分析
本篇文章是对dom4j使用selectSingleNode方法报错进行了详细的分析介绍，需要的朋友参考下
2013-05-05
Spring注解配置IOC,DI的方法详解
这篇文章主要为大家介绍了vue组件通信的几种方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助
2022-01-01
IDEA的Web项目右键无法创建Servlet问题解决办法
这篇文章主要介绍了IDEA的Web项目右键无法创建Servlet问题解决办法的相关资料,在IDEA中新建Servlet时发现缺失选项,可以通过在pom.xml文件中添加servlet依赖解决,文中通过图文介绍的非常详细,需要的朋友可以参考下
2024-10-10
mybatis集成到spring的方式详解
这篇文章主要介绍了mybatis是如何集成到spring的,将mybatis集成到spring之后，就可以被spring的ioc容器托管，再也不用自己创建SqlSessionFactory 、打开SqlSession等操作，本文结合实例代码给大家介绍的非常详细，需要的朋友可以参考下
2023-05-05
java基于双向环形链表解决丢手帕问题的方法示例
这篇文章主要介绍了java基于双向环形链表解决丢手帕问题的方法,简单描述了丢手帕问题,并结合实例形式给出了Java基于双向环形链表解决丢手帕问题的步骤与相关操作技巧,需要的朋友可以参考下
2017-11-11
详解SpringBoot中如何使用Reactor模型
Reactor模型主要提供了一种在Java虚拟机上构建非阻塞应用的方式,这种方式使用了响应式编程原理,通过响应式流标准来实现,下面我们就来看看它在SpringBoot中是如何使用的吧
2024-04-04
Spring Bean的定义及三种创建方式
本文主要介绍了Spring容器获取Bean的9种方式小结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-07-07
Java从ftp服务器上传与下载文件的实现
这篇文章主要给大家介绍了关于Java从ftp服务器上传与下载文件的实现方法,最近项目中需要实现将文件先存放到ftp上,需要的时候再从ftp上下载,做的过程中碰到了问题,所以这里总结下,需要的朋友可以参考下
2023-08-08
java8 forEach结合Lambda表达式遍历 List操作
这篇文章主要介绍了java8 forEach结合Lambda表达式遍历 List操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-09-09
Java之Arrays的各种功能和用法总结
数组在 Java 中是一种常用的数据结构，用于存储和操作大量数据。Arrays 是我们在处理数组时的一把利器。它提供了丰富的方法和功能，使得数组操作变得更加简单、高效和可靠。接下来我们一起看看 Arrays 的各种功能和用法，,需要的朋友可以参考下
2023-05-05