redis 学习问题总结
ehcache memcached redis 缓存技术总结
redis-stat 离线安装
redis  cluster 非ruby方式启动
redis-sentinel安装部署
spring-data-redis使用
redis客户端redisson实战
redisson-2.10.4源代码分析
tcmalloc jemalloc libc选择

 

 redis客户端redisson实战

1.前言

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

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

2.maven项目集成redisson

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

      
         
     
      org.redisson
          
     
      redisson
          
     
      3.5.4
       
          
      
         
     
      org.redisson
          
     
      redisson
          
     
      2.10.4
       
    

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

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

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

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

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

3.1 单节点部署方式(standalone)

(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
    
      keyObject = redisson.getBucket("key");  //如果key存在，就设置key的值为新值value  //如果key不存在，就设置key的值为value  keyObject.set("value");    //最后关闭RedissonClient  redisson.shutdown();
    

(2)spring集成操作

pom.xml

      
          
     
      org.redisson
           
     
      redisson
           
     
      2.10.4
       
      
      
          
     
      org.springframework
           
     
      spring-core
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-beans
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-context
           
     
      4.2.8.RELEASE
       
    

spring-redisson.xml

 

 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
    
      keyObject = redisson.getBucket("key");          // 如果key存在，就设置key的值为新值value          // 如果key不存在，就设置key的值为value          keyObject.set("value");      }  }
    

3.2 哨兵部署方式(sentinel)

(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()    //设置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");        //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
    
      keyObject = redisson.getBucket("key");  //如果key存在，就设置key的值为新值value  //如果key不存在，就设置key的值为value  keyObject.set("value");    //最后关闭RedissonClient  redisson.shutdown();
    

(2)spring集成操作

 pom.xml

      
          
     
      org.redisson
           
     
      redisson
           
     
      2.10.4
       
      
      
          
     
      org.springframework
           
     
      spring-core
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-beans
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-context
           
     
      4.2.8.RELEASE
       
    

spring-redisson.xml

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
    
      keyObject = redisson.getBucket("key");          // 如果key存在，就设置key的值为新值value          // 如果key不存在，就设置key的值为value          keyObject.set("value");      }  }
    

3.3 集群方式(cluster)

(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()    // 集群状态扫描间隔时间，单位是毫秒      .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
    
      keyObject = redisson.getBucket("key");  //如果key存在，就设置key的值为新值value  //如果key不存在，就设置key的值为value  keyObject.set("value");    //最后关闭RedissonClient  redisson.shutdown();
    

(2)spring集成操作

pom.xml

      
          
     
      org.redisson
           
     
      redisson
           
     
      2.10.4
       
      
      
          
     
      org.springframework
           
     
      spring-core
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-beans
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-context
           
     
      4.2.8.RELEASE
       
    

 spring-redisson.xml

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
    
      keyObject = redisson.getBucket("key");          // 如果key存在，就设置key的值为新值value          // 如果key不存在，就设置key的值为value          keyObject.set("value");      }  }
    

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

(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
    
      keyObject = redisson.getBucket("key");  //如果key存在，就设置key的值为新值value  //如果key不存在，就设置key的值为value  keyObject.set("value");    //最后关闭RedissonClient  redisson.shutdown();
    

(2)spring集成操作

pom.xml

      
          
     
      org.redisson
           
     
      redisson
           
     
      2.10.4
       
      
      
          
     
      org.springframework
           
     
      spring-core
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-beans
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-context
           
     
      4.2.8.RELEASE
       
    

 spring-redisson.xml

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
    
      keyObject = redisson.getBucket("key");          // 如果key存在，就设置key的值为新值value          // 如果key不存在，就设置key的值为value          keyObject.set("value");      }  }
    

 3.5 云托管部署方式

  这种方式主要解决redis提供商为云服务的提供商的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()    // 主节点变化扫描间隔时间      .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
    
      keyObject = redisson.getBucket("key");  //如果key存在，就设置key的值为新值value  //如果key不存在，就设置key的值为value  keyObject.set("value");    //最后关闭RedissonClient  redisson.shutdown();
    

(2)spring集成操作

pom.xml

      
          
     
      org.redisson
           
     
      redisson
           
     
      2.10.4
       
      
      
          
     
      org.springframework
           
     
      spring-core
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-beans
           
     
      4.2.8.RELEASE
       
      
          
     
      org.springframework
           
     
      spring-context
           
     
      4.2.8.RELEASE
       
    

 spring-redisson.xml

        
       	
       	
      
       >  	
         	
         	
         	
        	
       
    

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
    
      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对应的对象为：

那么从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
    
      keyObject = redisson.getBucket("time");  //如果key=time存在，就设置key=time的值为新值20171013  //如果key=time不存在，就设置key的值为20171013  keyObject.set("20171013");    //最后关闭RedissonClient  redisson.shutdown();
    

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

Redis命令	Redisson对象方法
AUTH	Config.setPassword();
BITCOUNT	RBitSet.cardinality(), RBitSet.cardinalityAsync(), RBitSetReactive.cardinality()
BITOP	RBitSet.or(), RBitSet.orAsync(), RBitSetReactive.or(); RBitSet.and(), RBitSet.andAsync(), RBitSetReactive.and(); RBitSet.not(); RBitSet.xor(), RBitSet.xorAsync(), RBitSetReactive.xor()
BITPOS	RBitSet.length(), RBitSet.lengthAsync(), RBitSetReactive.length()
BLPOP	RBlockingQueue.take(), RBlockingQueue.takeAsync(), RBlockingQueueReactive.take(); RBlockingQueue.poll(), RBlockingQueue.pollAsync(), RBlockingQueueReactive.poll(); RBlockingQueue.pollFromAny(), RBlockingQueue.pollFromAnyAsync(), RBlockingQueueReactive.pollFromAny();
BRPOP	RBlockingDeque.takeLast(), RBlockingDeque.takeLastAsync(), RBlockingDequeReactive.takeLast();
BRPOPLPUSH	RBlockingQueue.pollLastAndOfferFirstTo(), RBlockingQueue.pollLastAndOfferFirstToAsync(), RBlockingQueueReactive.pollLastAndOfferFirstTo();
CLIENT SETNAME	Config.setClientName();
CLUSTER INFO	ClusterNode.info();
CLUSTER KEYSLOT	RKeys.getSlot(), RKeys.getSlotAsync(), RKeysReactive.getSlot();
CLUSTER NODES	Used in ClusterConnectionManager
DBSIZE	RKeys.count(), RKeys.countAsync(), RKeysReactive.count();
DECR	RAtomicLong.decrementAndGet(), RAtomicLong.decrementAndGetAsync(), RAtomicLongReactive.decrementAndGetAsync();
DEL	RObject.delete(), RObject.deleteAsync(), RObjectReactive.delete(); RKeys.delete(), RKeys.deleteAsync();
STRLEN	RBucket.size(), RBucket.sizeAsync(), RBucketReactive.size();
EVAL	RScript.eval(), RScript.evalAsync(), RScriptReactive.eval();
CLIENT REPLY	RBatch.executeSkipResult();
EVALSHA	RScript.evalSha(), RScript.evalShaAsync(), RScriptReactive.evalSha();
EXISTS	RObject.isExists(), RObject.isExistsAsync(), RObjectReactive.isExists();
FLUSHALL	RKeys.flushall(), RKeys.flushallAsync(), RKeysReactive.flushall();
FLUSHDB	RKeys.flushdb(), RKeys.flushdbAsync(), RKeysReactive.flushdb();
GEOADD	RGeo.add(), RGeo.addAsync(), RGeoReactive.add();
GEODIST	RGeo.dist(), RGeo.distAsync(), RGeoReactive.dist();
GEOHASH	RGeo.hash(), RGeo.hashAsync(), RGeoReactive.hash();
GEOPOS	RGeo.pos(), RGeo.posAsync(), RGeoReactive.pos();
GEORADIUS	RGeo.radius(), RGeo.radiusAsync(), RGeoReactive.radius(); RGeo.radiusWithDistance(), RGeo.radiusWithDistanceAsync(), RGeoReactive.radiusWithDistance(); RGeo.radiusWithPosition(), RGeo.radiusWithPositionAsync(), RGeoReactive.radiusWithPosition();
GEORADIUSBYMEMBER	RGeo.radius(), RGeo.radiusAsync(), RGeoReactive.radius(); RGeo.radiusWithDistance(), RGeo.radiusWithDistanceAsync(), RGeoReactive.radiusWithDistance(); RGeo.radiusWithPosition(), RGeo.radiusWithPositionAsync(), RGeoReactive.radiusWithPosition();
GET	RBucket.get(), RBucket.getAsync(), RBucketReactive.get();
GETBIT	RBitSet.get(), RBitSet.getAsync(), RBitSetReactive.get();
GETSET	RBucket.getAndSet(), RBucket.getAndSetAsync(), RBucketReactive.getAndSet(); RAtomicLong.getAndSet(), RAtomicLong.getAndSetAsync(), RAtomicLongReactive.getAndSet(); RAtomicDouble.getAndSet(), RAtomicDouble.getAndSetAsync(), RAtomicDoubleReactive.getAndSet();
HDEL	RMap.fastRemove(), RMap.fastRemoveAsync(), RMapReactive.fastRemove();
HEXISTS	RMap.containsKey(), RMap.containsKeyAsync(), RMapReactive.containsKey();
HGET	RMap.get(), RMap.getAsync(), RMapReactive.get();
HSTRLEN	RMap.valueSize(), RMap.valueSizeAsync(), RMapReactive.valueSize();
HGETALL	RMap.readAllEntrySet(), RMap.readAllEntrySetAsync(), RMapReactive.readAllEntrySet();
HINCRBY	RMap.addAndGet(), RMap.addAndGetAsync(), RMapReactive.addAndGet();
HINCRBYFLOAT	RMap.addAndGet(), RMap.addAndGetAsync(), RMapReactive.addAndGet();
HKEYS	RMap.readAllKeySet(), RMap.readAllKeySetAsync(), RMapReactive.readAllKeySet();
HLEN	RMap.size(), RMap.sizeAsync(), RMapReactive.size();
HMGET	RMap.getAll(), RMap.getAllAsync(), RMapReactive.getAll();
HMSET	RMap.putAll(), RMap.putAllAsync(), RMapReactive.putAll();
HSET	RMap.put(), RMap.putAsync(), RMapReactive.put();
HSETNX	RMap.fastPutIfAbsent(), RMap.fastPutIfAbsentAsync, RMapReactive.fastPutIfAbsent();
HVALS	RMap.readAllValues(), RMap.readAllValuesAsync(), RMapReactive.readAllValues();
INCR	RAtomicLong.incrementAndGet(), RAtomicLong.incrementAndGetAsync(), RAtomicLongReactive.incrementAndGet();
INCRBY	RAtomicLong.addAndGet(), RAtomicLong.addAndGetAsync(), RAtomicLongReactive.addAndGet();
KEYS	RKeys.findKeysByPattern(), RKeys.findKeysByPatternAsync(), RKeysReactive.findKeysByPattern(); RedissonClient.findBuckets();
LINDEX	RList.get(), RList.getAsync(), RListReactive.get();
LLEN	RList.size(), RList.sizeAsync(), RListReactive.Size();
LPOP	RQueue.poll(), RQueue.pollAsync(), RQueueReactive.poll();
LPUSH	RDeque.addFirst(), RDeque.addFirstAsync(); RDequeReactive.addFirst(), RDeque.offerFirst(), RDeque.offerFirstAsync(), RDequeReactive.offerFirst();
LRANGE	RList.readAll(), RList.readAllAsync(), RListReactive.readAll();
LREM	RList.fastRemove(), RList.fastRemoveAsync(), RList.remove(), RList.removeAsync(), RListReactive.remove(); RDeque.removeFirstOccurrence(), RDeque.removeFirstOccurrenceAsync(), RDequeReactive.removeFirstOccurrence(); RDeque.removeLastOccurrence(), RDeque.removeLastOccurrenceAsync(), RDequeReactive.removeLastOccurrence();
LSET	RList.fastSet(), RList.fastSetAsync(), RListReactive.fastSet();
LTRIM	RList.trim(), RList.trimAsync(), RListReactive.trim();
LINSERT	RList.addBefore(), RList.addBeforeAsync(), RList.addAfter(), RList.addAfterAsync(), RListReactive.addBefore(), RListReactive.addAfter();
MGET	RedissonClient.loadBucketValues();
MIGRATE	RObject.migrate(), RObject.migrateAsync();
MOVE	RObject.move(), RObject.moveAsync();
MSET	RedissonClient.saveBuckets();
PERSIST	RExpirable.clearExpire(), RExpirable.clearExpireAsync(), RExpirableReactive.clearExpire();
PEXPIRE	RExpirable.expire(), RExpirable.expireAsync(), RExpirableReactive.expire();
PEXPIREAT	RExpirable.expireAt(), RExpirable.expireAtAsync(), RExpirableReactive.expireAt();
PFADD	RHyperLogLog.add(), RHyperLogLog.addAsync(), RHyperLogLogReactive.add(); RHyperLogLog.addAll(), RHyperLogLog.addAllAsync(), RHyperLogLogReactive.addAll();
PFCOUNT	RHyperLogLog.count(), RHyperLogLog.countAsync(), RHyperLogLogReactive.count(); RHyperLogLog.countWith(), RHyperLogLog.countWithAsync(), RHyperLogLogReactive.countWith();
PFMERGE	RHyperLogLog.mergeWith(), RHyperLogLog.mergeWithAsync(), RHyperLogLogReactive.mergeWith();
PING	Node.ping(); NodesGroup.pingAll();
PSUBSCRIBE	RPatternTopic.addListener();
PTTL	RExpirable.remainTimeToLive(), RExpirable.remainTimeToLiveAsync(), RExpirableReactive.remainTimeToLive();
PUBLISH	RTopic.publish
PUNSUBSCRIBE	RPatternTopic.removeListener();
RANDOMKEY	RKeys.randomKey(), RKeys.randomKeyAsync(), RKeysReactive.randomKey();
RENAME	RObject.rename(), RObject.renameAsync(), RObjectReactive.rename();
RENAMENX	RObject.renamenx(), RObject.renamenxAsync(), RObjectReactive.renamenx();
RPOP	RDeque.pollLast(), RDeque.pollLastAsync(), RDequeReactive.pollLast(); RDeque.removeLast(), RDeque.removeLastAsync(), RDequeReactive.removeLast();
RPOPLPUSH	RDeque.pollLastAndOfferFirstTo(), RDeque.pollLastAndOfferFirstToAsync();
RPUSH	RList.add(), RList.addAsync(), RListReactive.add();
SADD	RSet.add(), RSet.addAsync(), RSetReactive.add();
SCARD	RSet.size(), RSet.sizeAsync(), RSetReactive.size();
SCRIPT EXISTS	RScript.scriptExists(), RScript.scriptExistsAsync(), RScriptReactive.scriptExists();
SCRIPT FLUSH	RScript.scriptFlush(), RScript.scriptFlushAsync(), RScriptReactive.scriptFlush();
SCRIPT KILL	RScript.scriptKill(), RScript.scriptKillAsync(), RScriptReactive.scriptKill();
SCRIPT LOAD	RScript.scriptLoad(), RScript.scriptLoadAsync(), RScriptReactive.scriptLoad();
SDIFFSTORE	RSet.diff(), RSet.diffAsync(), RSetReactive.diff();
SELECT	Config.setDatabase();
SET	RBucket.set(); RBucket.setAsync(); RBucketReactive.set();
SETBIT	RBitSet.set(); RBitSet.setAsync(); RBitSet.clear(); RBitSet.clearAsync();
SETEX	RBucket.set(); RBucket.setAsync(); RBucketReactive.set();
SETNX	RBucket.trySet(); RBucket.trySetAsync(); RBucketReactive.trySet();
SISMEMBER	RSet.contains(), RSet.containsAsync(), RSetReactive.contains();
SINTERSTORE	RSet.intersection(), RSet.intersectionAsync(), RSetReactive.intersection();
SINTER	RSet.readIntersection(), RSet.readIntersectionAsync(), RSetReactive.readIntersection();
SMEMBERS	RSet.readAll(), RSet.readAllAsync(), RSetReactive.readAll();
SMOVE	RSet.move(), RSet.moveAsync(), RSetReactive.move();
SPOP	RSet.removeRandom(), RSet.removeRandomAsync(), RSetReactive.removeRandom();
SREM	RSet.remove(), RSet.removeAsync(), RSetReactive.remove();
SUBSCRIBE	RTopic.addListener(), RTopicReactive.addListener();
SUNION	RSet.readUnion(), RSet.readUnionAsync(), RSetReactive.readUnion();
SUNIONSTORE	RSet.union(), RSet.unionAsync(), RSetReactive.union();
TTL	RExpirable.remainTimeToLive(), RExpirable.remainTimeToLiveAsync(), RExpirableReactive.remainTimeToLive();
UNSUBSCRIBE	RTopic.removeListener(), RTopicReactive.removeListener();
ZADD	RScoredSortedSet.add(), RScoredSortedSet.addAsync(), RScoredSortedSetReactive.add();
ZCARD	RScoredSortedSet.size(), RScoredSortedSet.sizeAsync(), RScoredSortedSetReactive.size();
ZINCRBY	RScoredSortedSet.addScore(), RScoredSortedSet.addScoreAsync(), RScoredSortedSetReactive.addScore();
ZLEXCOUNT	RLexSortedSet.lexCount(), RLexSortedSet.lexCountAsync(), RLexSortedSetReactive.lexCount();  RLexSortedSet.lexCountHead(), RLexSortedSet.lexCountHeadAsync(), RLexSortedSetReactive.lexCountHead(); RLexSortedSet.lexCountTail(), RLexSortedSet.lexCountTailAsync(), RLexSortedSetReactive.lexCountTail();
ZRANGE	RScoredSortedSet.valueRange(), RScoredSortedSet.valueRangeAsync(), RScoredSortedSetReactive.valueRange();
ZREVRANGE	RScoredSortedSet.valueRangeReversed(), RScoredSortedSet.valueRangeReversedAsync(), RScoredSortedSetReactive.valueRangeReversed();
ZUNIONSTORE	RScoredSortedSet.union(), RScoredSortedSet.unionAsync(), RScoredSortedSetReactive.union();
ZINTERSTORE	RScoredSortedSet.intersection(), RScoredSortedSet.intersectionAsync(), RScoredSortedSetReactive.intersection();
ZRANGEBYLEX	RLexSortedSet.lexRange(), RLexSortedSet.lexRangeAsync(), RLexSortedSetReactive.lexRange();  RLexSortedSet.lexRangeHead(), RLexSortedSet.lexRangeHeadAsync(), RLexSortedSetReactive.lexRangeHead(); RLexSortedSet.lexRangeTail(), RLexSortedSet.lexRangeTailAsync(), RLexSortedSetReactive.lexRangeTail();
ZRANGEBYSCORE	RScoredSortedSet.valueRange(), RScoredSortedSet.valueRangeAsync(), RScoredSortedSetReactive.valueRange();  RScoredSortedSet.entryRange(), RScoredSortedSet.entryRangeAsync(), RScoredSortedSetReactive.entryRange();
TIME	Node.time();
ZRANK	RScoredSortedSet.rank(), RScoredSortedSet.rankAsync(), RScoredSortedSetReactive.rank();
ZREM	RScoredSortedSet.remove(), RScoredSortedSet.removeAsync(), RScoredSortedSetReactive.remove(); RScoredSortedSet.removeAll(), RScoredSortedSet.removeAllAsync(), RScoredSortedSetReactive.removeAll();
ZREMRANGEBYLEX	RLexSortedSet.removeRangeByLex(), RLexSortedSet.removeRangeByLexAsync(), RLexSortedSetReactive.removeRangeByLex();  RLexSortedSet.removeRangeHeadByLex(), RLexSortedSet.removeRangeHeadByLexAsync(), RLexSortedSetReactive.removeRangeHeadByLex(); RLexSortedSet.removeRangeTailByLex(), RLexSortedSet.removeRangeTailByLexAsync(), RLexSortedSetReactive.removeRangeTailByLex();
ZREMRANGEBYLEX	RScoredSortedSet.removeRangeByRank(), RScoredSortedSet.removeRangeByRankAsync(), RScoredSortedSetReactive.removeRangeByRank();
ZREMRANGEBYSCORE	RScoredSortedSet.removeRangeByScore(), RScoredSortedSet.removeRangeByScoreAsync(), RScoredSortedSetReactive.removeRangeByScore();
ZREVRANGEBYSCORE	RScoredSortedSet.entryRangeReversed(), RScoredSortedSet.entryRangeReversedAsync(), RScoredSortedSetReactive.entryRangeReversed(), RScoredSortedSet.valueRangeReversed(), RScoredSortedSet.valueRangeReversedAsync(), RScoredSortedSetReactive.valueRangeReversed();
ZREVRANK	RScoredSortedSet.revRank(), RScoredSortedSet.revRankAsync(), RScoredSortedSetReactive.revRank();
ZSCORE	RScoredSortedSet.getScore(), RScoredSortedSet.getScoreAsync(), RScoredSortedSetReactive.getScore();
SCAN	RKeys.getKeys(), RKeysReactive.getKeys();
SSCAN	RSet.iterator(), RSetReactive.iterator();
HSCAN	RMap.keySet().iterator(), RMap.values().iterator(), RMap.entrySet().iterator(), RMapReactive.keyIterator(), RMapReactive.valueIterator(), RMapReactive.entryIterator();
ZSCAN	RScoredSortedSet.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的实例可以通过这样的方式来配置：

更多的使用方法请前往了解。 举例单节点redis的详细配置如下：

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