Redis客户端redisson实战

最新推荐文章于 2023-07-13 16:38:05 发布
最新推荐文章于 2023-07-13 16:38:05 发布
阅读量248 收藏
点赞数
文章标签： 数据库 netty json
原文链接：https://my.oschina.net/LucasZhu/blog/1816320
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

    

redis 学习问题总结

http://aperise.iteye.com/blog/2310639

ehcache memcached redis 缓存技术总结

http://aperise.iteye.com/blog/2296219

redis-stat 离线安装

http://aperise.iteye.com/blog/2310254

redis  cluster 非ruby方式启动

http://aperise.iteye.com/blog/2310254

redis-sentinel安装部署

http://aperise.iteye.com/blog/2342693

spring-data-redis使用

 http://aperise.iteye.com/blog/2342615

redis客户端redisson实战

http://blog.csdn.net/zilong_zilong/article/details/78252037

redisson-2.10.4源代码分析

http://blog.csdn.net/zilong_zilong/article/details/78609423

tcmalloc jemalloc libc选择

http://blog.csdn.net/u010994304/article/details/49906819

 

 redis客户端redisson实战

1.前言

    Redisson是一个基于java编程框架netty进行扩展了的redis，想了解Redisson源码首先你必须熟悉netty网络编程框架。

    Redisson目前分开源版本和商业版(Redisson PRO),所以选择的时候请谨慎。（Map）和集（Set）数据分片功能仅限于Redisson PRO版本才有，另外Redis部署工具和集群管理工具功能仅限于Redisson PRO版本才有。关于商业版和开源版本的区别和商业版收费标准详见官网(https://redisson.pro/)  

2.maven项目集成redisson

    根据自己JDK环境，JDK 1.8+以上请选择3.5.4版本，JDK 1.6+以上请选择2.10.4版本 

<!-- JDK 1.8+ compatible -->  
<dependency>  
   <groupId>org.redisson</groupId>  
   <artifactId>redisson</artifactId>  
   <version>3.5.4</version>  
</dependency>    
  
<!-- JDK 1.6+ compatible -->  
<dependency>  
   <groupId>org.redisson</groupId>  
   <artifactId>redisson</artifactId>  
   <version>2.10.4</version>  
</dependency>

3.利用redisson API操作各种redis部署的服务端

    redis的部署方式有单节点部署、哨兵方式部署、集群方式部署3种方式，这3中方式都使用的是原生的redis；

    基于单节点部署为了保证数据的备份，一般会添加一个节点作为slave来备份master节点上的数据，这里就衍生出了主从部署方式；

    云服务商像阿里云、微软云和亚马逊云都基于原生redis做了高可用部署，为了能连接云服务商的redis服务，这里redisson也提供了API操作方式。

    下面以向redis服务端进行操作set key value为例进行说明如何使用redisson的API

3.1 单节点部署方式(standalone)

e9f7811d-2bd4-34dd-bb98-dec22fae4d80.jpg

(1)纯java操作

//创建配置  
Config config = new Config();  
  
//指定编码，默认编码为org.redisson.codec.JsonJacksonCodec  
//之前使用的spring-data-redis，用的客户端jedis，编码为org.springframework.data.redis.serializer.StringRedisSerializer  
//改用redisson后为了之间数据能兼容，这里修改编码为org.redisson.client.codec.StringCodec  
config.setCodec(new org.redisson.client.codec.StringCodec());  
  
//指定使用单节点部署方式  
config.useSingleServer().setAddress("redis://127.0.0.1:6379");  
  
//config.setPassword("password")//设置密码  
config.setConnectionPoolSize(500)//设置对于master节点的连接池中连接数最大为500  
config.setIdleConnectionTimeout(10000)//如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。  
config.setConnectTimeout(30000)//同任何节点建立连接时的等待超时。时间单位是毫秒。  
config.setTimeout(3000)//等待节点回复命令的时间。该时间从命令发送成功时开始计时。  
config.setPingTimeout(30000)  
config.setReconnectionTimeout(3000)//当与某个节点的连接断开时，等待与其重新建立连接的时间间隔。时间单位是毫秒。  
  
//创建客户端(发现创建RedissonClient非常耗时，基本在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();

(2)spring集成操作
pom.xml

<!--redisson-->  
<dependency>  
    <groupId>org.redisson</groupId>  
    <artifactId>redisson</artifactId>  
    <version>2.10.4</version>  
</dependency>  
<!--spring-->  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-core</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-beans</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-context</artifactId>  
    <version>4.2.8.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">    
    <bean id="stringCodec" class="org.redisson.client.codec.StringCodec"></bean>  
    <redisson:client id="standalone"   
                     name="aliasName1,aliasName2"  
                     codec-ref="stringCodec">    
        <redisson:single-server address="redis://127.0.0.1:6379"  
                                connection-pool-size="500"  
                                idle-connection-timeout="10000"  
                                connect-timeout="10000"  
                                timeout="3000"  
                                ping-timeout="30000"  
                                reconnection-timeout="30000"  
                                database="0"/>    
    </redisson:client>    
</beans>

 SpringRedissonTest.java

import org.redisson.api.RBucket;  
import org.redisson.api.RedissonClient;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
public class SpringRedissonTest {  
    public static void main(String[] args) {  
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-redisson.xml");  
        RedissonClient redisson = (RedissonClient) applicationContext.getBean("standalone");  
        // 首先获取redis中的key-value对象，key不存在没关系  
        RBucket<String> keyObject = redisson.getBucket("key");  
        // 如果key存在，就设置key的值为新值value  
        // 如果key不存在，就设置key的值为value  
        keyObject.set("value");  
    }  
}

3.2 哨兵部署方式(sentinel)

96816f65-d2bd-3eb2-9df8-294c55dd14a3.jpg

(1)纯java操作

//创建配置  
Config config = new Config();  
  
//指定编码，默认编码为org.redisson.codec.JsonJacksonCodec  
//之前使用的spring-data-redis，用的客户端jedis，编码为org.springframework.data.redis.serializer.StringRedisSerializer  
//改用redisson后为了之间数据能兼容，这里修改编码为org.redisson.client.codec.StringCodec  
config.setCodec(new org.redisson.client.codec.StringCodec());  
  
//指定使用哨兵部署方式  
config.useSentinelServers()  
<span style="white-space:pre">  </span>//设置sentinel.conf配置里的sentinel别名  
<span style="white-space:pre">  </span>//比如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");  
      
//config.setPassword("password")//设置密码  
config.setMasterConnectionPoolSize(500)//设置对于master节点的连接池中连接数最大为500  
config.setSlaveConnectionPoolSize(500)//设置对于slave节点的连接池中连接数最大为500  
config.setIdleConnectionTimeout(10000)//如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。  
config.setConnectTimeout(30000)//同任何节点建立连接时的等待超时。时间单位是毫秒。  
config.setTimeout(3000)//等待节点回复命令的时间。该时间从命令发送成功时开始计时。  
config.setPingTimeout(30000)  
config.setReconnectionTimeout(3000)//当与某个节点的连接断开时，等待与其重新建立连接的时间间隔。时间单位是毫秒。  
  
//创建客户端(发现这一非常耗时，基本在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();

(2)spring集成操作
 pom.xml

<!--redisson-->  
<dependency>  
    <groupId>org.redisson</groupId>  
    <artifactId>redisson</artifactId>  
    <version>2.10.4</version>  
</dependency>  
<!--spring-->  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-core</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-beans</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-context</artifactId>  
    <version>4.2.8.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">  
<bean id="stringCodec" class="org.redisson.client.codec.StringCodec"></bean>  
<redisson:client id="sentinel" codec-ref="stringCodec">  
    <redisson:sentinel-servers master-name="my-sentinel-name"  
                                slaveConnectionPoolSize="500"  
                                masterConnectionPoolSize="500"  
                                idle-connection-timeout="10000"  
                                connect-timeout="10000"  
                                timeout="3000"  
                                ping-timeout="1000"  
                                reconnection-timeout="3000"  
                                database="0">  
        <redisson:sentinel-address value="redis://127.0.0.1:26379" />  
        <redisson:sentinel-address value="redis://127.0.0.1:26389" />  
        <redisson:sentinel-address value="redis://127.0.0.1:26399" />  
    </redisson:sentinel-servers>  
</redisson:client>  
</beans>

SpringRedissonTest.java

import org.redisson.api.RBucket;  
import org.redisson.api.RedissonClient;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
public class SpringRedissonTest {  
    public static void main(String[] args) {  
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-redisson.xml");  
        RedissonClient redisson = (RedissonClient) applicationContext.getBean("sentinel");  
        // 首先获取redis中的key-value对象，key不存在没关系  
        RBucket<String> keyObject = redisson.getBucket("key");  
        // 如果key存在，就设置key的值为新值value  
        // 如果key不存在，就设置key的值为value  
        keyObject.set("value");  
    }  
}

3.3 集群方式(cluster)

bd9c5a2f-5d7d-3460-8642-37b143343b2e.jpg

(1)纯java操作

//创建配置  
Config config = new Config();  
  
//指定编码，默认编码为org.redisson.codec.JsonJacksonCodec  
//之前使用的spring-data-redis，用的客户端jedis，编码为org.springframework.data.redis.serializer.StringRedisSerializer  
//改用redisson后为了之间数据能兼容，这里修改编码为org.redisson.client.codec.StringCodec  
config.setCodec(new org.redisson.client.codec.StringCodec());  
  
//指定使用集群部署方式  
config.useClusterServers()  
<span style="white-space:pre">  </span>// 集群状态扫描间隔时间，单位是毫秒  
    .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");  
      
//config.setPassword("password")//设置密码  
config.setMasterConnectionPoolSize(500)//设置对于master节点的连接池中连接数最大为500  
config.setSlaveConnectionPoolSize(500)//设置对于slave节点的连接池中连接数最大为500  
config.setIdleConnectionTimeout(10000)//如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。  
config.setConnectTimeout(30000)//同任何节点建立连接时的等待超时。时间单位是毫秒。  
config.setTimeout(3000)//等待节点回复命令的时间。该时间从命令发送成功时开始计时。  
config.setPingTimeout(30000)  
config.setReconnectionTimeout(3000)//当与某个节点的连接断开时，等待与其重新建立连接的时间间隔。时间单位是毫秒。  
  
//创建客户端(发现创建RedissonClient非常耗时，基本在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();

(2)spring集成操作
pom.xml

<!--redisson-->  
<dependency>  
    <groupId>org.redisson</groupId>  
    <artifactId>redisson</artifactId>  
    <version>2.10.4</version>  
</dependency>  
<!--spring-->  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-core</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-beans</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-context</artifactId>  
    <version>4.2.8.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">  
    <bean id="stringCodec" class="org.redisson.client.codec.StringCodec"></bean>  
	<redisson:client id="cluster" codec-ref="stringCodec">  
	<redisson:cluster-servers slaveConnectionPoolSize="500"   
	masterConnectionPoolSize="500"   
	idle-connection-timeout="10000"    
	connect-timeout="10000"    
	timeout="3000"    
	ping-timeout="1000"    
	reconnection-timeout="3000"    
	database="0">    
	<redisson:node-address value="redis://127.0.0.1:6379" />  
	<redisson:node-address value="redis://127.0.0.1:6380" />  
	<redisson:node-address value="redis://127.0.0.1:6381" />  
	<redisson:node-address value="redis://127.0.0.1:6382" />  
	<redisson:node-address value="redis://127.0.0.1:6383" />  
	<redisson:node-address value="redis://127.0.0.1:6384" />  
	</redisson:cluster-servers>  
</redisson:client>  
</beans>

SpringRedissonTest.java

import org.redisson.api.RBucket;  
import org.redisson.api.RedissonClient;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
public class SpringRedissonTest {  
    public static void main(String[] args) {  
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-redisson.xml");  
        RedissonClient redisson = (RedissonClient) applicationContext.getBean("cluster");  
        // 首先获取redis中的key-value对象，key不存在没关系  
        RBucket<String> keyObject = redisson.getBucket("key");  
        // 如果key存在，就设置key的值为新值value  
        // 如果key不存在，就设置key的值为value  
        keyObject.set("value");  
    }  
}

 3.4 主从部署方式(master/slave)

2933de75-89d9-3a8a-b1d4-4427c37412a3.jpg

(1)纯java操作

//创建配置  
Config config = new Config();  
  
//指定编码，默认编码为org.redisson.codec.JsonJacksonCodec  
//之前使用的spring-data-redis，用的客户端jedis，编码为org.springframework.data.redis.serializer.StringRedisSerializer  
//改用redisson后为了之间数据能兼容，这里修改编码为org.redisson.client.codec.StringCodec  
config.setCodec(new org.redisson.client.codec.StringCodec());  
  
//指定使用主从部署方式  
config.useMasterSlaveServers()  
    //设置redis主节点  
    .setMasterAddress("redis://127.0.0.1:6379")  
    //设置redis从节点  
    .addSlaveAddress("redis://127.0.0.1:6380", "redis://127.0.0.1:6381");  
      
//config.setPassword("password")//设置密码  
config.setMasterConnectionPoolSize(500)//设置对于master节点的连接池中连接数最大为500  
config.setSlaveConnectionPoolSize(500)//设置对于slave节点的连接池中连接数最大为500  
config.setIdleConnectionTimeout(10000)//如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。  
config.setConnectTimeout(30000)//同任何节点建立连接时的等待超时。时间单位是毫秒。  
config.setTimeout(3000)//等待节点回复命令的时间。该时间从命令发送成功时开始计时。  
config.setPingTimeout(30000)  
config.setReconnectionTimeout(3000)//当与某个节点的连接断开时，等待与其重新建立连接的时间间隔。时间单位是毫秒。  
  
//创建客户端(发现创建RedissonClient非常耗时，基本在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();

(2)spring集成操作
pom.xml

<!--redisson-->  
<dependency>  
    <groupId>org.redisson</groupId>  
    <artifactId>redisson</artifactId>  
    <version>2.10.4</version>  
</dependency>  
<!--spring-->  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-core</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-beans</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-context</artifactId>  
    <version>4.2.8.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">  
  <bean id="stringCodec" class="org.redisson.client.codec.StringCodec"></bean>    
	<redisson:client id="masterSlave" codec-ref="stringCodec">  
	<redisson:master-slave-servers master-address="redis://127.0.0.1:6379"  
	                                slaveConnectionPoolSize="500"    
	                                masterConnectionPoolSize="500"    
	                                idle-connection-timeout="10000"    
	                                connect-timeout="10000"    
	                                timeout="3000"    
	                                ping-timeout="1000"    
	                                reconnection-timeout="3000"    
	                                database="0">  
	<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>

SpringRedissonTest.java

import org.redisson.api.RBucket;  
import org.redisson.api.RedissonClient;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
public class SpringRedissonTest {  
    public static void main(String[] args) {  
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-redisson.xml");  
        RedissonClient redisson = (RedissonClient) applicationContext.getBean("masterSlave");  
        // 首先获取redis中的key-value对象，key不存在没关系  
        RBucket<String> keyObject = redisson.getBucket("key");  
        // 如果key存在，就设置key的值为新值value  
        // 如果key不存在，就设置key的值为value  
        keyObject.set("value");  
    }  
}

 3.5 云托管部署方式

  这种方式主要解决redis提供商为云服务的提供商的redis连接，比如亚马逊云的AWS ElastiCache和微软云的Azure Redis 缓存

    (1)纯java操作

Config config = new Config();  
  
//指定编码，默认编码为org.redisson.codec.JsonJacksonCodec  
//之前使用的spring-data-redis，用的客户端jedis，编码为org.springframework.data.redis.serializer.StringRedisSerializer  
//改用redisson后为了之间数据能兼容，这里修改编码为org.redisson.client.codec.StringCodec  
config.setCodec(new org.redisson.client.codec.StringCodec());  
  
config.useReplicatedServers()  
<span style="white-space:pre">  </span>// 主节点变化扫描间隔时间  
    .setScanInterval(2000)   
    //设置云服务商的redis服务IP和端口，目前支持亚马逊云的AWS ElastiCache和微软云的Azure Redis 缓存  
    .addNodeAddress("redis://123.57.221.104.1:6379")  
    .addNodeAddress("redis://123.57.221.105:6380")  
    .addNodeAddress("redis://123.57.221.106:6382");  
      
//config.setPassword("password")//设置密码  
config.setMasterConnectionPoolSize(500)//设置对于master节点的连接池中连接数最大为500  
config.setSlaveConnectionPoolSize(500)//设置对于slave节点的连接池中连接数最大为500  
config.setIdleConnectionTimeout(10000)//如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。  
config.setConnectTimeout(30000)//同任何节点建立连接时的等待超时。时间单位是毫秒。  
config.setTimeout(3000)//等待节点回复命令的时间。该时间从命令发送成功时开始计时。  
config.setPingTimeout(30000)  
config.setReconnectionTimeout(3000)//当与某个节点的连接断开时，等待与其重新建立连接的时间间隔。时间单位是毫秒。  
  
//创建客户端(发现创建RedissonClient非常耗时，基本在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();

(2)spring集成操作
pom.xml

<!--redisson-->  
<dependency>  
    <groupId>org.redisson</groupId>  
    <artifactId>redisson</artifactId>  
    <version>2.10.4</version>  
</dependency>  
<!--spring-->  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-core</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-beans</artifactId>  
    <version>4.2.8.RELEASE</version>  
</dependency>  
<dependency>  
    <groupId>org.springframework</groupId>  
    <artifactId>spring-context</artifactId>  
    <version>4.2.8.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">  
  <bean id="stringCodec" class="org.redisson.client.codec.StringCodec"></bean>  
	<redisson:client id="cloud" codec-ref="stringCodec">  
	<redisson:replicated-servers slaveConnectionPoolSize="500"    
	                                masterConnectionPoolSize="500"    
	                                idle-connection-timeout="10000"    
	                                connect-timeout="10000"    
	                                timeout="3000"    
	                                ping-timeout="1000"    
	                                reconnection-timeout="3000"    
	                                database="0">>  
	<redisson:node-address value="redis://123.57.221.104:6379" />  
	<redisson:node-address value="redis://123.57.221.105:6380" />  
	<redisson:node-address value="redis://123.57.221.106:6381" />  
	</redisson:replicated-servers>  
	</redisson:client>  
</beans>

SpringRedissonTest.java

import org.redisson.api.RBucket;  
import org.redisson.api.RedissonClient;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
public class SpringRedissonTest {  
    public static void main(String[] args) {  
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-redisson.xml");  
        RedissonClient redisson = (RedissonClient) applicationContext.getBean("cloud");  
        // 首先获取redis中的key-value对象，key不存在没关系  
        RBucket<String> keyObject = redisson.getBucket("key");  
        // 如果key存在，就设置key的值为新值value  
        // 如果key不存在，就设置key的值为value  
        keyObject.set("value");  
    }  
}

4.Redisson API与原生redis操作命令映射关系

redisson的客户端API操作和以前的jedis稍微不一样的是你首先得获取到某个操作的key-value对象，然后再对其进行操作，比如我想设置key=time，value=20171013这个string的key-value对象，那么从下表首先查询到SET对应的对象为：

e86c1faf-77b7-3a16-9ca5-3452ebf82024.jpg

那么从API操作上你就需要首先获取到RBucket对象，然后调用其3个方法来分别执行set操作,以单节点部署方式举例如下：

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

至于其他的redis命令操作通过哪个对象去操作，你可以通过如下表格查询：

Redis命令Redisson对象方法
AUTHConfig.setPassword();
BITCOUNTRBitSet.cardinality(), RBitSet.cardinalityAsync(), RBitSetReactive.cardinality()
BITOPRBitSet.or(), RBitSet.orAsync(), RBitSetReactive.or();
RBitSet.and(), RBitSet.andAsync(), RBitSetReactive.and();
RBitSet.not();
RBitSet.xor(), RBitSet.xorAsync(), RBitSetReactive.xor()
BITPOSRBitSet.length(), RBitSet.lengthAsync(), RBitSetReactive.length()
BLPOPRBlockingQueue.take(), RBlockingQueue.takeAsync(), RBlockingQueueReactive.take();
RBlockingQueue.poll(), RBlockingQueue.pollAsync(), RBlockingQueueReactive.poll();
RBlockingQueue.pollFromAny(), RBlockingQueue.pollFromAnyAsync(), RBlockingQueueReactive.pollFromAny();
BRPOPRBlockingDeque.takeLast(), RBlockingDeque.takeLastAsync(), RBlockingDequeReactive.takeLast();
BRPOPLPUSHRBlockingQueue.pollLastAndOfferFirstTo(), RBlockingQueue.pollLastAndOfferFirstToAsync(), RBlockingQueueReactive.pollLastAndOfferFirstTo();
CLIENT SETNAMEConfig.setClientName();
CLUSTER INFOClusterNode.info();
CLUSTER KEYSLOTRKeys.getSlot(), RKeys.getSlotAsync(), RKeysReactive.getSlot();
CLUSTER NODESUsed in ClusterConnectionManager
DBSIZERKeys.count(), RKeys.countAsync(), RKeysReactive.count();
DECRRAtomicLong.decrementAndGet(), RAtomicLong.decrementAndGetAsync(), RAtomicLongReactive.decrementAndGetAsync();
DELRObject.delete(), RObject.deleteAsync(), RObjectReactive.delete();
RKeys.delete(), RKeys.deleteAsync();
STRLENRBucket.size(), RBucket.sizeAsync(), RBucketReactive.size();
EVALRScript.eval(), RScript.evalAsync(), RScriptReactive.eval();
CLIENT REPLYRBatch.executeSkipResult();
EVALSHARScript.evalSha(), RScript.evalShaAsync(), RScriptReactive.evalSha();
EXISTSRObject.isExists(), RObject.isExistsAsync(), RObjectReactive.isExists();
FLUSHALLRKeys.flushall(), RKeys.flushallAsync(), RKeysReactive.flushall();
FLUSHDBRKeys.flushdb(), RKeys.flushdbAsync(), RKeysReactive.flushdb();
GEOADDRGeo.add(), RGeo.addAsync(), RGeoReactive.add();
GEODISTRGeo.dist(), RGeo.distAsync(), RGeoReactive.dist();
GEOHASHRGeo.hash(), RGeo.hashAsync(), RGeoReactive.hash();
GEOPOSRGeo.pos(), RGeo.posAsync(), RGeoReactive.pos();
GEORADIUSRGeo.radius(), RGeo.radiusAsync(), RGeoReactive.radius();
RGeo.radiusWithDistance(), RGeo.radiusWithDistanceAsync(), RGeoReactive.radiusWithDistance();
RGeo.radiusWithPosition(), RGeo.radiusWithPositionAsync(), RGeoReactive.radiusWithPosition();
GEORADIUSBYMEMBERRGeo.radius(), RGeo.radiusAsync(), RGeoReactive.radius();
RGeo.radiusWithDistance(), RGeo.radiusWithDistanceAsync(), RGeoReactive.radiusWithDistance();
RGeo.radiusWithPosition(), RGeo.radiusWithPositionAsync(), RGeoReactive.radiusWithPosition();
GETRBucket.get(), RBucket.getAsync(), RBucketReactive.get();
GETBITRBitSet.get(), RBitSet.getAsync(), RBitSetReactive.get();
GETSETRBucket.getAndSet(), RBucket.getAndSetAsync(), RBucketReactive.getAndSet();
RAtomicLong.getAndSet(), RAtomicLong.getAndSetAsync(), RAtomicLongReactive.getAndSet();
RAtomicDouble.getAndSet(), RAtomicDouble.getAndSetAsync(), RAtomicDoubleReactive.getAndSet();
HDELRMap.fastRemove(), RMap.fastRemoveAsync(), RMapReactive.fastRemove();
HEXISTSRMap.containsKey(), RMap.containsKeyAsync(), RMapReactive.containsKey();
HGETRMap.get(), RMap.getAsync(), RMapReactive.get();
HSTRLENRMap.valueSize(), RMap.valueSizeAsync(), RMapReactive.valueSize();
HGETALLRMap.readAllEntrySet(), RMap.readAllEntrySetAsync(), RMapReactive.readAllEntrySet();
HINCRBYRMap.addAndGet(), RMap.addAndGetAsync(), RMapReactive.addAndGet();
HINCRBYFLOATRMap.addAndGet(), RMap.addAndGetAsync(), RMapReactive.addAndGet();
HKEYSRMap.readAllKeySet(), RMap.readAllKeySetAsync(), RMapReactive.readAllKeySet();
HLENRMap.size(), RMap.sizeAsync(), RMapReactive.size();
HMGETRMap.getAll(), RMap.getAllAsync(), RMapReactive.getAll();
HMSETRMap.putAll(), RMap.putAllAsync(), RMapReactive.putAll();
HSETRMap.put(), RMap.putAsync(), RMapReactive.put();
HSETNXRMap.fastPutIfAbsent(), RMap.fastPutIfAbsentAsync, RMapReactive.fastPutIfAbsent();
HVALSRMap.readAllValues(), RMap.readAllValuesAsync(), RMapReactive.readAllValues();
INCRRAtomicLong.incrementAndGet(), RAtomicLong.incrementAndGetAsync(), RAtomicLongReactive.incrementAndGet();
INCRBYRAtomicLong.addAndGet(), RAtomicLong.addAndGetAsync(), RAtomicLongReactive.addAndGet();
KEYSRKeys.findKeysByPattern(), RKeys.findKeysByPatternAsync(), RKeysReactive.findKeysByPattern();
RedissonClient.findBuckets();
LINDEXRList.get(), RList.getAsync(), RListReactive.get();
LLENRList.size(), RList.sizeAsync(), RListReactive.Size();
LPOPRQueue.poll(), RQueue.pollAsync(), RQueueReactive.poll();
LPUSHRDeque.addFirst(), RDeque.addFirstAsync();
RDequeReactive.addFirst(), RDeque.offerFirst(), RDeque.offerFirstAsync(), RDequeReactive.offerFirst();
LRANGERList.readAll(), RList.readAllAsync(), RListReactive.readAll();
LREMRList.fastRemove(), RList.fastRemoveAsync(), RList.remove(), RList.removeAsync(), RListReactive.remove();
RDeque.removeFirstOccurrence(), RDeque.removeFirstOccurrenceAsync(), RDequeReactive.removeFirstOccurrence();
RDeque.removeLastOccurrence(), RDeque.removeLastOccurrenceAsync(), RDequeReactive.removeLastOccurrence();
LSETRList.fastSet(), RList.fastSetAsync(), RListReactive.fastSet();
LTRIMRList.trim(), RList.trimAsync(), RListReactive.trim();
LINSERTRList.addBefore(), RList.addBeforeAsync(), RList.addAfter(), RList.addAfterAsync(), RListReactive.addBefore(), RListReactive.addAfter();
MGETRedissonClient.loadBucketValues();
MIGRATERObject.migrate(), RObject.migrateAsync();
MOVERObject.move(), RObject.moveAsync();
MSETRedissonClient.saveBuckets();
PERSISTRExpirable.clearExpire(), RExpirable.clearExpireAsync(), RExpirableReactive.clearExpire();
PEXPIRERExpirable.expire(), RExpirable.expireAsync(), RExpirableReactive.expire();
PEXPIREATRExpirable.expireAt(), RExpirable.expireAtAsync(), RExpirableReactive.expireAt();
PFADDRHyperLogLog.add(), RHyperLogLog.addAsync(), RHyperLogLogReactive.add();
RHyperLogLog.addAll(), RHyperLogLog.addAllAsync(), RHyperLogLogReactive.addAll();
PFCOUNTRHyperLogLog.count(), RHyperLogLog.countAsync(), RHyperLogLogReactive.count();
RHyperLogLog.countWith(), RHyperLogLog.countWithAsync(), RHyperLogLogReactive.countWith();
PFMERGERHyperLogLog.mergeWith(), RHyperLogLog.mergeWithAsync(), RHyperLogLogReactive.mergeWith();
PINGNode.ping(); NodesGroup.pingAll();
PSUBSCRIBERPatternTopic.addListener();
PTTLRExpirable.remainTimeToLive(), RExpirable.remainTimeToLiveAsync(), RExpirableReactive.remainTimeToLive();
PUBLISHRTopic.publish
PUNSUBSCRIBERPatternTopic.removeListener();
RANDOMKEYRKeys.randomKey(), RKeys.randomKeyAsync(), RKeysReactive.randomKey();
RENAMERObject.rename(), RObject.renameAsync(), RObjectReactive.rename();
RENAMENXRObject.renamenx(), RObject.renamenxAsync(), RObjectReactive.renamenx();
RPOPRDeque.pollLast(), RDeque.pollLastAsync(), RDequeReactive.pollLast();
RDeque.removeLast(), RDeque.removeLastAsync(), RDequeReactive.removeLast();
RPOPLPUSHRDeque.pollLastAndOfferFirstTo(), RDeque.pollLastAndOfferFirstToAsync();
RPUSHRList.add(), RList.addAsync(), RListReactive.add();
SADDRSet.add(), RSet.addAsync(), RSetReactive.add();
SCARDRSet.size(), RSet.sizeAsync(), RSetReactive.size();
SCRIPT EXISTSRScript.scriptExists(), RScript.scriptExistsAsync(), RScriptReactive.scriptExists();
SCRIPT FLUSHRScript.scriptFlush(), RScript.scriptFlushAsync(), RScriptReactive.scriptFlush();
SCRIPT KILLRScript.scriptKill(), RScript.scriptKillAsync(), RScriptReactive.scriptKill();
SCRIPT LOADRScript.scriptLoad(), RScript.scriptLoadAsync(), RScriptReactive.scriptLoad();
SDIFFSTORERSet.diff(), RSet.diffAsync(), RSetReactive.diff();
SELECTConfig.setDatabase();
SETRBucket.set(); RBucket.setAsync(); RBucketReactive.set();
SETBITRBitSet.set(); RBitSet.setAsync(); RBitSet.clear(); RBitSet.clearAsync();
SETEXRBucket.set(); RBucket.setAsync(); RBucketReactive.set();
SETNXRBucket.trySet(); RBucket.trySetAsync(); RBucketReactive.trySet();
SISMEMBERRSet.contains(), RSet.containsAsync(), RSetReactive.contains();
SINTERSTORERSet.intersection(), RSet.intersectionAsync(), RSetReactive.intersection();
SINTERRSet.readIntersection(), RSet.readIntersectionAsync(), RSetReactive.readIntersection();
SMEMBERSRSet.readAll(), RSet.readAllAsync(), RSetReactive.readAll();
SMOVERSet.move(), RSet.moveAsync(), RSetReactive.move();
SPOPRSet.removeRandom(), RSet.removeRandomAsync(), RSetReactive.removeRandom();
SREMRSet.remove(), RSet.removeAsync(), RSetReactive.remove();
SUBSCRIBERTopic.addListener(), RTopicReactive.addListener();
SUNIONRSet.readUnion(), RSet.readUnionAsync(), RSetReactive.readUnion();
SUNIONSTORERSet.union(), RSet.unionAsync(), RSetReactive.union();
TTLRExpirable.remainTimeToLive(), RExpirable.remainTimeToLiveAsync(), RExpirableReactive.remainTimeToLive();
UNSUBSCRIBERTopic.removeListener(), RTopicReactive.removeListener();
ZADDRScoredSortedSet.add(), RScoredSortedSet.addAsync(), RScoredSortedSetReactive.add();
ZCARDRScoredSortedSet.size(), RScoredSortedSet.sizeAsync(), RScoredSortedSetReactive.size();
ZINCRBYRScoredSortedSet.addScore(), RScoredSortedSet.addScoreAsync(), RScoredSortedSetReactive.addScore();
ZLEXCOUNTRLexSortedSet.lexCount(), RLexSortedSet.lexCountAsync(), RLexSortedSetReactive.lexCount(); 
RLexSortedSet.lexCountHead(), RLexSortedSet.lexCountHeadAsync(), RLexSortedSetReactive.lexCountHead();
RLexSortedSet.lexCountTail(), RLexSortedSet.lexCountTailAsync(), RLexSortedSetReactive.lexCountTail();
ZRANGERScoredSortedSet.valueRange(), RScoredSortedSet.valueRangeAsync(), RScoredSortedSetReactive.valueRange();
ZREVRANGERScoredSortedSet.valueRangeReversed(), RScoredSortedSet.valueRangeReversedAsync(), RScoredSortedSetReactive.valueRangeReversed();
ZUNIONSTORERScoredSortedSet.union(), RScoredSortedSet.unionAsync(), RScoredSortedSetReactive.union();
ZINTERSTORERScoredSortedSet.intersection(), RScoredSortedSet.intersectionAsync(), RScoredSortedSetReactive.intersection();
ZRANGEBYLEXRLexSortedSet.lexRange(), RLexSortedSet.lexRangeAsync(), RLexSortedSetReactive.lexRange(); 
RLexSortedSet.lexRangeHead(), RLexSortedSet.lexRangeHeadAsync(), RLexSortedSetReactive.lexRangeHead();
RLexSortedSet.lexRangeTail(), RLexSortedSet.lexRangeTailAsync(), RLexSortedSetReactive.lexRangeTail();
ZRANGEBYSCORERScoredSortedSet.valueRange(), RScoredSortedSet.valueRangeAsync(), RScoredSortedSetReactive.valueRange(); 
RScoredSortedSet.entryRange(), RScoredSortedSet.entryRangeAsync(), RScoredSortedSetReactive.entryRange();
TIMENode.time();
ZRANKRScoredSortedSet.rank(), RScoredSortedSet.rankAsync(), RScoredSortedSetReactive.rank();
ZREMRScoredSortedSet.remove(), RScoredSortedSet.removeAsync(), RScoredSortedSetReactive.remove();
RScoredSortedSet.removeAll(), RScoredSortedSet.removeAllAsync(), RScoredSortedSetReactive.removeAll();
ZREMRANGEBYLEXRLexSortedSet.removeRangeByLex(), RLexSortedSet.removeRangeByLexAsync(), RLexSortedSetReactive.removeRangeByLex(); 
RLexSortedSet.removeRangeHeadByLex(), RLexSortedSet.removeRangeHeadByLexAsync(), RLexSortedSetReactive.removeRangeHeadByLex();
RLexSortedSet.removeRangeTailByLex(), RLexSortedSet.removeRangeTailByLexAsync(), RLexSortedSetReactive.removeRangeTailByLex();
ZREMRANGEBYLEXRScoredSortedSet.removeRangeByRank(), RScoredSortedSet.removeRangeByRankAsync(), RScoredSortedSetReactive.removeRangeByRank();
ZREMRANGEBYSCORERScoredSortedSet.removeRangeByScore(), RScoredSortedSet.removeRangeByScoreAsync(), RScoredSortedSetReactive.removeRangeByScore();
ZREVRANGEBYSCORERScoredSortedSet.entryRangeReversed(), RScoredSortedSet.entryRangeReversedAsync(), RScoredSortedSetReactive.entryRangeReversed(), RScoredSortedSet.valueRangeReversed(), RScoredSortedSet.valueRangeReversedAsync(), RScoredSortedSetReactive.valueRangeReversed();
ZREVRANKRScoredSortedSet.revRank(), RScoredSortedSet.revRankAsync(), RScoredSortedSetReactive.revRank();
ZSCORERScoredSortedSet.getScore(), RScoredSortedSet.getScoreAsync(), RScoredSortedSetReactive.getScore();
SCANRKeys.getKeys(), RKeysReactive.getKeys();
SSCANRSet.iterator(), RSetReactive.iterator();
HSCANRMap.keySet().iterator(), RMap.values().iterator(), RMap.entrySet().iterator(), RMapReactive.keyIterator(), RMapReactive.valueIterator(), RMapReactive.entryIterator();
ZSCANRScoredSortedSet.iterator(), RScoredSortedSetReactive.iterator();

5.Redisson的同步和异步操作API

    Redisson框架提供的几乎所有对象都包含了同步和异步相互匹配的方法。这些对象都可以通过RedissonClient接口获取。同时还为大部分Redisson对象提供了满足异步流处理标准的程序接口RedissonReactiveClient。

5.1 同步执行方式

// 同步执行方式  
RedissonClient client = Redisson.create(config);  
RAtomicLong longObject = client.getAtomicLong('myLong');  
longObject.compareAndSet(3, 401);

5.2 异步执行方式

// 异步执行方式  
RedissonClient client = Redisson.create(config);  
RAtomicLong longObject = client.getAtomicLong('myLong');  
longObject.compareAndSetAsync(3, 401);

5.3 异步流执行方式

// 异步流执行方式  
RedissonReactiveClient client = Redisson.createReactive(config);  
RAtomicLongReactive longObject = client.getAtomicLong('myLong');  
longObject.compareAndSet(3, 401);

6.redisson支持的配置方式

    6.1 直接操作程序API

        Redisson程序化的配置方法是通过构建Config对象实例来实现的。例如：

Config config = new Config();  
config.setUseLinuxNativeEpoll(true);  
config.useClusterServers()  
      //可以用"rediss://"来启用SSL连接  
      .addNodeAddress("redis://127.0.0.1:7181");

6.2 通过JSON文件配置

        Redisson的配置文件可以是JSON格式。 可以通过调用Config.fromJSON方法并指定一个File实例来实现读取JSON格式的配置：

Config config = Config.fromJSON(new File("config-file.json"));  
RedissonClient redisson = Redisson.create(config);

6.3 通过YAML文件配置

        Redisson的配置文件可以是YAML格式。 可以通过调用config.fromYAML方法并指定一个File实例来实现读取YAML格式的配置：

Config config = Config.fromYAML(new File("config-file.yaml"));  
RedissonClient redisson = Redisson.create(config);

6.4 通过Spring XML配置

        Redisson为Spring框架提供了一套通过命名空间来配置实例的方式。一个Redisson的实例可以通过这样的方式来配置：

<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">  
<!-- 配置分类1：netty相关-->  
<!-- 配置分类2：redis服务端IP和端口-->  
<!-- 配置分类3：redisson客户端负载均衡-->  
<!-- 配置分类4：发布和订阅连接池配置-->  
<!-- 配置分类5：连接池配置-->  
<!-- 配置分类6：超时设置-->  
<!-- 配置分类7：失败重试配置-->  
<!-- 配置分类8：redis库和密码设置-->  
<!-- 配置分类9：SSL相关设置-->  
<!-- 配置分类10：特有的配置 -->  
<redisson:client>  
    <!-- 单节点部署方式  -->  
    <redisson:single-server ... />  
    <!-- 主从部署方式  -->  
    <redisson:master-slave-servers ... />  
    <!-- 哨兵部署方式 -->  
    <redisson:sentinel-servers ... />  
    <!-- 集群部署方式 -->  
    <redisson:cluster-servers ... />  
    <!-- 云部署方式 -->  
    <redisson:replicated-servers ... />  
</redisson:client>  
</beans>

更多的使用方法请前往第三方框架整合文档了解。 举例单节点redis的详细配置如下：

<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节点模式的配置 -->  
    <bean id="jsonJacksonCodec" class="org.redisson.codec.JsonJacksonCodec"></bean>  
    <bean id="defaultCodecProvider" class="org.redisson.codec.DefaultCodecProvider"></bean>  
    <bean id="defaultResolverProvider" class="org.redisson.liveobject.provider.DefaultResolverProvider"></bean>  
    <bean id="nioEventLoopGroup" class="io.netty.channel.nio.NioEventLoopGroup"></bean>  
      
    <bean id="defaultThreadFactory" class="io.netty.util.concurrent.DefaultThreadFactory">  
        <constructor-arg name="poolName" value="redisson"></constructor-arg>  
    </bean>  
    <bean id="executors" factory-method="newFixedThreadPool" class="java.util.concurrent.Executors">  
        <constructor-arg name="nThreads" value="50"></constructor-arg>  
        <constructor-arg ref="defaultThreadFactory"></constructor-arg>  
    </bean>  
      
    <redisson:client   
        id="standalone"  
        name="aliasName1,aliasName2"   
        threads="8"   
        netty-threads="8"   
        codec-ref="jsonJacksonCodec"  
        codec-provider-ref="defaultCodecProvider"   
        use-linux-native-epoll="false"  
        redisson-reference-enabled="true"  
        resolver-provider-ref="defaultResolverProvider"   
        executor-ref="executors"   
        event-loop-group-ref="nioEventLoopGroup" >  
    <redisson:single-server   
        address="redis://192.168.29.24:6379"     
        subscription-connection-minimum-idle-size="1"  
        subscriptions-per-connection="50"  
        subscription-connection-pool-size="50"  
        connection-minimum-idle-size="10"  
        connection-pool-size="64"  
        idle-connection-timeout="10000"  
        connect-timeout="10000"  
        timeout="3000"  
        ping-timeout="3000"  
        retry-attempts="3"  
        retry-interval="1500"  
        reconnection-timeout="3000"  
        failed-attempts="3"  
        database="0"  
        password=""  
        client-name=""  
        ssl-enable-endpoint-identification="true"  
        ssl-keystore=""  
        ssl-keystore-password=""  
        ssl-provider="JDK"  
        ssl-truststore=""  
        ssl-truststore-password=""  
        dns-monitoring="false"  
        dns-monitoring-interval="5000"/>  
    </redisson:client>  
</beans>

7.redisson如何配置参数

    redisson的配置参数很多，容易让人感觉疲乏，更恐怖的是针对每种部署方式，相关参数也不尽相同，但不管怎么变化，配置参数的归类就那么几个，初学者可以先记住配置参数的大致分类，然后针对每个分类下的不同参数有无进行对比总结，这样能方便理解，总结归类redisson的配置参数分类如下：

  • 配置分类1：netty相关
  • 配置分类2：redis服务端IP和端口
  • 配置分类3：redisson客户端负载均衡
  • 配置分类4：发布和订阅连接池配置
  • 配置分类5：连接池配置
  • 配置分类6：超时设置
  • 配置分类7：失败重试配置
  • 配置分类8：redis库和密码设置
  • 配置分类9：SSL相关设置
  • 配置分类10：特有的配置

    前面已经知道如何简单的去操作redisson客户端来调用redis服务端，默认值设置了服务端相关的redis IP地址和端口，没有做过多设置，那么redisson有哪些方面设置，如何设置呢？

  •     因为redisson是基于java的网络编程框架netty实现，所以首先提供了暴露了netty相关配置参数；
  •     redis服务端要么是单机要么是多机，那么这里必然存在主从相关设置；
  •     redisson作为客户端，如果频繁去创建和关闭连接，那么性能必然大幅下降，那么这里必然有连接池相关配置；
  •     考虑到安全相关，所以redis还需要有SSL相关设置；
  •     后面还有客户端操作失败重试相关设置参数和根据不同部署的特殊配置；

    这里将各种部署方式的配置列表如下：

 

转自：https://blog.csdn.net/zilong_zilong/article/details/78252037

 

转载于:https://my.oschina.net/LucasZhu/blog/1816320

weixin_33905756
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis的使用实战教程
12-06
此外，Redisson 是一个Java客户端库，它提供了对Redis的全面支持，包括分布式锁、分布式ID生成器等高级功能。 Redis 的内存管理策略包括LRU（Least Recently Used）和LFU（Least Frequently Used）等，可以根据实际...
Redis从入门到精通(八)Redis实战(五)分布式锁误删与原子性问题、Redisson 测试项目代码
最新发布
04-06
而Redisson是基于Redis的Java客户端，提供了丰富的数据结构和服务，包括分布式锁服务。 首先，让我们理解什么是分布式锁。在分布式系统中，当多个节点需要对共享资源进行互斥访问时，分布式锁便发挥了作用。它确保...
Redis 与 Python 交互（简单连接）
weixin_51927215的博客
04-09 245
Redis1、Python 操作 Window 端 Redis2、Python 操作 Linux 端 Redis 1、Python 操作 Window 端 Redis 具体步骤： 第一步：安装Redis扩展（在命令行窗口运行） pip install redis 第二步：连接（在 pycharm 里运行） r = redis.StrictRedis(host='localhost',port=6379,db=0) 2、Python 操作 Linux 端 Redis 具体步骤： 第一步：Redis 开启
最强分布式锁工具：Redisson
很多时候犯错都是在不知情的情况下发生的
08-30 299
什么是Redisson？Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。一个基于Redis实现的分布式工具，有基本分布式对象和高级又抽象的分布式服务，为每个试图再造分布式轮子的程序员带来了大部分分布式问题的解决办法。...
Redisson分布式锁分析
weixin_33971205的博客
01-26 341
2019独角兽企业重金招聘Python工程师标准>>> ...
使用 Python 操作 Redis
sinat_35773915的博客
07-13 374
Redis 是一个开源的内存数据结构存储系统，它提供了快速、可靠的键值存储和缓存解决方案。通过使用 Python 的 redis 模块，我们可以方便地操作 Redis 数据库。通过以上步骤，我们可以方便地使用 Python 操作 Redis 数据库。你可以根据实际需求进行扩展，比如添加更多的键值对、使用其他数据结构、实现缓存功能等。接下来，我们可以使用其他命令来操作不同类型的数据结构。然后，我们可以使用 Redis 的各种命令来操作数据。最后，我们可以根据实际需求对数据进行更新、删除等操作。
redis客户端操作实战-redisDemo.zip
01-29
在这个实战教程中，我们将深入探讨如何在实际应用中操作Redis客户端。"redisDemo.zip"包含了一个名为"redisDemo-master"的项目，这很可能是用来演示Redis客户端使用的代码仓库。 一、Redis基础知识 1. Redis的数据...
redisson使用手册
01-19
Redisson是一款基于Java的Redis客户端，它提供了丰富的数据结构支持，如锁、信号量、队列、布隆过滤器等，极大地扩展了Redis在Java应用中的功能。本使用手册将详细解析Redisson的使用方法和功能，帮助开发者充分利用...
springboot整合redis.zip
07-16
- 首先，你需要在`pom.xml`文件中添加Redis的相关依赖，通常会引入`spring-boot-starter-data-redis`，这将包含Spring Data Redis和Lettuce客户端。 ```xml <groupId>org.springframework.boot <artifactId>...
初识Redisson
提供各种学习资源及帮助
01-03 760
接着第二个if判断，判断一下，myLock锁key的hash数据结构中，是否包含客户端B的ID，但是明显不是的，因为那里包含的是客户端A的ID。这样的锁，就是分布式锁。在一个分布式环境下，假如一个线程获得锁后，突然服务器宕机了，那么这个时候在一定时间后这个锁会自动释放，你也可以设置锁的有效时间(不设置默认30秒），这样的目的主要是防止死锁的发生。客户端B再次加锁，在新的master节点上加锁也也会成功，这个时候客户端B也会认为加锁成功，出现两个节点同时持有一把锁的问题，此时就会产生脏数据的问题。
springboot项目启动redis连接失败问题记录RedisException: ERR Client sent AUTH, but no password is set. channel
ls2008
12-21 5023
springboot项目启动redis连接失败问题记录RedisException: ERR Client sent AUTH, but no password is set. channel
Redisson--------基础入门
cristianoxm的博客
10-06 1175
一、前言 之前用的Redis，都是用的原生的RedisTempale或者是StringRedisTemplate，各种API非常的难易记忆，每次用的时候还得去网上查询API文档，而Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。这里放上redisson的github链接，先说明，redisson除了开源版本，还有付费的pro版本，以后介绍的某些高级功能，如果是pro版本的，会标出 二、在SpringBo
SpringBoot整合Redisson（Redisson的配置）
小小得愿望-博客
07-22 4889
SpringBoot整合Redisson
redisson的使用
竹林幽深
08-23 4121
1、Redisson工具类 public class RedissonUtil { private RedissonManager redissonManager; private Redisson redisson; public RedissonUtil(RedissonManager redissonManager) { this.redissonManager = redissonManager; this.redisson = redisson...
spring 5.x 系列第7篇 —— 整合Redis客户端 Jedis和Redisson (xml配置方式)
很多时候犯错都是在不知情的情况下发生的
08-16 1176
版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/m0_37809146/article/details/86678847 文章目录 一、说明 1.1 Redis 客户端说明 1.2 Redis可视化软件 1.3 项目结构说明 1.3 依赖说明 二、spring 整合 jedis 2.1 ...
使用Redisson配置redis
ShiZaolin的博客
11-01 2852
多线程使用Redisson配置redis
Redisson自定义序列化
yzh_1346983557的博客
01-10 6351
项目之前使用的RestTemplate api，RestTemplate的序列化使用的RedisSerializer接口，使用的实现类Jackson2JsonRedisSerializer。现在改为使用RedissonClient，RedissonClient的序列化使用的Codec接口，默认实现类JsonJacksonCodec。
redis客户端redisson实战
热门推荐
猿类崛起
10-16 20万+
  redis 学习问题总结 http://aperise.iteye.com/blog/2310639 ehcache memcached redis 缓存技术总结 http://aperise.iteye.com/blog/2296219 redis-stat 离线安装 http://aperise.iteye.com/blo...
springboot整合redis和redisson
08-31
Spring Boot整合Redis和Redisson可以让我们更方便地使用Redis作为缓存或分布式锁。下面是一个简单的示例，展示了如何在Spring Boot项目中实现这个整合: 1. 首先，在pom.xml文件中添加以下依赖： ```xml ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值