项目中会常用到redis,但JedisCluster的使用api还是比较多,经常可能会记不太清楚,故这里将大部分JedisCluster的api贴出来,供大家参考。
一、redis在工作是一个常见的工具,这里对redis和springboot形成集群的使用。 (1)引入对应redis集群所需要maven文件
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.0.5.RELEASE</version>
</dependency>
(2) 在配置文件配置 redis.properties 配置redis集群必要参数
#客户端超时时间单位是毫秒 默认是2000
redis.timeout=10000
#最大空闲数
redis.maxIdle=300
#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
#redis.maxActive=600
#控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
redis.maxTotal=2000
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
redis.maxWaitMillis=1000
redis.nodes=192.168.25.128:7000,192.168.25.128:7001,192.168.25.128:7002,192.168.25.128:7003,192.168.25.128:7004,192.168.25.128:7005,192.168.25.128:7006,192.168.25.128:7007
(3)初始化JedisCluster
@Configuration
@PropertySource("classpath:conf/redis.properties")
public class RedisConfig {
@Value("${redis.maxIdle}")
private Integer maxIdle;
@Value("${redis.timeout}")
private Integer timeout;
@Value("${redis.maxTotal}")
private Integer maxTotal;
@Value("${redis.maxWaitMillis}")
private Integer maxWaitMillis;
@Value("${redis.nodes}")
private String clusterNodes;
@Bean
public JedisCluster getJedisCluster(){
String[] cNodes = clusterNodes.split(",");
HashSet<HostAndPort> nodes = new HashSet<>();
//分割集群节点
for (String node : cNodes) {
String[] hp = node.split(":");
nodes.add(new HostAndPort(hp[0], Integer.parseInt(hp[1])));
}
JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
jedisPoolConfig.setMaxTotal(maxTotal);
//创建集群对象
JedisCluster jedisCluster = new JedisCluster(nodes, timeout, jedisPoolConfig);
return jedisCluster;
}
}
(4)引入JedisCluster进行api测试
01、测试整数和浮点数
@Autowired
JedisCluster jedisCluster;
/***
* 整数和浮点数
*/
@Test
public void testNumber(){
jedisCluster.set("numkey1", "1");
jedisCluster.set("numkey2", "2");
jedisCluster.set("numkey3", "0.56");
System.out.println("获取numkey1的值:" + jedisCluster.get("numkey1"));
System.out.println("让numkey1的值加1:" + jedisCluster.incr("numkey1"));
System.out.println("获取numkey1的值:" + jedisCluster.get("numkey1"));
System.out.println("让numkey1的值减1:" + jedisCluster.decr("numkey1"));
System.out.println("让numkey1的值加5:" + jedisCluster.incrBy("numkey1", 5));
System.out.println("获取numkey1的值:" + jedisCluster.get("numkey1"));
System.out.println("获取numkey1的值减4:" + jedisCluster.decrBy("numkey1", 4));
System.out.println("获取numkey1的值:" + jedisCluster.get("numkey1"));
System.out.println("-------------------------------------");
System.out.println("获取numkey3的值:" + jedisCluster.get("numkey3"));
//小数无法进行加减法运算
}
测试参数的值
获取numkey1的值:1
让numkey1的值加1:2
获取numkey1的值:2
让numkey1的值减1:1
让numkey1的值加5:6
获取numkey1的值:6
获取numkey1的值减4:2
获取numkey1的值:2
-------------------------------------
获取numkey3的值:0.56
02、测试对字符串进行hash操作 由于mset设置一批的值,由于jedis集群获取值通过key配置slot的地址,故这里将mset批量设置的key的前缀{aaa}
public static int getSlot(String key) {
int s = key.indexOf("{");
if (s > -1) {
int e = key.indexOf("}", s + 1);
if (e > -1 && e != s + 1) {
key = key.substring(s + 1, e);
}
}
// optimization with modulo operator with power of 2
// equivalent to getCRC16(key) % 16384
return getCRC16(key) & (16384 - 1);
}
集群对字符串的操作
@Autowired
JedisCluster jedisCluster;
@Test
public void testString() throws InterruptedException {
System.out.println("对keyString1设置字符串:"+jedisCluster.set("keyString1", "valueString1"));
System.out.println("获取keyString1设置的值:"+jedisCluster.get("keyString1"));
System.out.println("对keyString1的值增加值:"+jedisCluster.append("keyString1","appendValue"));
System.out.println("获取keyString1设置的值:"+jedisCluster.get("keyString1"));
System.out.println("删除keyString1实在的值:"+jedisCluster.del("keyString1"));
System.out.println("获取keyString1设置的值:"+jedisCluster.get("keyString1"));
System.out.println("----------------------------对多个键值对的操作----------------------");
/**
* 因此,暂且不能在RedisCluster模式下,通过增加中间层来对批量请求进行分组,并处理到对应的slot中,理想很好,但是不能够实现,因为服务端会进行一定的限制。
*
* 只能通过HASH_TAG来实现cluster模式下的mget/mset批量操作,我们可以在命令行中通过cluster keyslot ${key}来查看某个key对应的slot,可以从Jedis客户端的源码查看对应的key slot算法:
*/
System.out.println("设置多个键值对:"+jedisCluster.mset("{aaa}keyString01",
"valueString01","{aaa}keyString02","valueString02","{aaa}keyString03","valueString03"));
System.out.println("获取多个键值对:"+jedisCluster.mget("{aaa}keyString1","{aaa}keyString01","{aaa}keyString02","{aaa}keyString03"));
System.out.println("设删除多个键值对:"+jedisCluster.del(new String[]{"{aaa}keyString01","{aaa}keyString02"}));
System.out.println("获取多个键值对:"+jedisCluster.mget("{aaa}keyString01","{aaa}keyString02","{aaa}keyString03"));
/**
* jedisCluster.set(prefix + key, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, tt1);
*
*
* EX seconds : 将键的过期时间设置为 seconds 秒。 执行 SET key value EX seconds 的效果等同于执行 SETEX key seconds value 。
* PX milliseconds : 将键的过期时间设置为 milliseconds 毫秒。 执行 SET key value PX milliseconds 的效果等同于执行 PSETEX key milliseconds value 。
* NX : 只在键不存在时, 才对键进行设置操作。 执行 SET key value NX 的效果等同于执行 SETNX key value 。
* XX : 只在键已经存在时, 才对键进行设置操作。
*/
System.out.println("-----------------------set命令----------------------------------");
System.out.println("获取设置nx,px1:" + jedisCluster.set("setKey", "setValue1", "NX", "PX", 10000));
TimeUnit.SECONDS.sleep(1);
System.out.println("获取setKey保留时间1:" + jedisCluster.ttl("setKey"));
TimeUnit.SECONDS.sleep(1);
System.out.println("获取setKey保留时间2:" + jedisCluster.ttl("setKey"));
System.out.println("获取设置nx,px2:" + jedisCluster.set("setKey", "setValue2", "NX", "PX", 10000));
System.out.println("获取setKey的value值2:"+jedisCluster.get("setKey"));
System.out.println("设置nx,xx1:" + jedisCluster.set("setKey", "setValue3", "NX", "PX", 10000));
System.out.println("获取setKey的value值3:"+jedisCluster.get("setKey"));
System.out.println("---------------------新增键值对防止覆盖原先值----------------");
System.out.println("key1 setnx:"+jedisCluster.setnx("key1", "value1"));
System.out.println("key2 setnx: "+jedisCluster.setnx("key2", "value2"));
System.out.println("key2 setnx: "+jedisCluster.setnx("key2", "value2-new"));
System.out.println("获取 key1的值:"+jedisCluster.get("key1"));
System.out.println("获取 key2的值"+jedisCluster.get("key2"));
System.out.println("------------新增键值对并设置有效时间------------");
System.out.println("set keyex:"+jedisCluster.setex("key3", 2, "value3"));
System.out.println("key3 :"+jedisCluster.get("key3"));
TimeUnit.SECONDS.sleep(3);
System.out.println("key3 休息3s:"+jedisCluster.get("key3"));
//GETSET is an atomic set this value and return the old value command.
System.out.println("------------------获取原值,更新为新值-----------");
System.out.println("getSet 值"+jedisCluster.getSet("key2", "key2GetSet"));
System.out.println("获取key2::"+jedisCluster.get("key2"));
System.out.println("获得key2的值的字串:"+jedisCluster.getrange("key2", 2, 4));
}
操作的字符串的的值
对keyString1设置字符串:OK
获取keyString1设置的值:valueString1
对keyString1的值增加值:23
获取keyString1设置的值:valueString1appendValue
删除keyString1实在的值:1
获取keyString1设置的值:null
----------------------------对多个键值对的操作----------------------
设置多个键值对:OK
获取多个键值对:[null, valueString01, valueString02, valueString03]
设删除多个键值对:2
获取多个键值对:[null, null, valueString03]
-----------------------set命令----------------------------------
获取设置nx,px1:OK
获取setKey保留时间1:9
获取setKey保留时间2:8
获取设置nx,px2:null
获取setKey的value值2:setValue1
设置nx,xx1:null
获取setKey的value值3:setValue1
---------------------新增键值对防止覆盖原先值----------------
key1 setnx:0
key2 setnx: 0
key2 setnx: 0
获取 key1的值:value1
获取 key2的值key2GetSet
------------新增键值对并设置有效时间------------
set keyex:OK
key3 :value3
key3 休息3s:null
------------------获取原值,更新为新值-----------
getSet 值key2GetSet
获取key2::key2GetSet
获得key2的值的字串:y2G
03、集群对有序集合api的操作
/**
* 有序集合
*/
@Test
public void testSortedSet(){
System.out.println("设置zset集合:"+jedisCluster.zadd("zset", 3,"key01"));
System.out.println("设置zset集合:"+jedisCluster.zadd("zset", 1,"key02"));
System.out.println("zset中的所有元素:"+jedisCluster.zrangeWithScores("zset", 0, -1));
System.out.println("zset中的score中元素2-4:"+jedisCluster.zrangeWithScores("zset", 2, 4));
Map<String,Double> map = new HashMap<String,Double>();
map.put("key1",1.0);
map.put("key2",1.2);
map.put("key3",4.0);
map.put("key4",5.0);
map.put("key5",0.2);
System.out.println("zet 添加map"+jedisCluster.zadd("zset",map));
System.out.println("zset中的所有元素(zrangeWithScores):"+jedisCluster.zrangeWithScores("zset", 0, -1));
System.out.println("-------------------------------------------------------");
System.out.println("zset中的所有zrangeByScore元素(1,3):"+jedisCluster.zrangeByScore("zset", 1,3));
System.out.println("zset中的所有zrangeByScoreWithScores元素(1,3):"+jedisCluster.zrangeByScoreWithScores("zset", 1,3));
System.out.println("zset中key2的分值:"+jedisCluster.zscore("zset", "key2"));
System.out.println("zset中key2的排名:"+jedisCluster.zrank("zset", "key2"));
System.out.println("删除zset中的元素key3:"+jedisCluster.zrem("zset", "key3"));
System.out.println("zset中的所有元素:"+jedisCluster.zrange("zset", 0, -1));
System.out.println("zset中元素的个数:"+jedisCluster.zcard("zset"));
System.out.println("zset中分值在1-4之间的元素的个数:"+jedisCluster.zcount("zset", 1, 4));
System.out.println("key2的分值加上5:"+jedisCluster.zincrby("zset", 5, "key2"));
System.out.println("key3的分值加上4:"+jedisCluster.zincrby("zset", 4, "key3"));
System.out.println("zset中的所有元素:"+jedisCluster.zrange("zset", 0, -1));
}
对有序集合的操作获取的值
设置zset集合:1
设置zset集合:1
zset中的所有元素:[[[107, 101, 121, 48, 50],1.0], [[107, 101, 121, 48, 49],3.0]]
zset中的score中元素2-4:[]
zet 添加map5
zset中的所有元素(zrangeWithScores):[[[107, 101, 121, 53],0.2], [[107, 101, 121, 48, 50],1.0], [[107, 101, 121, 49],1.0], [[107, 101, 121, 50],1.2], [[107, 101, 121, 48, 49],3.0], [[107, 101, 121, 51],4.0], [[107, 101, 121, 52],5.0]]
-------------------------------------------------------
zset中的所有zrangeByScore元素(1,3):[key02, key1, key2, key01]
zset中的所有zrangeByScoreWithScores元素(1,3):[[[107, 101, 121, 48, 50],1.0], [[107, 101, 121, 49],1.0], [[107, 101, 121, 50],1.2], [[107, 101, 121, 48, 49],3.0]]
zset中key2的分值:1.2
zset中key2的排名:3
删除zset中的元素key3:1
zset中的所有元素:[key5, key02, key1, key2, key01, key4]
zset中元素的个数:6
zset中分值在1-4之间的元素的个数:4
key2的分值加上5:6.2
key3的分值加上4:4.0
zset中的所有元素:[key5, key02, key1, key01, key3, key4, key2]
04、对hash操作的操作
/**
* test Hash
*/
@Test
public void testHash(){
Map<String,String> map = new HashMap<String,String>();
map.put("hashkey1","hashvalue1");
map.put("hashkey2","hashvalue2");
map.put("hashkey3","hashvalue3");
map.put("hashkey4","hashvalue4");
jedisCluster.hmset("hash",map);
jedisCluster.hset("hash", "hashkey5", "hashvalue5");
System.out.println("散列hash的所有键值对为:"+jedisCluster.hgetAll("hash"));
System.out.println("散列hash的所有键为:"+jedisCluster.hkeys("hash"));
System.out.println("散列hash的所有值为:"+jedisCluster.hvals("hash"));
System.out.println("将key6保存的值加上一个整数,如果hashkey6不存在则添加hashkey6:"+jedisCluster.hincrBy("hash", "hashkey6", 6));
System.out.println("散列hash的所有键值对为:"+jedisCluster.hgetAll("hash"));
System.out.println("将key6保存的值加上一个整数,如果hashkey6不存在则添加hashkey6:"+jedisCluster.hincrBy("hash", "hashkey6", 3));
System.out.println("散列hash的所有键值对为:"+jedisCluster.hgetAll("hash"));
System.out.println("删除一个或者多个键值对:"+jedisCluster.hdel("hash", "hashkey2"));
System.out.println("散列hash的所有键值对为:"+jedisCluster.hgetAll("hash"));
System.out.println("散列hash中键值对的个数:"+jedisCluster.hlen("hash"));
System.out.println("判断hash中是否存在hashkey2:"+jedisCluster.hexists("hash","hashkey2"));
System.out.println("判断hash中是否存在hashkey3:"+jedisCluster.hexists("hash","hashkey3"));
System.out.println("获取hash中的值:"+jedisCluster.hmget("hash","hashkey3"));
System.out.println("获取hash中的值:"+jedisCluster.hmget("hash","hashkey3","hashkey4"));
}
对hash操作的获取的值
散列hash的所有键值对为:{hashkey5=hashvalue5, hashkey4=hashvalue4, hashkey3=hashvalue3, hashkey2=hashvalue2, hashkey1=hashvalue1}
散列hash的所有键为:[hashkey5, hashkey4, hashkey3, hashkey2, hashkey1]
散列hash的所有值为:[hashvalue3, hashvalue2, hashvalue1, hashvalue4, hashvalue5]
将key6保存的值加上一个整数,如果hashkey6不存在则添加hashkey6:6
散列hash的所有键值对为:{hashkey6=6, hashkey5=hashvalue5, hashkey4=hashvalue4, hashkey3=hashvalue3, hashkey2=hashvalue2, hashkey1=hashvalue1}
将key6保存的值加上一个整数,如果hashkey6不存在则添加hashkey6:9
散列hash的所有键值对为:{hashkey6=9, hashkey5=hashvalue5, hashkey4=hashvalue4, hashkey3=hashvalue3, hashkey2=hashvalue2, hashkey1=hashvalue1}
删除一个或者多个键值对:1
散列hash的所有键值对为:{hashkey6=9, hashkey5=hashvalue5, hashkey4=hashvalue4, hashkey3=hashvalue3, hashkey1=hashvalue1}
散列hash中键值对的个数:5
判断hash中是否存在hashkey2:false
判断hash中是否存在hashkey3:true
获取hash中的值:[hashvalue3]
获取hash中的值:[hashvalue3, hashvalue4]
05、对排序的操作
/**
* 排序
*/
@Test
public void testSort(){
System.out.println("collections的push:"+jedisCluster.lpush("collectionskey", "collectionsvalue01", "collectionsvalue02", "collectionsvalue03"));
System.out.println("collections的内容:"+jedisCluster.lrange("collectionskey", 0, -1));
SortingParams sortingParameters = new SortingParams();
// 当数据集中保存的是字符串值时,你可以用 ALPHA,默认是升序
System.out.println("alpha排序方式:" + jedisCluster.sort("collectionskey",sortingParameters.alpha()));
System.out.println("---------------------------");
jedisCluster.lpush("sortedList", "3","1","2","8","7","4");
System.out.println("sortedList排序前:"+jedisCluster.lrange("sortedList", 0, -1));
System.out.println("升序:"+jedisCluster.sort("sortedList", sortingParameters.asc()));
System.out.println("降序:"+jedisCluster.sort("sortedList", sortingParameters.desc()));
}
对排序的操作获取的值
collections的push:3
collections的内容:[collectionsvalue03, collectionsvalue02, collectionsvalue01]
alpha排序方式:[collectionsvalue01, collectionsvalue02, collectionsvalue03]
---------------------------
sortedList排序前:[4, 7, 8, 2, 1, 3]
升序:[1, 2, 3, 4, 7, 8]
降序:[8, 7, 4, 3, 2, 1]
6、集群对有序集合api的操(02)
@Test
public void sortedSetTest2() throws InterruptedException {
String keyA = "{" + prefix + KEY_SPLIT + "sortedSet}a";
String keyB = "{" + prefix + KEY_SPLIT + "sortedSet}b";
String keyC = "{" + prefix + KEY_SPLIT + "sortedSet}c";
jedisCluster.del(keyA);
jedisCluster.del(keyB);
jedisCluster.del(keyC);
System.out.println("====================添加返回================");
System.out.println("zadd 添加 单个数据:"+jedisCluster.zadd(keyA, 10, "aa"));
Map<String, Double> map = new HashMap<>();
map.put("b", 8.0);
map.put("c", 4.0);
map.put("d", 6.0);
System.out.println("zadd 通过map添加数据:"+jedisCluster.zadd(keyA, map));
System.out.println("返回有序集 key 的数量: "+jedisCluster.zcard(keyA));
System.out.println("返回有序集 key 中score某个范围的数量: "+jedisCluster.zcount(keyA, 3, 8));
System.out.println("zrange: 返回有序集 key 中,指定区间内的成员。按score从小到大: " + jedisCluster.zrange(keyA, 0, -1));
System.out.println("zrevrange: 返回有序集 key 中,指定区间内的成员。按score从大到小:" + jedisCluster.zrevrange(keyA, 0, -1));
System.out.println("zrangeWithScores: 返回有序集 key 中,指定区间内的成员。按score从小到大.包含分值:" + jedisCluster.zrangeWithScores(keyA, 0, -1));
System.out.println("zscore: 返回有序集 key 的分值" + jedisCluster.zscore(keyA, "aa"));
/*
返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的,不需要额外的计算)。
*/
System.out.println("zrangeByScore: 返回指定分价值之间:" + jedisCluster.zrangeByScore(keyA, 3, 8));
System.out.println("zrank: 返回有序集 key 中成员 member 的(其中有序集成员按 score 值递增(从小到大)顺序排列)排名:" + jedisCluster.zrank(keyA, "c"));
System.out.println("zrevrank: 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从大到小)顺序排列的排名:" + jedisCluster.zrevrank(keyA, "c"));
System.out.println("zrem: 移除有序集 key 中的一个或多个成员,不存在的成员将被忽略" + jedisCluster.zrem(keyA, "c", "a"));
System.out.println("zrange:中的所有元素: " + jedisCluster.zrange(keyA, 0, -1));
System.out.println("zremrangeByRank: 按下标删除 (1到2):" + jedisCluster.zremrangeByRank(keyA, 1, 2));
System.out.println("range:中的所有元素: " + jedisCluster.zrange(keyA, 0, -1));
System.out.println("zremrangeByScore: 按评分删除(1到3)" + jedisCluster.zremrangeByScore(keyA, 1, 3));
System.out.println("zrange: 中的所有元素:" + jedisCluster.zrange(keyA, 0, -1));
/*
接下来这几个操作,需要使用"{}"使得key落到同一个slot中才可以
*/
System.out.println("===================有序集合 交、差、=============");
System.out.println(jedisCluster.zadd(keyB, map));
System.out.println("zrange: keyB的所有值:" + jedisCluster.zrange(keyB, 0, -1));
/*
ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
计算给定的一个或多个有序集的并集,其中给定 key 的数量必须以 numkeys 参数指定,并将该并集(结果集)储存到 destination 。
默认情况下,结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。
WEIGHTS
使用 WEIGHTS 选项,你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor),每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。
如果没有指定 WEIGHTS 选项,乘法因子默认设置为 1 。
AGGREGATE
使用 AGGREGATE 选项,你可以指定并集的结果集的聚合方式。
默认使用的参数 SUM ,可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值;使用参数 MIN ,可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值;而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。
*/
System.out.println("zunionstore 合并keyA和keyB并保存到keyC中: " + jedisCluster.zunionstore(keyC, keyA, keyB));
System.out.println("zrange:keyC中的所有值 " + jedisCluster.zrange(keyC, 0, -1));
System.out.println("zinterstore:交集 keyC 与 keyA,KeyB" + jedisCluster.zinterstore(keyC, keyA, keyB));
System.out.println("zinterstore:交集 keyC 与 keyA" + jedisCluster.zinterstore(keyC, keyA));
System.out.println("zinterstore:交集 keyC 与 keyA" + jedisCluster.zinterstore(keyC, keyB));
System.out.println("zrange: keyC中的值" + jedisCluster.zrange(keyC, 0, -1));
}
返回结果:
====================添加返回================
zadd 添加 单个数据:1
zadd 通过map添加数据:3
返回有序集 key 的数量: 4
返回有序集 key 中score某个范围的数量: 3
zrange: 返回有序集 key 中,指定区间内的成员。按score从小到大: [c, d, b, aa]
zrevrange: 返回有序集 key 中,指定区间内的成员。按score从大到小:[aa, b, d, c]
zrangeWithScores: 返回有序集 key 中,指定区间内的成员。按score从小到大.包含分值:[[c,4.0], [d,6.0], [b,8.0], [aa,10.0]]
zscore: 返回有序集 key 的分值10.0
zrangeByScore: 返回指定分价值之间:[c, d, b]
zrank: 返回有序集 key 中成员 member 的(其中有序集成员按 score 值递增(从小到大)顺序排列)排名:0
zrevrank: 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从大到小)顺序排列的排名:3
zrem: 移除有序集 key 中的一个或多个成员,不存在的成员将被忽略1
zrange:中的所有元素: [d, b, aa]
zremrangeByRank: 按下标删除 (1到2):2
range:中的所有元素: [d]
zremrangeByScore: 按评分删除(1到3)0
zrange: 中的所有元素:[d]
===================有序集合 交、差、=============
3
zrange: keyB的所有值:[c, d, b]
zunionstore 合并keyA和keyB并保存到keyC中: 3
zrange:keyC中的所有值 [c, b, d]
zinterstore:交集 keyC 与 keyA,KeyB1
zinterstore:交集 keyC 与 keyA1
zinterstore:交集 keyC 与 keyA3
zrange: keyC中的值[c, d, b]
7、对set集合进行操作
/**
* Set集合
*/
@Test
public void setTest() throws InterruptedException {
String keyA = "{" + prefix + KEY_SPLIT + "set}a";
String keyB = "{" + prefix + KEY_SPLIT + "set}b";
jedisCluster.del(keyA);
jedisCluster.del(keyB);
System.out.println("============增删====================");
System.out.println("给集合添加数据:"+jedisCluster.sadd(keyA, "a", "b", "c"));
System.out.println("给集合添加重复数据:"+jedisCluster.sadd(keyA, "a"));
System.out.println("给集合添加非重复数据:"+jedisCluster.sadd(keyA, "d"));
System.out.println("返回集合所有数据:"+jedisCluster.smembers(keyA));
System.out.println("返回集合长度:"+jedisCluster.scard(keyA));
System.out.println("c是否在集合A中(当元素在集合A中的时候):" + jedisCluster.sismember(keyA, "c"));
System.out.println("f是否在集合A中(当元素不在集合A中的时候):" + jedisCluster.sismember(keyA, "f"));
System.out.println("返回集合中的一个随机元素:"+jedisCluster.srandmember(keyA));
System.out.println("移除并返回集合中的一个随机元素:"+jedisCluster.spop(keyA));
System.out.println("返回集合所有数据:"+jedisCluster.smembers(keyA));
System.out.println("============smove命令====================");
/*
SMOVE 是原子性操作。
如果 source 集合不存在或不包含指定的 member 元素,则 SMOVE 命令不执行任何操作,仅返回 0 。否则, member 元素从 source 集合中被移除,并添加到 destination 集合中去。
当 destination 集合已经包含 member 元素时, SMOVE 命令只是简单地将 source 集合中的 member 元素删除。
当 source 或 destination 不是集合类型时,返回一个错误。
注:不可以在redis-cluster中使用SMOVE:redis.clients.jedis.exceptions.JedisClusterException:
No way to dispatch this command to Redis Cluster because keys have different slots.
解决办法可以参考上面的mset命令,使用“{}”来讲可以设置的同一个slot中
*/
System.out.println("将集合keyA的a中元素移动到keyB:"+jedisCluster.smove(keyA, keyB, "a"));
System.out.println("返回集合keyA所有数据: " + jedisCluster.smembers(keyA));
System.out.println("返回集合keyB所有数据: " + jedisCluster.smembers(keyB));
System.out.println("============差、交、并====================");
System.out.println("返回集合keyB添加数据: "+jedisCluster.sadd(keyB, "a", "f", "c"));
System.out.println("sdiff差集 keyA-keyB: "+jedisCluster.sdiff(keyA, keyB));
System.out.println("sinter交集:"+jedisCluster.sinter(keyA, keyB));
System.out.println("sunion并集"+jedisCluster.sunion(keyA, keyB));
}
返回结果:
============增删====================
给集合添加数据:3
给集合添加重复数据:0
给集合添加非重复数据:1
返回集合所有数据:[d, c, a, b]
返回集合长度:4
c是否在集合A中(当元素在集合A中的时候):true
f是否在集合A中(当元素不在集合A中的时候):false
返回集合中的一个随机元素:b
移除并返回集合中的一个随机元素:d
返回集合所有数据:[c, a, b]
============smove命令====================
将集合keyA的a中元素移动到keyB:1
返回集合keyA所有数据: [c, b]
返回集合keyB所有数据: [a]
============差、交、并====================
返回集合keyB添加数据: 2
sdiff差集 keyA-keyB: [b]
sinter交集:[c]
sunion并集[a, f, c, b]
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
发布者:全栈程序员栈长,转载请注明出处:https://javaforall.cn/181995.html原文链接:https://javaforall.cn