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://aperise.iteye.com/blog/2396196 |
redisson-2.10.4源代码分析 |
http://aperise.iteye.com/blog/2400528 |
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)
(1)纯java操作
//创建配置 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();
(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"> <redisson:client id="standalone" name="aliasName1,aliasName2"> <redisson:single-server address="redis://127.0.0.1:6379" /> </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)
(1)纯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();
(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"> <redisson:client id="sentinel"> <redisson:sentinel-servers master-name="my-sentinel-name"> <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)
(1)纯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();
(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"> <redisson:client id="cluster"> <redisson:cluster-servers> <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)
(1)纯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();
(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"> <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>
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(); 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"); //创建客户端(发现这一非常耗时,基本在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"> <redisson:client id="cloud"> <redisson:replicated-servers> <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对应的对象为:
那么从API操作上你就需要首先获取到RBucket对象,然后调用其3个方法来分别执行set操作,以单节点部署方式举例如下:
//创建配置 Config config = new Config(); //指定使用单节点部署方式 config.useSingleServer().setAddress("redis://127.0.0.1:6379"); //创建客户端(发现这一非常耗时,基本在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对象方法 |
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的实例可以通过这样的方式来配置:
<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相关设置;
- 后面还有客户端操作失败重试相关设置参数和根据不同部署的特殊配置;
这里将各种部署方式的配置列表如下:
配置分类 | 配置介绍 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||
netty相关
|
以下参数主要影响redisson里面的netty网络编程框架,如果想了解更多建议去实际使用以下netty框架,在redisson里在常用配置参数环节有介绍:
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
redis服务端IP和端口 |
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
redisson客户端负载均衡 |
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
发布和订阅连接池配置 |
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
连接池配置 |
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
超时设置 |
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
失败重试配置 |
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
redis库和密码设置 |
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
SSL相关设置 |
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
特有的配置 |
|
8. 单个集合数据分片(有Redisson PRO版本限制)
目前支持的数据结构类型包括Set和Map.该功能仅限于Redisson PRO版本。
参见https://github.com/redisson/redisson/wiki。
9.分布式对象
包含通用对象桶(Object Bucket)、二进制流(Binary Stream)、地理空间对象桶(Geospatial Bucket)、BitSet、原子整长形(AtomicLong)、原子双精度浮点数(AtomicDouble)、话题(订阅分发)、模糊话题、布隆过滤器(Bloom Filter)、基数估计算法(HyperLogLog)。
参见https://github.com/redisson/redisson/wiki。
10.分布式集合(有Redisson PRO版本限制)
包含映射(Map)、映射(Map)、多值映射(Multimap)、集(Set)、有序集(SortedSet)、计分排序集(ScoredSortedSet)、字典排序集(LexSortedSet)、列表(List)、列队(Queue)、双端队列(Deque)、阻塞队列(Blocking Queue)、有界阻塞列队(Bounded Blocking Queue)、阻塞双端列队(Blocking Deque)、阻塞公平列队(Blocking Fair Queue)、延迟列队(Delayed Queue)、优先队列(Priority Queue)、优先双端队列(Priority Deque)。
其中映射(Map)和集(Set)功能仅限于Redisson PRO版本。
参见https://github.com/redisson/redisson/wiki。
11.分布式锁(Lock)和同步器(Synchronizer)
包含可重入锁(Reentrant Lock)公平锁(Fair Lock)联锁(MultiLock)红锁(RedLock)读写锁(ReadWriteLock)信号量(Semaphore)可过期性信号量(PermitExpirableSemaphore)闭锁(CountDownLatch)。
参见https://github.com/redisson/redisson/wiki。
12.分布式服务
包含分布式远程服务(Remote Service)、分布式实时对象(Live Object)服务、分布式执行服务(Executor Service)、分布式调度任务服务(Scheduler Service)、分布式映射归纳服务(MapReduce)。
参见https://github.com/redisson/redisson/wiki。
13.额外功能
包含对Redis节点的操作、复杂多维对象结构和对象引用的支持、命令的批量执行、脚本执行、底层Redis客户端。
参见https://github.com/redisson/redisson/wiki。
14.独立节点模式
Redisson Node指的是Redisson在分布式运算环境中作为独立节点运行的一种模式。Redisson Node的功能可以用来执行通过分布式执行服务或分布式调度执行服务发送的远程任务,也可以用来为分布式远程服务提供远端服务。 所有这些功能全部包含在一个JAR包里,您可以从这里下载.。
参见https://github.com/redisson/redisson/wiki。
15.工具(有Redisson PRO版本限制)
包含Redis部署工具、集群管理工具。
其中Redis部署工具和集群管理工具功能仅限于Redisson PRO版本。
参见https://github.com/redisson/redisson/wiki。
16.第三方框架整合
包含Spring框架整合、Spring Cache整合、Hibernate整合、Java缓存标准规范JCache API (JSR-107)、Tomcat会话管理器(Tomcat Session Manager)、Spring Session会话管理器。
参见https://github.com/redisson/redisson/wiki。
17.问题记录
17.1 maven jar冲突问题
redisson本身依赖一些第三方jar,比如netty,如果在项目中其他maven依赖已经存在这些jar,那么可能导致redisson假死或者卡死现象,比如hbase就依赖netty,如果hbase和redisson同时在项目中出现,并且hbase的maven配置在redisson之前,那么hbase依赖的netty会生效,这样redisson依赖的netty会被抛弃,解决的办法是设置hbase不要依赖netty,设置如下:
<!-- hbase --> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId> <version>1.2.1</version> <exclusions> <exclusion> <artifactId>netty-all</artifactId> <groupId>io.netty</groupId> </exclusion> <exclusion> <artifactId>netty</artifactId> <groupId>io.netty</groupId> </exclusion> </exclusions> </dependency> <!-- redisson --> <!-- 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>
redisson的依赖jar如下:
io.netty | netty-common | 4.1+ | required |
io.netty | netty-codec | 4.1+ | required |
io.netty | netty-buffer | 4.1+ | required |
io.netty | netty-transport | 4.1+ | required |
io.netty | netty-handler | 4.1+ | required |
net.openhft | zero-allocation-hashing | 0.8+ | required |
com.fasterxml.jackson.dataformat | jackson-core | 2.7+ | required |
com.fasterxml.jackson.dataformat | jackson-databind | 2.7+ | required |
com.fasterxml.jackson.dataformat | jackson-databind | 2.7+ | required |
com.fasterxml.jackson.dataformat | jackson-dataformat-yaml | 2.7+ | optional (used for yaml configuration) |
net.bytebuddy | byte-buddy | 1.6+ | optional (used for LiveObject service) |
org.jodd | jodd-bean | 3.7+ | optional (used for LiveObject service) |
javax.cache | cache-api | 1.0.0 | optional (used for JCache implementation) |
io.projectreactor | reactor-stream | 2.0.8 | optional (used for RedissonReactiveClient) |
17.2 redisson操作完后客户端一直处于运行状态,类似于后台进程一直运行
这个主要是因为redisson使用netty将redis引入java后,本身就是一个常驻后台执行的程序,如果要强制关闭,请加上以下代码即可:
redisson.shutdown();
相关推荐
在这个实战教程中,我们将深入探讨如何在实际应用中操作Redis客户端。"redisDemo.zip"包含了一个名为"redisDemo-master"的项目,这很可能是用来演示Redis客户端使用的代码仓库。 一、Redis基础知识 1. Redis的数据...
此外,Redisson 是一个Java客户端库,它提供了对Redis的全面支持,包括分布式锁、分布式ID生成器等高级功能。 Redis 的内存管理策略包括LRU(Least Recently Used)和LFU(Least Frequently Used)等,可以根据实际...
而Redisson是基于Redis的Java客户端,提供了丰富的数据结构和服务,包括分布式锁服务。 首先,让我们理解什么是分布式锁。在分布式系统中,当多个节点需要对共享资源进行互斥访问时,分布式锁便发挥了作用。它确保...
3. 编写代码:使用Redis客户端(如Jedis、Redisson等)连接Redis,实现数据的增删改查操作。 4. 考虑扩展性:随着数据量的增长,可能需要考虑主从复制、Sentinel集群或Cluster集群来提高系统的可扩展性和容错性。 ...
a) 添加依赖:在SpringBoot的`pom.xml`文件中添加Redis Sentinel的相关依赖,如`spring-boot-starter-data-redis`和`redisson`(一个支持Redis Sentinel的Java客户端)。 b) 配置Redis Sentinel:在`application....
接下来,我们引入Redisson,这是一个全面的Java客户端,提供了丰富的Redis功能,包括分布式锁、队列、信号量等。RedLock是Redisson中的一个特性,它由Redis社区提出,旨在提供一种更健壮的分布式锁实现,比单节点...
1. **Redisson**:Redisson是一个全面的Java客户端,用于处理Redis服务器。它提供了丰富的数据结构支持,如Map、Set、List、Queue、Deque、SortedSet、AtomicLong、CountDownLatch、BitSet、Lock、Semaphore、...
1. **添加依赖**:在 `pom.xml` 文件中,我们需要引入 Spring Boot 的 Redis starter 和 Redisson(一个 Redis 客户端库)依赖。这将确保我们能够利用 Spring Boot 的自动配置特性来轻松设置 Redis 连接。 ```xml ...
Redisson是一款基于Java的Redis客户端,它提供了丰富的数据结构支持,如锁、信号量、队列、布隆过滤器等,极大地扩展了Redis在Java应用中的功能。本使用手册将详细解析Redisson的使用方法和功能,帮助开发者充分利用...
- 首先,你需要在`pom.xml`文件中添加Redis的相关依赖,通常会引入`spring-boot-starter-data-redis`,这将包含Spring Data Redis和Lettuce客户端。 ```xml <groupId>org.springframework.boot <artifactId>...
- Jedis:最常用的Java Redis客户端,支持多种Redis命令和数据类型操作。 - Lettuce:提供了更现代的API设计,支持异步操作和Spring Data集成。 - Redisson:除了基本操作,还包含分布式锁、映射、队列等高级功能...
- WebSocket是一种在客户端和服务器之间建立长连接的协议,允许双向通信,极大地优化了实时数据传输效率。 - 在微服务中,WebSocket常用于实现聊天室、实时推送通知等场景,提高用户体验。 4. **Redis**: - ...
在实际开发中,还可以进一步优化,例如使用Redisson客户端支持更丰富的数据结构,或者使用Spring Cache抽象层来统一各种缓存策略。总之,合理利用这些技术可以显著提升系统的响应速度和用户体验。
为了提高开发效率,Spring Boot还支持Redisson客户端,它提供了更丰富的功能,如分布式锁、原子操作、计数器等。通过引入`spring-boot-starter-data-redisson`依赖,可以在项目中方便地使用这些高级特性。 在持久化...
Redisson和Jedis都是Java的Redis客户端,但Redisson提供了分布式和可扩展的Java数据结构,更注重于简化Redis的使用,而Jedis提供了更全面的Redis命令支持。 总的来说,Java面试题目和Redis的知识是面试者必须掌握的...
Redisson是高性能的,完全兼容Redis协议的客户端,支持所有Redis命令,包括数据结构如字符串、哈希、列表、集合、有序集合,以及高级特性如发布订阅、事务、lua脚本、地理空间索引等。在Spring项目中,Redisson常被...
Redisson是基于Redis的Java客户端,它提供了丰富的数据结构和服务,包括分布式锁。使用Redisson实现分布式锁的优点在于其高效和可扩展性。以下是一些基本步骤: 1. 添加Redisson依赖到项目中,通常在Maven的pom.xml...
例如,使用`Redisson`或`Jedis`等客户端库来实现数据的同步。 2. **发布/订阅(Pub/Sub)**:MySQL可以作为数据源,当数据发生变化时,通过发布事件到Redis的频道,订阅该频道的Redis实例或应用可以实时收到更新,...
通过阅读《Redis实战.pdf》,你可以深入理解Redis的使用方法和优化技巧,结合Java进行实际项目开发,提升系统的性能和响应速度。这本书涵盖了Redis的全面知识,是Java开发者学习Redis的宝贵资源。