redisson整合spring

最新推荐文章于 2025-06-07 14:51:12 发布
最新推荐文章于 2025-06-07 14:51:12 发布
阅读量1.9w 收藏 19
点赞数 15
CC 4.0 BY-SA版权
分类专栏： redis redisson spring 文章标签： redis redisson spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wang_keng/article/details/73549274
本文介绍Redisson——一款基于Redis的Java驻内存数据网格，并详细讲解如何将其整合到Spring环境中。通过面向对象的方式操作Redis，提供了多种集合类，确保线程安全的数据操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

首先讲下什么是Redisson：Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。（摘自redisson的wiki：wiki地址）

redisson提供的api均以面向对象的操作方式，将key-value封装成我们熟悉的集合或者对象，我们可以通过封装的api更方便的操作数据。同时它提供了多个实现了java.util.corrurnent接口的集合类，让我们能在线程安全的环境下操作数据。

其中redis的官网也将它纳入推荐使用的工具中，可见redisson已经逐渐上位。



废话不多说，现在开始讲下怎么整合redisson到spring：

首先引入redisson的包：（如果你还在用手动加jar包的方式，那建议你赶紧学一下maven，用上后会让你有种便秘一星期后突然通便的清爽）

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

接下来新建redisson.xml文件：（可参考wiki：redisson配置教程）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:redisson="http://redisson.org/schema/redisson"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://redisson.org/schema/redisson
       http://redisson.org/schema/redisson/redisson.xsd">
   <!--
    	单台redis机器配置  
    <redisson:client id="redissonClient">
        <redisson:single-server address="192.168.2.100:7000" connection-pool-size="30"/>
    </redisson:client>
     -->
     <!-- redis集群配置 -->
     <redisson:client id="redissonClient" >
     	
        <redisson:cluster-servers scan-interval="10000">   <!-- //scan-interval:集群状态扫描间隔时间，单位是毫秒 -->
        	<redisson:node-address value="192.168.2.100:7000"></redisson:node-address>
        	<redisson:node-address value="192.168.2.100:7001"></redisson:node-address>
        	<redisson:node-address value="192.168.2.100:7002"></redisson:node-address>
        	<redisson:node-address value="192.168.2.100:7003"></redisson:node-address>
        	<redisson:node-address value="192.168.2.100:7004"></redisson:node-address>
        	<redisson:node-address value="192.168.2.100:7005"></redisson:node-address>
        </redisson:cluster-servers>
        
    </redisson:client>
</beans>

然后在Application.xml中引入redisson.xml：<import resource="classpath:/spring/redisson.xml" />     （路径记得自己改哦~）

至此我们redisson的环境就配置好了。接下来就是怎么操作它来操作redis：

首先新建一个工具类RedissonUtils：

package com.basic.common.utils.redis;

import java.util.Map;

import org.redisson.api.RAtomicLong;
import org.redisson.api.RBucket;
import org.redisson.api.RCountDownLatch;
import org.redisson.api.RDeque;
import org.redisson.api.RList;
import org.redisson.api.RLock;
import org.redisson.api.RMap;
import org.redisson.api.RQueue;
import org.redisson.api.RSet;
import org.redisson.api.RSortedSet;
import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;

import com.basic.common.utils.generator.CollectionObjectConvert;
@Service
public class RedissonUtils{
    
    
    /** 
     * 获取字符串对象 
     * @param redisson 
     * @param t 
     * @param objectName 
     * @return 
     */  
    public static <T> RBucket<T> getRBucket(RedissonClient redissonClient,String objectName){  
        RBucket<T> bucket=redissonClient.getBucket(objectName);  
        return bucket;  
    }  
      
    /** 
     * 获取Map对象 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static <K,V> RMap<K, V> getRMap(RedissonClient redissonClient,String objectName){  
        RMap<K, V> map=redissonClient.getMap(objectName);  
        return map;  
    }  
      
    /** 
     * 获取有序集合 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static <V> RSortedSet<V> getRSortedSet(RedissonClient redissonClient,String objectName){  
        RSortedSet<V> sortedSet=redissonClient.getSortedSet(objectName);  
        return sortedSet;  
    }  
      
    /** 
     * 获取集合 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static <V> RSet<V> getRSet(RedissonClient redissonClient,String objectName){  
        RSet<V> rSet=redissonClient.getSet(objectName);  
        return rSet;  
    }  
      
    /** 
     * 获取列表 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static <V> RList<V> getRList(RedissonClient redissonClient,String objectName){  
        RList<V> rList=redissonClient.getList(objectName);  
        return rList;  
    }  
      
    /** 
     * 获取队列 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static <V> RQueue<V> getRQueue(RedissonClient redissonClient,String objectName){  
        RQueue<V> rQueue=redissonClient.getQueue(objectName);  
        return rQueue;  
    }  
      
    /** 
     * 获取双端队列 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static <V> RDeque<V> getRDeque(RedissonClient redissonClient,String objectName){  
        RDeque<V> rDeque=redissonClient.getDeque(objectName);  
        return rDeque;  
    }  
      
    /** 
     * 此方法不可用在Redisson 1.2 中  
     * 在1.2.2版本中 可用 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    /** 
    public <V> RBlockingQueue<V> getRBlockingQueue(Redisson redisson,String objectName){ 
        RBlockingQueue rb=redisson.getBlockingQueue(objectName); 
        return rb; 
    }*/  
      
    /** 
     * 获取锁 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static RLock getRLock(RedissonClient redissonClient,String objectName){  
        RLock rLock=redissonClient.getLock(objectName);  
        return rLock;  
    }  
      
    /** 
     * 获取原子数 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static RAtomicLong getRAtomicLong(RedissonClient redissonClient,String objectName){  
        RAtomicLong rAtomicLong=redissonClient.getAtomicLong(objectName);  
        return rAtomicLong;  
    }  
      
    /** 
     * 获取记数锁 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static RCountDownLatch getRCountDownLatch(RedissonClient redissonClient,String objectName){  
        RCountDownLatch rCountDownLatch=redissonClient.getCountDownLatch(objectName);  
        return rCountDownLatch;  
    }  
      
    /** 
     * 获取消息的Topic 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public static <M> RTopic<M> getRTopic(RedissonClient redissonClient,String objectName){  
         RTopic<M> rTopic=redissonClient.getTopic(objectName);  
         return rTopic;  
    }  
    
    
}

然后我们需要在调用RedissonUtils的类中依赖进RedissonClient 

@Autowired  

private RedissonClient redisson;

只后便可以对redis进行操作啦

RMap<String, Object> map = RedissonUtils.getRMap(redisson,key);

map.put("key","value");     调用到这个语句的同时就已经对redis中的数据进行了修改。 


注意！redis最好是3.0以上的，官方发布的版本，不然会出现莫名其妙的错误

spring整合Redisson
weixin_43926757的博客
05-13 856
Redisson 分布式锁
Redisson 整合 Spring Cache
joy_pan的博客
08-07 2430
Redisson 官方文档写的很详细了：https://github.com/redisson/redisson/wiki/目录 参考第14.2章 这里主要描述遇到的问题： 序列化 Caused by: java.lang.RuntimeException: Class com.xx.response.MemberVO does not implement Serializable or exte...
Spring整合redisson实现分布式锁 - redisson-all-2.10.5.jar
08-09
Spring整合redisson实现分布式锁,用到的redisson-all-2.10.5.jar
如何在 Java 中优雅地使用 Redisson 实现分布式锁
最新发布
kersixy的博客
06-07 1133
分布式系统中，节点并发访问共享资源可能导致数据一致性问题。分布式锁是常见的解决方案，可确保操作原子性。Redisson是基于Redis的Java分布式对象库，提供多种分布式同步工具，包括分布式锁。Redisson与Redis（实时数据平台）和Valkey兼容，是Java实现实时数据处理的理想选择。
Spring整合Redisson(全是步骤，没有原理）
一歪风的博客
03-07 1954
在applicationContext.xml文件中添加对应redis模式的配置（单机，哨兵和集群模式）
Spring集成Redisson及存取几种基本类型数据
LoveTalk的博客
10-14 1662
在Spring boot中使用Redisson存取几种类型的方法(多种方法实现,附带区别讲解)
redisson-spring-boot-starter
03-18
`redisson-spring-boot-starter` 是一个基于 Redis 的 Java 框架，它与 Spring Boot 整合，简化了在 Spring Boot 应用中使用 Redis 的过程。这个项目的目标是帮助开发者快速、便捷地接入 Redis 数据库服务，提供丰富...
【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); } ...
Redisson和Spring Boot 结合的案例
步子哥的博客
04-01 1091
定义一个@RedisLock注解，用于标记需要加锁的方法。通过上述步骤，我们成功地将Redisson与Spring Boot结合起来，实现了一个简单的分布式锁功能。开发者只需在方法上添加@RedisLock注解，并设置相应的参数，就可以控制并发访问，避免数据不一致的问题。这种机制在处理共享资源或执行幂等性操作时非常有用。同时，使用注解的方式也让代码更加简洁和易于维护。
redisson教程java,SpringBoot整合Redisson实战（通过redisson-spring-boot-starter）
weixin_35244067的博客
03-12 1938
SpringBoot整合Redisson实战(通过redisson-spring-boot-starter)点进来看整合的小伙伴肯定都了解Redisson的概念和背景了，这里就直接开始；SpringBoot整合Redisson有个比较好用的starter包就是redisson-spring-boot-starter，这也是官方比较推荐的配置方式，本文就使用redisson-spring-boot-...
SpringBoot集成Redisson
qq_38254635的博客
08-18 8645
Redisson
Spring Boot整合Redisson的两种方式
涛哥是个大帅比
04-24 1万+
Redis是一个开源的内存数据库，支持多种数据类型，如字符串、哈希、列表、集合和有序集合等，常用于缓存、消息队列、计数器、分布式锁和搜索等应用场景。Redisson则是一个基于Redis实现的Java驻内存数据网格，提供了一系列分布式的Java常用对象和多种锁机制，以及分布式服务，使开发者能更集中于处理业务逻辑。Redisson不支持字符串操作、排序、事务、管道、分区等Redis特性，但Redisson 提供了许多其他功能，如分布式闭锁、分布式计数器、分布式信号量等。
springboot整合redisson
qq_37170583的博客
12-12 2891
01 搭建redis服务 我是在自己的云服务通过docker搭建了一个单机的redis服务 docker run -d --rm --name redis5 -p 6379:6379 redis --requirepass "123456" 02 创建应用 1.在pom.xml文件导入redisson依赖 <dependency> <groupId>org.red...
Spring Boot集成Redisson
囚徒之困
06-24 2132
Spring Boot集成Redisson
Spring整合redisson实现分布式锁
麦叔
08-09 958
一.你需要准备 spring-4.1.7.RELEASE.jar redisson-all-2.10.5.jar 在整合redisson之前,我们是在你的项目已经整合了redis的基础上进行的,关于spring整合redis,我们这里不再赘述; 二.整合redisson 2.1 Redisson配置类 import org.redisson.Redisson; import org.redi...
spring 集成redisson
bohu83的博客
12-24 2212
一 背景 一定压力下，Redis的主从结构还是容易出问题，升级到Redis集群模式会提高性能。 如何平滑升级是需要重点考虑的。这里不展开，项目中升级遇到新项目springboot.老项目spring。这里看下如何集成。 二 xml 整合 首先推荐官网，看懂官网就不用看我啰嗦了。 https://github.com/redisson/redisson/wiki/14.-%E...
SpringBoot整合Redisson（操作五种数据类型）
2403_86763612的博客
10-14 994
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
Spring Boot 整合Redisson
qq_28014809的博客
09-15 762
版本说明 spring-boot: 2.3.5.RELEASE redisson: 3.16.2 引入依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</artifactId> <version>3.16.2</ver
Redisson与SpringCache
03-18
### 关于 Redisson 与 Spring Cache 的集成 Redisson 是一个用于 Java 平台的高级分布式工具包，它实现了许多常用的接口并提供了丰富的功能。通过 Redisson 可以更方便地管理和操作 Redis 数据库[^4]。 #### 集成 Redisson 到 Spring Cache 为了将 Redisson 整合到 Spring Cache 中，可以通过以下方式进行设置： 1. **引入依赖** 在项目的 `pom.xml` 文件中添加 Redisson 和 Spring Cache 所需的相关依赖项。 ```xml <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-cache</artifactId> <version>3.17.0</version> </dependency> <!-- 如果使用的是 spring-boot-starter-data-redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 2. **配置 Redisson 客户端** 创建 RedissonClient 实例并通过 YAML 或者 JSON 配置文件初始化连接参数。 ```java @Bean(destroyMethod = "shutdown") public RedissonClient redisson() throws IOException { Config config = new Config(); config.useSingleServer().setAddress("redis://127.0.0.1:6379"); return Redisson.create(config); } ``` 3. **启用缓存支持** 使用 `@EnableCaching` 注解开启 Spring Cache 功能，并指定自定义的 RedisCacheManager。 ```java import org.redisson.spring.cache.RedissonSpringCacheManager; import org.springframework.context.annotation.Bean; @Configuration @EnableCaching public class CacheConfig { private final RedissonClient redissonClient; public CacheConfig(RedissonClient redissonClient) { this.redissonClient = redissonClient; } @Bean public RedissonSpringCacheManager cacheManager() { return new RedissonSpringCacheManager(redissonClient); } } ``` 这样就可以利用 Redisson 提供的功能来增强 Spring Cache 行为[^5]。 --- ### Redisson 与 Spring Cache 对比分析 | 特性 | Redisson | Spring Cache | |-------------------------|------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------| | **核心定位** | 分布式对象存储解决方案 | 缓存抽象框架 | | **易用程度** | 更加灵活强大，提供多种数据结构的支持 | 较简单直观，专注于声明式缓存管理 | | **性能表现** | 支持锁机制、发布订阅等功能 | 主要针对读写优化 | | **扩展能力** | 内建众多特性如消息队列、计数器 | 能够与其他第三方组件配合 | 尽管两者都可以用来处理基于内存的数据访问需求，但是它们的设计目标有所不同。如果仅考虑简单的键值对存储场景，则可能倾向于采用 Spring Cache；而当涉及到更多复杂的业务逻辑时（比如分布式锁），则推荐选用 Redisson[^6]。 --- ### 示例代码展示 下面是一个结合了 Redisson 和 Spring Cache 的例子： ```java @Service public class UserService { @Autowired private UserRepository userRepository; @Cacheable(value = "users", key = "#id", unless = "#result == null") public User getUserById(Long id){ System.out.println("Fetching from database..."); return userRepository.findById(id).orElse(null); } } ``` 此片段展示了如何借助注解形式快速实现用户信息查询过程中的结果缓存效果[^7]。 ---
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

麦田小猪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值