spring整合redisson配置

最新推荐文章于 2024-07-11 15:46:34 发布
最新推荐文章于 2024-07-11 15:46:34 发布
阅读量8.2k 收藏 13
点赞数 2
分类专栏： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36042938/article/details/105827726
版权

配置方式

redis的部署方式有单节点部署、哨兵方式部署、集群方式部署3种方式

各种配置方式可以去看xsd文件：redisson-1.1.xsd

<xsd:element name="single-server"> // 单节点
<xsd:element name="sentinel-servers"> // 哨兵
<xsd:element name="cluster-servers"> // 集群
<xsd:element name="master-slave-servers"> // 主从

等其他方式

单节点配置standalone

单纯的java代码，基于单节点部署为了保证数据的备份，一般会添加一个节点作为slave来备份master节点上的数据

//创建配置  
Config config = new Config();  
//指定使用单节点部署方式  
config.useSingleServer().setAddress("redis://127.0.0.1:6379");  
//创建客户端(发现这一非常耗时，基本在2秒-4秒左右)  
RedissonClient redisson = Redisson.create(config);  
  
//首先获取redis中的key-value对象，key不存在没关系  
RBucket<String> keyObject = redisson.getBucket("key");  
//如果key存在，就设置key的值为新值value  
//如果key不存在，就设置key的值为value  
keyObject.set("value");  
  
//最后关闭RedissonClient  
redisson.shutdown();

spring整合pom

<!--redisson-->  
<dependency>  
    <groupId>org.redisson</groupId>  
    <artifactId>redisson</artifactId>  
    <version>2.10.4</version>  
</dependency> 
<!--redis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>1.7.1.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.7.1.RELEASE</version>
</dependency>

spring整合redisson.xml

    <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">  
        <redisson:client id="standalone" name="aliasName1,aliasName2">  
            <redisson:single-server address="redis://127.0.0.1:6379" />  
        </redisson:client>  
    </beans>

哨兵配置sentinel

纯java代码

//创建配置  
Config config = new Config();  
//指定使用哨兵部署方式  
config.useSentinelServers()  
    //设置sentinel.conf配置里的sentinel别名  
    //比如sentinel.conf里配置为sentinel monitor my-sentinel-name 127.0.0.1 6379 2,那么这里就配置my-sentinel-name  
    .setMasterName("my-sentinel-name")  
    //这里设置sentinel节点的服务IP和端口，sentinel是采用Paxos拜占庭协议，一般sentinel至少3个节点  
    //记住这里不是配置redis节点的服务端口和IP，sentinel会自己把请求转发给后面monitor的redis节点  
    .addSentinelAddress("redis://127.0.0.1:26379")  
    .addSentinelAddress("redis://127.0.0.1:26389")  
    .addSentinelAddress("redis://127.0.0.1:26399");  
  
//创建客户端(发现这一非常耗时，基本在2秒-4秒左右)  
RedissonClient redisson = Redisson.create(config);  
//首先获取redis中的key-value对象，key不存在没关系  
RBucket<String> keyObject = redisson.getBucket("key");  
//如果key存在，就设置key的值为新值value  
//如果key不存在，就设置key的值为value  
keyObject.set("value");  
  
//最后关闭RedissonClient  
redisson.shutdown();

spring整合redis和redisson的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans" 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://redisson.org/schema/redisson http://redisson.org/schema/redisson/redisson.xsd">

    <!-- 构造JedisConnectionFactory实例，注入池配置poolConfig和哨兵配置sentinelConfig-->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <!--<constructor-arg index="0" ref="redisSentinelConfiguration"/>-->
        <!--<constructor-arg index="1" ref="jedisPoolConfig"/>-->
        <constructor-arg ref="redisSentinelConfiguration"/>
        <property name="poolConfig" ref="jedisPoolConfig"/>
        <property name="database" value="${redis.database}"/>
    </bean>

    <!-- 配置JedisPoolConfig-->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="minIdle" value="${redis.minIdle}"/>
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxTotal" value="${redis.maxTotal}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        <property name="testWhileIdle" value="${redis.testWhileIdle}"/>
        <property name="testOnReturn" value="${redis.testOnReturn}"/>
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/>
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>
    </bean>

    <!-- 配置RedisSentinelConfiguration-->
    <bean id="redisSentinelConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
        <property name="master">
            <bean class="org.springframework.data.redis.connection.RedisNode">
                <property name="name" value="${redis.masterName}"/>
            </bean>
        </property>
        <property name="sentinels">
            <set>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg index="0" value="${redis.host}"/>
                    <constructor-arg index="1" value="${redis.port}"/>
                </bean>
            </set>
        </property>
    </bean>

    <!-- 用于缓存对象-->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
        <!-- key -->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <!-- value -->
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
    </bean>

    <!-- 用于缓存字符串-->
    <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
    </bean>

    <redisson:client id="redissonClient">
        <!--master-name为redis的主节点名称-->
        <redisson:sentinel-servers master-name="mymaster">
            <!-- 可以配置多个 -->
            <redisson:sentinel-address value="redis://172.17.46.11:26379" />
        </redisson:sentinel-servers>
    </redisson:client>

</beans>

使用

    @Autowired
    @Lazy
    private RedissonClient redissonClient; 


   /**
     * @param key 具体键值
     * @return 锁对象
     */
    public RReadWriteLock getLock(String key) {
        return redissonClient.getReadWriteLock(key);
    }

集群配置cluster

纯java代码

//创建配置  
Config config = new Config();  
//指定使用集群部署方式  
config.useClusterServers()  
    // 集群状态扫描间隔时间，单位是毫秒  
    .setScanInterval(2000)   
    //cluster方式至少6个节点(3主3从，3主做sharding，3从用来保证主宕机后可以高可用)  
    .addNodeAddress("redis://127.0.0.1:6379" )  
    .addNodeAddress("redis://127.0.0.1:6380")  
    .addNodeAddress("redis://127.0.0.1:6381")  
    .addNodeAddress("redis://127.0.0.1:6382")  
    .addNodeAddress("redis://127.0.0.1:6383")  
    .addNodeAddress("redis://127.0.0.1:6384");  
//创建客户端(发现这一非常耗时，基本在2秒-4秒左右)  
RedissonClient redisson = Redisson.create(config);  
  
//首先获取redis中的key-value对象，key不存在没关系  
RBucket<String> keyObject = redisson.getBucket("key");  
//如果key存在，就设置key的值为新值value  
//如果key不存在，就设置key的值为value  
keyObject.set("value");  
  
//最后关闭RedissonClient  
redisson.shutdown();

spring整合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:redisson="http://redisson.org/schema/redisson"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://redisson.org/schema/redisson http://redisson.org/schema/redisson/redisson.xsd">

    <!--  Redis 连接池配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="minIdle" value="${redis.minIdle}"/>
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxTotal" value="${redis.maxTotal}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        <property name="testWhileIdle" value="${redis.testWhileIdle}"/>
        <property name="testOnReturn" value="${redis.testOnReturn}"/>

        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/>
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>
        <property name="timeBetweenEvictionRunsMillis" value="30000"/>
    </bean>

    <!-- jedisCluster 配置 -->
    <!-- 自定义的工厂类，实现了FactoryBean<JedisCluster>接口 -->
    <bean id="jedisCluster" class="com.xxxxx.JedisClusterFactory">
        <!-- address： 集群配置 -->
        <property name="address" value="${redisColony.host}"/>
        <!-- timeout： 连接超时时间 -->
        <property name="timeout" value="100000"/>
        <!-- maxRedirections： 最大重定向 -->
        <property name="maxRedirections" value="5"/>
        <!-- 连接池 -->
        <property name="genericObjectPoolConfig" ref="poolConfig"/>
    </bean>

    <!--redisson的实例 -->
    <redisson:client id="redissonClient">
        <redisson:cluster-servers>
            <!-- 节点地址同redis集群的节点 -->
            <redisson:node-address value="${redisColony.host1}"/>
            <redisson:node-address value="${redisColony.host2}"/>
            <redisson:node-address value="${redisColony.host3}"/>
            <redisson:node-address value="${redisColony.host4}"/>
            <redisson:node-address value="${redisColony.host5}"/>
            <redisson:node-address value="${redisColony.host6}"/>
        </redisson:cluster-servers>
    </redisson:client>


</beans>

properties文件

redisColony.host = 172.17.46.11:36379,172.17.46.11:36381,172.17.45.12:36379,172.17.45.12:36381,172.17.45.13:36379,172.17.45.13:36381
redis.timeOut = 100000
redis.redirection = 5

redisColony.host1 = redis://172.17.46.11:36379
redisColony.host2 = redis://172.17.46.11:36381
redisColony.host3 = redis://172.17.45.12:36379
redisColony.host4 = redis://172.17.45.12:36381
redisColony.host5 = redis://172.17.45.13:36379
redisColony.host6 = redis://172.17.45.13:36381

使用方式与哨兵配置方式相同，@Autowired注入即可

主从部署方式(master/slave)

纯java代码

    //创建配置  
    Config config = new Config();  
    //指定使用主从部署方式  
    config.useMasterSlaveServers()  
        //设置redis主节点  
        .setMasterAddress("redis://127.0.0.1:6379")  
        //设置redis从节点  
        .addSlaveAddress("redis://127.0.0.1:6380", "redis://127.0.0.1:6381");  
    //创建客户端(发现这一非常耗时，基本在2秒-4秒左右)  
    RedissonClient redisson = Redisson.create(config);  
      
    //首先获取redis中的key-value对象，key不存在没关系  
    RBucket<String> keyObject = redisson.getBucket("key");  
    //如果key存在，就设置key的值为新值value  
    //如果key不存在，就设置key的值为value  
    keyObject.set("value");  
      
    //最后关闭RedissonClient  
    redisson.shutdown();

spring整合redisson.xml

<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">  
    <redisson:client id="masterSlave">  
        <redisson:master-slave-servers master-address="redis://127.0.0.1:6379">  
            <redisson:slave-address value="redis://127.0.0.1:6380" />  
            <redisson:slave-address value="redis://127.0.0.1:6381" />  
        </redisson:master-slave-servers>  
    </redisson:client>  
</beans>

 

小甄笔记
关注
专栏目录
spring整合Redisson
weixin_43926757的博客
05-13 803
Redisson 分布式锁
【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
dgqvhtlwq472235338的博客
03-09 187
原文：http://blog.csdn.net/wang_keng/article/details/73549274 首先讲下什么是Redisson：Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。（摘自redisson的wiki：wiki地址）...
SpringBoot使用Redisson操作Redis及使用场景实战
最新发布
ToBeMaybe_的博客
07-11 3207
从 spring-boot 2.x 版本开始，spring-boot-data-redis 默认使用 Lettuce 客户端操作数据。
Spring整合Redisson(全是步骤，没有原理）
一歪风的博客
03-07 1748
在applicationContext.xml文件中添加对应redis模式的配置（单机，哨兵和集群模式）
Spring整合redisson实现分布式锁 - redisson-all-2.10.5.jar
08-09
Spring整合redisson实现分布式锁,用到的redisson-all-2.10.5.jar
redis的服务端，客户端，整合spring配置文件
11-18
文件内包含redis单机版安装步骤，redis集群安装步骤，redis服务端，redis客户端，redis与spring整合配置文件，处理json的工具类等全套资源
Springboot-Redisson - 1.简介和配置
yueerba126的博客
10-27 6711
Redisson是一个基于Java的Redis客户端库，它提供了许多有用的功能和工具，使得在使用Redis时更加方便和强大。Redisson可以与Spring Boot集成，以简化在Spring应用程序中使用Redis的过程。：Redisson允许您将Java对象保存在Redis中，这些对象可以通过Redis的分布式特性进行管理和共享。这意味着您可以使用Redis作为分布式缓存和数据存储，而不必手动处理序列化和反序列化。
spring整合redisson
01-26
Spring整合Redisson可以通过Redisson框架为Spring应用程序提供分布式锁、分布式集合、分布式对象以及分布式服务等功能。首先需要在Spring的配置文件中配置Redisson客户端，指明连接的Redis服务器地址和端口号。然后...
Spring boot 整合 redisson ，spring-session
不会写博客
09-28 5389
Spring boot 整合 redisson ，spring-session整合Redisson整合Spring Session会话管理器参考文章 整合Redisson 在项目中引入封装好的redisson-spring-boot-starter依赖（也可以根据封装代码或者官网自己实现，从简单角度建议根据封装代码实现自己需要的） &amp;lt;dependency&amp;gt; &amp;lt;g...
springboot整合redisson（一）搭建Redisson环境
2401_84009749的博客
04-03 413
虽然面试套路众多，但对于技术面试来说，主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同，没有规律可循。上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料。
spring boot整合redisson
lucky_ly的博客
12-08 2371
1.springboot 整合redisson，也依赖于spring-boot-starter-data-redis。 1.引入依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent&...
springboot redissionl配置
李振伟的博客
08-19 1026
【代码】springboot redissionl配置。
Spring集成Redisson配置RedissonAutoConfiguration初始化源码解析
进击的小白
10-26 8852
Redisson数据源初始化源码 ，当前版本3.13.6 /** * Copyright (c) 2013-2020 Nikita Koksharov * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License
SpringBoot集成redisson操作redis
quanzhan_King的博客
05-31 6222
该对象的最大容量受Redis限制，最大元素数量是4294967295个。基于Redisson的分布式Set结构的RSet Java对象实现了java.util.Set接口，通过元素的互相状态比较保证了每个元素的唯一性，该对象的最大容量受Redis限制，最大元素数量是4294967295个。基于Redisson的分布式列表 List 结构的RList Java对象在实现了java.util.List接口的同时，确保了元素插入时的顺序，该对象的最大容量受Redis限制，最大元素数量是4294967295个。
Spring Boot整合Redisson的两种方式
涛哥是个大帅比
04-24 5643
Redis是一个开源的内存数据库，支持多种数据类型，如字符串、哈希、列表、集合和有序集合等，常用于缓存、消息队列、计数器、分布式锁和搜索等应用场景。Redisson则是一个基于Redis实现的Java驻内存数据网格，提供了一系列分布式的Java常用对象和多种锁机制，以及分布式服务，使开发者能更集中于处理业务逻辑。Redisson不支持字符串操作、排序、事务、管道、分区等Redis特性，但Redisson 提供了许多其他功能，如分布式闭锁、分布式计数器、分布式信号量等。
Spring Boot 整合Redisson
qq_28014809的博客
09-15 651
版本说明 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
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值