Redisson与SpringBoot整合

已于 2023-01-10 13:00:36 修改
阅读量1.2w 收藏 41
点赞数 6
分类专栏： Spring 缓存 文章标签： redisson
于 2021-12-13 11:43:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianzhonghaoqing/article/details/121902105
版权

概述

实际开发中会遇到分布式锁的情况，解决方案有数据库（不推荐）、Redis（Redission 推荐）、zookeeper等。
这里我们介绍redisson方案。
官方解释，什么是redisson？
Redis Java Client with features of In-Memory Data Grid。

什么是redisson

redisson是一个在redis的java客户端，是在Redis基础上实现的数据网格功能。
他不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。
redisson提供的api均以面向对象的操作方式，将key-value封装成我们熟悉的集合或者对象，我们可以通过这些API更方便的操作数据。同时它提供了多个实现了java.util.concurrent接口的集合类，让我们能在线程安全的环境下操作数据。
其中redis的官网也将它纳入推荐使用的工具中。

pom依赖

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.6.1</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	...
	<!-- redisson config -->
		<dependency>
			<groupId>org.redisson</groupId>
			<artifactId>redisson-spring-boot-starter</artifactId>
			<version>3.16.6</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>

redission配置信息

spring.redis.cluster.nodes=${redis.nodes}
spring.redis.database=6
spring.redis.timeout=30000
spring.redis.enableTransactionSupport=false
spring.redis.password=${redis.password}
spring.redis.lettuce.pool.max-wait=30000
spring.redis.lettuce.pool.max-active=100
spring.redis.lettuce.pool.min-idle=50

redisson客户端对象实例化

package com.example.springboot_redis.redis;

import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Redission配置类
 */
@Slf4j
@Configuration
public class RedissionConfig {

    /**
     * redisson协议前缀
     */
    private static final String SCHEMA_PREFIX = "redis://";

    /**
     * 锁超时时间
     */
    @Value("${spring.redis.lockTimeOut:30000}")
    private long lockWatchTimeOut;
    
    @Bean
    public RedissonClient redissonClient(RedisProperties redisProperties) {
        Config config = new Config();
        RedisProperties.Sentinel sentinel = redisProperties.getSentinel();
        RedisProperties.Cluster redisPropertiesCluster = redisProperties.getCluster();
        if (redisPropertiesCluster != null) {
            //集群redis
            ClusterServersConfig clusterServersConfig = config.useClusterServers();
            for (String cluster : redisPropertiesCluster.getNodes()) {
                clusterServersConfig.addNodeAddress(SCHEMA_PREFIX + cluster);
            }
            if (StringUtils.hasText(redisProperties.getPassword())) {
                clusterServersConfig.setPassword(redisProperties.getPassword());
            }
            clusterServersConfig.setTimeout((int) redisProperties.getTimeout().toMillis());
            clusterServersConfig.setPingConnectionInterval(30000);
        } else if (StringUtils.hasText(redisProperties.getHost())) {
            //单点redis
            SingleServerConfig singleServerConfig = config.useSingleServer().
                    setAddress(SCHEMA_PREFIX + redisProperties.getHost() + ":" + redisProperties.getPort());
            if (StringUtils.hasText(redisProperties.getPassword())) {
                singleServerConfig.setPassword(redisProperties.getPassword());
            }
            singleServerConfig.setTimeout((int) redisProperties.getTimeout().toMillis());
            singleServerConfig.setPingConnectionInterval(30000);
            singleServerConfig.setDatabase(redisProperties.getDatabase());
        } else if (sentinel != null) {
            //哨兵模式
            SentinelServersConfig sentinelServersConfig = config.useSentinelServers();
            sentinelServersConfig.setMasterName(sentinel.getMaster());
            for (String node : sentinel.getNodes()) {
                sentinelServersConfig.addSentinelAddress(SCHEMA_PREFIX + node);
            }
            if (StringUtils.hasText(redisProperties.getPassword())) {
                sentinelServersConfig.setPassword(redisProperties.getPassword());
            }
            sentinelServersConfig.setTimeout((int) redisProperties.getTimeout().toMillis());
            sentinelServersConfig.setPingConnectionInterval(30000);
            sentinelServersConfig.setDatabase(redisProperties.getDatabase());
        }
        config.setLockWatchdogTimeout(lockWatchTimeOut);
        return Redisson.create(config);
    }
}

编写分布式锁工具类

package com.example.springboot_redis.redis;

import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * 分布式Redis锁
 */
@Slf4j
@Component
public class DistributedRedisLock {

    @Autowired
    private RedissonClient redissonClient;

    // 加锁
    public Boolean lock(String lockName) {
        if (redissonClient == null) {
            log.info("DistributedRedisLock redissonClient is null");
            return false;
        }

        try {
            RLock lock = redissonClient.getLock(lockName);
            // 锁15秒后自动释放，防止死锁
            lock.lock(15, TimeUnit.SECONDS);

            log.info("Thread [{}] DistributedRedisLock lock [{}] success", Thread.currentThread().getName(), lockName);
            // 加锁成功
            return true;
        } catch (Exception e) {
            log.error("DistributedRedisLock lock [{}] Exception:", lockName, e);
            return false;
        }
    }

    // 释放锁
    public Boolean unlock(String lockName) {
        if (redissonClient == null) {
            log.info("DistributedRedisLock redissonClient is null");
            return false;
        }

        try {
            RLock lock = redissonClient.getLock(lockName);
            lock.unlock();
            log.info("Thread [{}] DistributedRedisLock unlock [{}] success", Thread.currentThread().getName(), lockName);
            // 释放锁成功
            return true;
        } catch (Exception e) {
            log.error("DistributedRedisLock unlock [{}] Exception:", lockName, e);
            return false;
        }
    }
}

功能测试

package com.example.springboot_redis.contoller;

import com.example.springboot_redis.redis.DistributedRedisLock;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 分布式Redis锁测试controller
 */
@Slf4j
@RestController
@RequestMapping("/lock")
public class LockTestController {

    private final String LOCK = "LOCK";

    @Autowired
    private DistributedRedisLock distributedRedisLock;

    // 测试不释放锁
    @GetMapping("/testLock")
    public void testLock() {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                distributedRedisLock.lock(LOCK);
            }).start();
        }
    }

    // 实际业务开发使用分布式锁的方式
    @PostMapping
    public void post() {
        try {
            if (distributedRedisLock.lock(LOCK)) {
                // 业务逻辑
                log.info("开始业务逻辑");
            } else {
                // 处理获取锁失败的逻辑
                log.info("获取锁失败");
            }
        } catch (Exception e) {
            log.error("处理异常：", e);
        } finally {
            distributedRedisLock.unlock(LOCK);
        }
    }
}

测试结果

2021-12-17 15:03:14.243  INFO 64496 --- [      Thread-21] com.study.practice.utils.DistributeLock  : Thread [Thread-21] DistributedRedisLock lock [LOCK] success
2021-12-17 15:03:29.243  INFO 64496 --- [      Thread-23] com.study.practice.utils.DistributeLock  : Thread [Thread-23] DistributedRedisLock lock [LOCK] success
2021-12-17 15:03:44.246  INFO 64496 --- [      Thread-20] com.study.practice.utils.DistributeLock  : Thread [Thread-20] DistributedRedisLock lock [LOCK] success
2021-12-17 15:03:59.250  INFO 64496 --- [      Thread-19] com.study.practice.utils.DistributeLock  : Thread [Thread-19] DistributedRedisLock lock [LOCK] success
2021-12-17 15:04:14.255  INFO 64496 --- [      Thread-22] com.study.practice.utils.DistributeLock  : Thread [Thread-22] DistributedRedisLock lock [LOCK] success

结果分析

  1. 调用方法启用5个线程，每个线程都去获取分布式锁，只有一个线程能获取到锁，其他线程均处于阻塞状态
  2. 因为没有调用释放锁的方法，且在获取锁的lock（）方法中设置了锁的最大时间为15秒（防止死锁的发生），所以在15秒后锁自动释放，由其他线程进行竞争这把分布式锁然后执行。

总结

在实际使用redission作为分布式锁时，操作步骤如下：

  1. 调用distributedRedisLock.lock(String lockName) 获取分布式锁；
  2. 如果返回true，执行业务逻辑。如果返回false，进行阻塞；
  3. 当执行完业务逻辑后，调用distributedRedisLock.unlock(String lockName)释放锁。

参考

Redis客户端之Redission
SprinBoot2.2.x 整合 Redission （分布式锁）
Redisson实现分布式锁(1)—原理

融极
关注
专栏目录
springboot整合redisson（一）搭建Redisson环境，30岁转行程序员
m0_54865014的博客
12-22 7125
=============================================================================== 1.通过idea创建springboot项目 2.通过web网站创建springboot项目 创建完之后的项目结构如下： ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210614122935330.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGV
SpringBoot整合Redisson操作集群redis
u013658328的博客
01-15 2665
关联文章： SpringBoot整合Redisson操作单节点Redis 上文使用Redisson对单节点的redis进行操作，但是在对于集群操作时需要不同的配置以及集群的搭建，本文就一起来探索使用docker的redis集群的搭建。 搭建集群Redis 本文Redis集群的搭建参考官方给出的搭建指导。 1.首先我们需要编写Redis的配置文件redis.conf #redis的端口 port 7000 #关闭redis的保护模式 protected-mode no #开启集群模式 cluster-
spring boot 利用redisson实现redis的分布式锁（二）
05-01
NULL 博文链接：https://liaoke0123.iteye.com/blog/2375556
SpringBoot集成Redisson
qq_38254635的博客
08-18 5099
Redisson
springboot整合redission
最新发布
xl_21的博客
08-21 346
【代码】springboot整合redission。
SpringBoot整合Redisson
马明的博客
01-19 3881
个人博客纯净版 SpringBoot整合Redisson | 代码搬运工 Redisson简介 Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步
Spring Boot集成Redisson
囚徒之困
06-24 1335
Spring Boot集成Redisson
Springboot 整合 Redisson
博客
06-06 1万+
Springboot 整合 Redisson
springboot - 2.7.3版本 - （四）整合Redisson
09-23
在redis的基础上添加redisson的使用，主要演示与springboot项目的整合
【SpringBoot】整合Redisson（使用redisson-spring-boot-starter）
热门推荐
qq_27579471的博客
01-10 3万+
public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime){ RLock lock = redissonClient.getLock(lockKey); try { return lock.tryLock(waitTime, leaseTime, unit); } ...
springboot整合redisson（一）搭建Redisson环境
2301_76238237的博客
04-04 1405
我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。
SpringBoot 整合Redisson
yyongsheng的博客
10-11 3881
1) 在application.yml 中添加redission 配置文件路径。2) 测试类 TestApplication.java。可以看到配置类中注入了Redission客户端对象。1) 主启动类 Application.java。正常运行,且能加锁成功。查看jar包相关依赖。
redisson整合springboot
k_x_sh的博客
05-23 217
http://www.javashuo.com/article/p-hqujfqxv-by.html
springboot 集成 redisson
学海无涯,我用JAVA
03-08 1308
其中引入了RedisProperties,正常来说,是无须编写redisson配置类的,但是不知为何,必须要有该配置类,否则注入redisson失败。其中 spring.redis.redisson 按照此,我在yml中配置,也是不生效的,无法读取配置。ps: 集成过程中百度了很多文章,也有一些疑惑,请知道的大神予以解答 两个问题,但是是同样的。集成 redisson 分两步,第一步引入pom,第二步需要配置。接下来就可以使用了,给出一个demo。2 自定义配置redisson地址。
springboot集成redisson
lizsy的博客
08-24 1401
springboot集成有两种方式，分别是集成redisson-spring-boot-starter或redisson-spring-data。由于作者的项目和redisson-spring-boot-starter有冲突，所以选择集成redisson-spring-data，下面介绍集成集成步骤，已单机版redis为列。
[分布式锁] SpringBoot整合Redisson
GSON的博客
11-04 2274
一、添加依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- springboot整合
Spring Boot与Redisson的集成
聚娃科技开发者博客
07-13 498
它通过简单易用的接口，使Java开发者能够充分利用Redis的强大功能，如分布式锁、分布式集合和分布式对象等。Redisson作为一个强大的分布式解决方案，能够帮助开发者轻松实现分布式应用程序中的各种功能需求，提升系统的性能和可靠性。除了分布式锁之外，Redisson还提供了丰富的分布式对象和服务，如分布式集合、分布式Map、分布式队列等。在Spring Boot项目中集成Redisson非常简单，可以通过Maven或Gradle添加依赖，然后配置即可开始使用Redisson提供的功能。
redisson版本_SpringBoot整合Redisson(集群版)
05-26
在SpringBoot中使用Redisson（集群版）可以使用以下步骤： 1. 添加Redisson依赖 在`pom.xml`文件中添加以下依赖： ```xml <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>${redisson.version}</version> </dependency> ``` `${redisson.version}`是Redisson版本号，可以根据需要进行修改。 2. 配置Redisson 在SpringBoot中配置Redisson可以通过自定义配置类实现，示例代码如下： ```java @Configuration public class RedissonConfig { @Value("${spring.redis.host}") private String host; @Value("${spring.redis.port}") private int port; @Value("${spring.redis.password}") private String password; @Value("${spring.redis.database}") private int database; @Value("${spring.redis.timeout}") private int timeout; @Bean(destroyMethod = "shutdown") public RedissonClient redisson() { Config config = new Config(); config.useClusterServers() .addNodeAddress("redis://host1:port1", "redis://host2:port2") .setPassword(password) .setDatabase(database) .setConnectTimeout(timeout) .setRetryInterval(5000) .setRetryAttempts(3) .setMasterConnectionMinimumIdleSize(10) .setMasterConnectionPoolSize(64) .setSlaveConnectionMinimumIdleSize(10) .setSlaveConnectionPoolSize(64) .setLoadBalancer(new RoundRobinLoadBalancer()); return Redisson.create(config); } } ``` 其中，`host`、`port`、`password`、`database`、`timeout`等属性可以从`application.properties`文件中获取。 `config.useClusterServers()`方法表示使用Redis集群模式，`addNodeAddress()`方法用于添加Redis节点地址，可以添加多个节点。其他方法则是对Redisson连接池的配置，可以根据需要进行修改。 3. 使用Redisson 在需要使用Redisson的地方注入`RedissonClient`，示例代码如下： ```java @Service public class UserService { @Autowired private RedissonClient redissonClient; public void addUser(User user) { RMap<String, User> map = redissonClient.getMap("users"); map.put(user.getId(), user); } public User getUser(String id) { RMap<String, User> map = redissonClient.getMap("users"); return map.get(id); } } ``` 以上示例代码中，使用`redissonClient.getMap("users")`获取名为`users`的Redisson Map对象，然后可以使用Map对象进行Redis数据操作。 注意：在使用Redisson时，需要保证RedissonClient的单例，否则可能会出现连接泄漏等问题。可以使用SpringBoot的`@Scope("singleton")`注解或者将`RedissonClient`对象定义为静态变量来实现单例。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

融极

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值