介绍
springboot整合redis需要的是spring的另外一个项目 spring data ；
他使用的是RedisTemplate这个类来进行操作
导入依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>
配置文件
spring:
redis:
# redis服务端主机
host: localhost
# 端口
port: 6379
RedisConfig
package com.example.springdataredisdemo.config;
import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
/**
* @Description:
* @Author Aeolian
* @Date: 2021/4/9 14:26
* @EMAIL:
*/
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(redisConnectionFactory);
// 使用的fastjson的序列化，需要导入fastjson的包
GenericFastJsonRedisSerializer genericFastJsonRedisSerializer = new GenericFastJsonRedisSerializer();
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key 采用 String 的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash 的 key 也采用 String 的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value 序列化方式采用 fastjson
template.setValueSerializer(genericFastJsonRedisSerializer);
// hash 的 value 序列化方式采用 fastjson
template.setHashValueSerializer(genericFastJsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
// 两种连接方式选一个 推荐使用LettuceConnectionFactory
@Bean
public RedisConnectionFactory redisConnectionFactory(){
return new JedisConnectionFactory(new RedisStandaloneConfiguration("localhost",6379));
}
@Bean
public RedisConnectionFactory redisConnectionFactory1(){
return new LettuceConnectionFactory(new RedisStandaloneConfiguration("localhost",6379));
}
}
测试
String
package com.example.springdataredisdemo;
import com.example.springdataredisdemo.pojo.User;
import org.junit.After;
import org.junit.Before;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@SpringBootTest
public class StringDemo {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
ValueOperations<String, Object> valueOperations;
/**
* set/get操作
*/
@Test
void textSetAndGet() {
valueOperations = redisTemplate.opsForValue();
// set 值
valueOperations.set("k1","v1");
valueOperations.set("k2","v2");
valueOperations.set("k3","v3");
// get
System.out.println(valueOperations.get("k1"));
System.out.println(valueOperations.get("k2"));
System.out.println(valueOperations.get("k3"));
// 长度
System.out.println(valueOperations.size("k1"));
}
/**
* 自增和自减
*/
@Test
void testStringIncrAndDecr(){
valueOperations = redisTemplate.opsForValue();
// 自增长和自减
valueOperations.set("k1",1);
valueOperations.set("k2",2);
// 默认增长1
valueOperations.increment("k1");
System.out.println(valueOperations.get("k1"));
// 指定
valueOperations.increment("k1",2);
System.out.println(valueOperations.get("k1"));
// 负数就是减与decrement同样的效果 反向思维即可
valueOperations.increment("k1",-1);
valueOperations.decrement("k2",2);
System.out.println(valueOperations.get("k1"));
System.out.println(valueOperations.get("k2"));
}
/**
* 主要json的序列化问题，如果使用json的序列化作为String类型value的序列化，那么对于逗号的识别会有问题，
* 只有转换为String的序列化才能解决问题.
* append操作
*/
@Test
void testAppend(){
valueOperations = redisTemplate.opsForValue();
valueOperations.set("k1","hello,");
valueOperations.append("k1","world");
System.out.println(valueOperations.get("k1"));
}
/**
* 字符串替换及范围获取
*/
@Test
void testRange(){
valueOperations = redisTemplate.opsForValue();
valueOperations.set("k1","helloworld");
String s = "abc";
// 范围获取 hell
System.out.println(valueOperations.get("k1", 0, 3));
// 替换 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
valueOperations.set("k1",s,3);
System.out.println(valueOperations.get("k1"));
}
/**
* 设置过期时间及只有在 key 不存在时设置 key 的值
*/
@Test
void testSetexAndSetnx() throws InterruptedException {
valueOperations = redisTemplate.opsForValue();
// 设置这个key 30秒后过期
valueOperations.set("k1","v1",30,TimeUnit.SECONDS);
Thread.sleep(3000);
// 还有多少秒过期
System.out.println(redisTemplate.getExpire("k1",TimeUnit.SECONDS));
// 只有在 key 不存在时设置 key 的值
if (valueOperations.setIfAbsent("k1","hello")) {
System.out.println("不存在创建成功");
}else {
System.out.println("存在创建失败");
}
System.out.println("k1的值："+valueOperations.get("k1"));
if (valueOperations.setIfAbsent("k5","v2")){
System.out.println("不存在创建成功");
}else {
System.out.println("存在创建失败");
}
System.out.println("k5的值："+valueOperations.get("k5"));
}
/**
* 批量添加 key-value
* 批量获取 value
*/
@Test
void testMset(){
valueOperations = redisTemplate.opsForValue();
Map<String,Object> map = new HashMap<>();
map.put("key1","v1");
map.put("key2","v2");
map.put("key3","v3");
valueOperations.multiSet(map);
List<String> list = new ArrayList<>();
list.add("key1");
list.add("key2");
list.add("key3");
for (Object o : valueOperations.multiGet(list)) {
System.out.println(o);
}
}
/**
* 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在才会设置成功
*/
@Test
void testMultiSetIfAbsent(){
valueOperations = redisTemplate.opsForValue();
Map<String,Object> map = new HashMap<>();
map.put("key4","v1");
map.put("key5","v2");
map.put("key6","v3");
valueOperations.multiSet(map);
List<String> list = new ArrayList<>();
list.add("key4");
list.add("key5");
list.add("key6");
for (Object o : valueOperations.multiGet(list)) {
System.out.println(o);
}
}
@Test
void testPojo(){
valueOperations = redisTemplate.opsForValue();
User user = new User();
user.setUsername("zhangsan");
user.setPassword("123456");
valueOperations.set("k1",user);
System.out.println(valueOperations.get("k1"));
}
}
Hash
package com.example.springdataredisdemo;
import com.example.springdataredisdemo.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @Description:
* @Author Aeolian
* @Date: 2021/4/11 22:30
* @EMAIL:
*/
@SpringBootTest
public class MapDemo {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
HashOperations<String, String, Object> hashOperations;
/**
* put/get
*/
@Test
void testGetAndSet(){
hashOperations = redisTemplate.opsForHash();
hashOperations.put("k1","field1","v1");
hashOperations.put("k1","field2","v2");
hashOperations.put("k1","field3","v3");
Map<String, Object> k1 = hashOperations.entries("k1");
for (Map.Entry<String, Object> objectObjectEntry : k1.entrySet()) {
System.out.println(objectObjectEntry);
}
System.out.println("===========================");
System.out.println("field1="+hashOperations.get("k1", "field1"));
System.out.println("field2="+hashOperations.get("k1", "field2"));
System.out.println("field3="+hashOperations.get("k1", "field3"));
System.out.println("===========================");
System.out.println("k1"+hashOperations.values("k1"));
System.out.println("============================");
Cursor<Map.Entry<String, Object>> scan = hashOperations.scan("k1", ScanOptions.scanOptions().build());
while (scan.hasNext()){
Map.Entry<String, Object> next = scan.next();
System.out.println(next.getKey()+":"+next.getValue());
}
System.out.println("============================");
Map<String,Object> map = new HashMap<>();
map.put("filed1","v1");
map.put("filed2","v2");
map.put("filed3","v3");
hashOperations.putAll("k2",map);
Map<String, Object> k2 = hashOperations.entries("k2");
for (Map.Entry<String, Object> objectObjectEntry : k1.entrySet()) {
System.out.println("k2:"+objectObjectEntry);
}
}
/**
* 仅当 hashKey 不存在时才设置
*/
@Test
void testPutIfAbsent(){
hashOperations = redisTemplate.opsForHash();
if (hashOperations.putIfAbsent("k1","field1","v1")) {
System.out.println("不存在设置成功");
}else {
System.out.println("存在设置失败");
}
Map<String, Object> k1 = hashOperations.entries("k1");
for (Map.Entry<String, Object> objectObjectEntry : k1.entrySet()) {
System.out.println(objectObjectEntry);
}
if (hashOperations.putIfAbsent("k3","field1","v1")) {
System.out.println("不存在设置成功");
}else {
System.out.println("存在设置失败");
}
Map<String, Object> k3 = hashOperations.entries("k3");
for (Map.Entry<String, Object> objectObjectEntry : k3.entrySet()) {
System.out.println(objectObjectEntry);
}
}
/**
* 删除
*/
@Test
void testDel(){
hashOperations = redisTemplate.opsForHash();
// 判断是否有这个字段
if (hashOperations.hasKey("k1","field1")){
hashOperations.delete("k1","field1");
}
Map<String, Object> k1 = hashOperations.entries("k1");
for (Map.Entry<String, Object> objectObjectEntry : k1.entrySet()) {
System.out.println(objectObjectEntry);
}
}
/**
* 获取hash字段的数量和hash表的字段
*/
@Test
void testKeysAndValues(){
hashOperations = redisTemplate.opsForHash();
System.out.println("k1的字段数:"+hashOperations.size("k1"));
// 获取到k1的所有字段
Set<String> k1 = hashOperations.keys("k1");
for (String s : k1) {
System.out.println("k1:"+s+"="+hashOperations.get("k1", s));
}
}
/**
* 增量
*/
@Test
void testIncrAndDecr(){
hashOperations = redisTemplate.opsForHash();
hashOperations.put("k4","field1",1);
// 增量
hashOperations.increment("k4","field1",1);
System.out.println("====输出增量后的值===");
System.out.println(hashOperations.get("k4", "field1"));
// 减
hashOperations.increment("k4","field1",-2);
System.out.println("====输出减量后的值===");
System.out.println(hashOperations.get("k4", "field1"));
}
}
List
package com.example.springdataredisdemo;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.ArrayList;
import java.util.List;
/**
* @Description:
* @Author Aeolian
* @Date: 2021/4/12 9:35
* @EMAIL:
*/
@SpringBootTest
public class ListDemo {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
ListOperations<String, Object> listOperations;
/**
* left 头插法
*/
@Test
void testLeft(){
listOperations = redisTemplate.opsForList();
// 头插 hello3 hello2 hello1
listOperations.leftPush("k1","hello1");
listOperations.leftPush("k1","hello2");
listOperations.leftPush("k1","hello3");
// 通过下标获取值
System.out.println(listOperations.index("k1", 0));
System.out.println(listOperations.index("k1", 1));
System.out.println(listOperations.index("k1", 2));
// 通过指定下标设置值，前提这个key已经存在且长度没有超出
listOperations.set("k1",0,"v1");
listOperations.set("k1",1,"v2");
listOperations.set("k1",2,"v3");
// 通过范围获取
System.out.println("===通过范围获取===");
System.out.println("k1:"+listOperations.range("k1",0,-1));
// 多个值存储
listOperations.leftPushAll("k2","v1","v2","v3","v4");
List<String> list = new ArrayList<>();
list.add("v1");
list.add("v2");
list.add("v3");
list.add("v4");
listOperations.leftPushAll("k3",list);
System.out.println("k2:"+listOperations.range("k2",0,-1));
System.out.println("k3:"+listOperations.range("k3",0,-1));
// 如果k1的v1存在，就在v1前添加
listOperations.leftPush("k1","v1","v0");
System.out.println("===========");
System.out.println("k1:"+listOperations.range("k1",0,-1));
// pop 弹出顶层的元素
System.out.println("=====POP======");
System.out.println("k1的数量:"+listOperations.size("k1"));
System.out.println(listOperations.leftPop("k1"));
System.out.println(listOperations.leftPop("k1"));
System.out.println(listOperations.leftPop("k1"));
System.out.println("pop后k1的数量:"+listOperations.size("k1"));
}
/**
* right 尾插法 头插和尾插很多都是通用的，只是位置问题。
*/
@Test
void testRight(){
listOperations = redisTemplate.opsForList();
// 尾插 v1 v2 v3
listOperations.rightPush("k1","v1");
listOperations.rightPush("k1","v2");
listOperations.rightPush("k1","v3");
System.out.println(listOperations.range("k1",0,-1));
// pop
listOperations.rightPop("k1");
listOperations.leftPop("k1");
System.out.println(listOperations.range("k1",0,-1));
// 尾部弹出，头部插入
listOperations.rightPush("k1","v1");
listOperations.leftPush("k1","v3");
listOperations.rightPush("k2","hello1");
// 将k1的尾部弹出插入到k2的头部
listOperations.rightPopAndLeftPush("k1","k2");
System.out.println("===================");
System.out.println(listOperations.range("k1",0,-1));
System.out.println(listOperations.range("k2",0,-1));
}
/**
* list内部操作
*/
@Test
void testList(){
listOperations = redisTemplate.opsForList();
// 尾插 v1 v2 v3
listOperations.rightPush("k1","v1");
listOperations.rightPush("k1","v1");
listOperations.rightPush("k1","v2");
listOperations.rightPush("k1","v2");
listOperations.rightPush("k1","v3");
listOperations.rightPush("k1","v3");
// 长度
System.out.println("k1的长度为："+listOperations.size("k1"));
// 删除指定的value元素
// index = 0, 删除所有值等于value的元素;
// index > 0, 从头部开始删除第一个值等于 value 的元素;
// index < 0, 从尾部开始删除第一个值等于 value 的元素;
listOperations.remove("k1",0,"v1");
System.out.println("====删除后=====");
System.out.println("k1:"+listOperations.range("k1",0,-1));
// 裁剪
listOperations.trim("k1",0,2);
System.out.println("====裁剪后=====");
System.out.println("k1:"+listOperations.range("k1",0,-1));
}
}
Set
package com.example.springdataredisdemo;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
/**
* @Description:
* @Author Aeolian
* @Date: 2021/4/12 11:34
* @EMAIL:
*/
@SpringBootTest
public class SetDemo {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
SetOperations<String, Object> setOperations;
@Test
void test(){
setOperations = redisTemplate.opsForSet();
// add 可以添加多个
setOperations.add("k1","v1","v2","v3");
setOperations.add("k2","v1","v2","v3");
// setOperations.add("k3","hello1","hello2","hello3");
// 移除 可以移除多个
System.out.println("========移除k1的多个元素===========");
setOperations.remove("k1","v1","v2");
System.out.println(setOperations.members("k1"));
// 移除并返回集合的一个随机元素
Object k2 = setOperations.pop("k2");
System.out.println("=========移除返回元素==========");
System.out.println("随机移除k2的元素："+k2);
// 将元素 value 从一个集合移到另一个集合
System.out.println("========元素 value 从一个集合移到另一个集合===========");
setOperations.add("k1","v1","v2");
setOperations.move("k1",k2,"k2");
System.out.println("k1："+setOperations.members("k1"));
System.out.println("k2："+setOperations.members("k2"));
// 集合大小 这里k1已经将一个元素移至k2，所以长度为2
System.out.println("========k1的长度===========");
System.out.println(setOperations.size("k1"));
// 判断是否含有这个value 包含返回 true, 不包含返回 false
System.out.println("========k1是否包含===========");
if (setOperations.isMember("k1",k2)){
System.out.println("k1不存在:"+k2);
}else {
System.out.println("k1存在:"+k2);
}
// 获取两个集合的交集
System.out.println("=========两个集合的元素交集==========");
Set<Object> intersect = setOperations.intersect("k1", "k2");
System.out.println("k1和k2的交集元素："+intersect);
// 还可以指定多个集合
System.out.println("=========多个集合的元素交集==========");
List<String> list = new ArrayList<>();
list.add("k1");
list.add("k2");
Set<Object> intersect1 = setOperations.intersect(list);
System.out.println("k1和k2的交集元素："+intersect1);
// key 集合与 otherKey 集合的交集存储到 destKey 中、 返回新集合的长度
setOperations.intersectAndStore("k1", "k2", "k5");
System.out.println("=========多个集合的元素交集存入新的集合==========");
System.out.println("k5:"+setOperations.members("k5"));
// 集合与集合间的并集
Set<Object> union = setOperations.union("k1", "k2");
System.out.println("=========多个集合的元素并集==========");
System.out.println("多个集合元素的并集："+union);
// key 集合与 otherKey 集合的并集存储到 destKey 中、 返回新集合的长度
setOperations.unionAndStore("k1", "k2", "k3");
System.out.println("=========多个集合的元素并集存入新的集合==========");
System.out.println("k3:"+setOperations.members("k3"));
// 获取两个集合的差集
setOperations.add("k1","hello");
setOperations.add("k2","helloworld");
System.out.println("=========两个集合的元素差集==========");
Set<Object> intersect2 = setOperations.difference("k1", "k2");
System.out.println("k1和k2的差集元素："+intersect2);
// 还可以指定多个集合
System.out.println("=========多个集合的元素差集==========");
List<String> list2 = new ArrayList<>();
list2.add("k1");
list2.add("k2");
Set<Object> intersect3 = setOperations.difference(list2);
System.out.println("k1和k2的差集元素："+intersect3);
// key 集合与 otherKey 集合的差集存储到 destKey 中、 返回新集合的长度
setOperations.differenceAndStore("k1","k2","k4");
System.out.println("=========多个集合的元素差集存入新的集合==========");
System.out.println("k4:"+setOperations.members("k4"));
// 随机获取集合中的一个元素
System.out.println("随机获取k1的元素："+setOperations.randomMember("k1"));
// 随机获取集合中的多个个元素
System.out.println("随机获取k1的多个元素："+setOperations.randomMembers("k1",2));
}
}
ZSet
package com.example.springdataredisdemo;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.DefaultTypedTuple;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import java.util.HashSet;
import java.util.Set;
/**
* @Description:
* @Author Aeolian
* @Date: 2021/4/12 14:40
* @EMAIL:
*/
@SpringBootTest
public class ZSetDemo {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
@Test
void test(){
ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();;
// 添加元素
zSetOperations.add("k1","one",1);
// 集合添加元素
ZSetOperations.TypedTuple<Object> typedTuple = new DefaultTypedTuple<Object>("two",2D);
ZSetOperations.TypedTuple<Object> typedTuple2 = new DefaultTypedTuple<Object>("three",3D);
Set<ZSetOperations.TypedTuple<Object>> set = new HashSet<>();
set.add(typedTuple);
set.add(typedTuple2);
zSetOperations.add("k1",set);
// 按顺序输出元素
System.out.println("=========按顺序输出元素============");
System.out.println(zSetOperations.range("k1",0,-1));
// 移除有序集合中的值
System.out.println("=========移除有序集合中的值============");
zSetOperations.remove("k1","tow","three");
System.out.println(zSetOperations.range("k1",0,-1));
// 移除指定索引位置的成员
System.out.println("=========移除指定索引位置的成员============");
zSetOperations.add("k1",set);
zSetOperations.removeRange("k1",1,2);
System.out.println(zSetOperations.range("k1",0,-1));
// 根据指定的 score 值的范围来移除成员
System.out.println("=========根据指定的 score 值的范围来移除成员============");
zSetOperations.add("k1",set);
zSetOperations.removeRangeByScore("k1",1,3);
System.out.println(zSetOperations.range("k1",0,-1));
// 增加元素的 score 值，并返回增加后的值
System.out.println("=========增加元素的 score 值，并返回增加后的值============");
zSetOperations.add("k1",set);
zSetOperations.incrementScore("k1","one",4);
System.out.println(zSetOperations.range("k1",0,-1));
// 返回元素在集合的排名,有序集合是按照元素的 score 值由小到大排列
System.out.println("=========返回元素在集合的排名,有序集合是按照元素的 score 值由小到大排列============");
System.out.println("one的排行："+zSetOperations.rank("k1", "one"));
// 返回元素在集合的排名,按元素的 score 值由大到小排列
System.out.println("=========返回元素在集合的排名,按元素的 score 值由大到小排列============");
System.out.println("one的排行："+zSetOperations.reverseRank("k1", "one"));
// 获取集合元素, 并且把 score 值也获取
System.out.println("=========获取集合元素, 并且把 score 值也获取============");
Set<ZSetOperations.TypedTuple<Object>> set1 = zSetOperations.rangeWithScores("k1", 0, 2);
for (ZSetOperations.TypedTuple<Object> objectTypedTuple : set1) {
System.out.println(objectTypedTuple.getScore()+":"+objectTypedTuple.getValue());
}
// 根据 score 值查询集合元素 这里应该只会输出一个two 因为只有two在这个区间
System.out.println("k1:"+zSetOperations.rangeByScore("k1", 0, 2));
// 根据 score 值查询集合元素及其分数, 并按分数从小到大排序
System.out.println("=========根据 score 值查询集合元素及其分数, 并按分数从小到大排序============");
Set<ZSetOperations.TypedTuple<Object>> set2 = zSetOperations.rangeWithScores("k1", 0, 6);
for (ZSetOperations.TypedTuple<Object> objectTypedTuple : set2) {
System.out.println(objectTypedTuple.getScore()+":"+objectTypedTuple.getValue());
}
// 获取集合的元素, 从大到小排序
System.out.println("k1:"+zSetOperations.reverseRange("k1",0,-1));
// 说明：反序输出也可以使用类似上面的方法，只不过顺序是反的
// 根据 score 值获取集合元素数量
System.out.println("=========根据 score 值获取集合元素数量============");
System.out.println("k1:"+zSetOperations.count("k1",0,3));
// 获取集合大小 size的底层实现还是ZCard
System.out.println("=========获取集合大小============");
System.out.println("k1的大小："+zSetOperations.size("k1"));
System.out.println("k1的大小："+zSetOperations.zCard("k1"));
// 获取集合中 value 元素的 score 值
System.out.println("=========获取集合中 value 元素的 score 值============");
System.out.println("k1的one元素的score值："+zSetOperations.score("k1","one"));
// ZSet也有并集交集差集，调用方法和set是一致的
}
}
扫一扫
21万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
