目录
- Redis 数据类型
- 一、Redis 字符串(String)
- 二、Redis 哈希(Hash)
- 三、Redis 列表(List)
- 四、Redis 集合(Set)
- 五、Redis 有序集合(sorted set)
Redis 数据类型
Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。
一、Redis 字符串(String)
代码语言：javascript复制ValueOperations valueOperations = redisTemplate.opsForValue();
/**Set void*/
valueOperations.set("keyDemo","hello");
/**Set void 同一个key,会对原有的value进行复写，该set可以设置失效时间*/
valueOperations.set("keyDemo","hello word",30, TimeUnit.SECONDS);
/**Set void(复写) 从上一个值的6下标开始复写*/
valueOperations.set("keyDemo","redis",6);
//结果： hello redis
/**如果key已经存在，则该值追加到字符串的末尾。
* 如果键不存在，则它被创建并设置为空字符串*/
valueOperations.append("keyDemo"," By");
valueOperations.append("keyDemo1","Hello");
// keyDemo 结果： hello redis By
// keyDemo1 结果： Hello
/**size Long 返回key所对应的value的长度*/
System.out.println("****5key****：" valueOperations.size("keyDemo"));
// 结果：14
/**getAndSet String 先取Key对应的值，再进行赋值*/
System.out.println("****6key****：" valueOperations.getAndSet("keyDemo","String Type is End!"));
// 结果 hello redis By
System.out.println("****7key****：" valueOperations.get("keyDemo"));
// 结果 String Type is End!二、Redis 哈希(Hash)
代码语言：javascript复制/**设置过期时间*/
redisTemplate.expire("redisHash",10, TimeUnit.SECONDS);
HashOperations hashOperations = redisTemplate.opsForHash();
/**void put(H key, HK hashKey, HV value);
设置散列hashKey的值*/
hashOperations.put("redisHash","name","666");
hashOperations.put("redisHash","age",26);
hashOperations.put("redisHash","class","6");
//结果：结果：{age=26, class=6, name=666}
/**void putAll(H key, Map<? extends HK, ? extends HV> m);
使用m中提供的多个散列字段设置到key对应的散列表中*/
Map<String,Object> testMap = new HashMap();
testMap.put("name","666");
testMap.put("age",27);
testMap.put("class","1");
hashOperations.putAll("redisHash1",testMap);
System.out.println(hashOperations.entries("redisHash1"));
//结果：结果：{class=1, name=jack, age=27}
/**Set<HK> keys(H key);
获取key所对应的散列表的key*/
System.out.println(hashOperations.keys("redisHash"));
//结果：redisHash所对应的散列表为{class=1, name=666, age=27}
//结果：结果：[name, class, age]
/**
* HV get(H key, Object hashKey);
*/
System.out.println(hashOperations.get("redisHash","age"));
//结果：结果：26
/**
* Boolean hasKey(H key, Object hashKey);
* 确定哈希hashKey是否存在
*/
System.out.println(hashOperations.hasKey("redisHash","666")); //结果：true
System.out.println(hashOperations.hasKey("redisHash","777"));//结果：false
/**List<HV> values(H key);
获取整个哈希存储的值根据密钥*/
System.out.println(hashOperations.values("redisHash"));
//结果：[666, 26, 6]
/**Map<HK, HV> entries(H key);
获取整个哈希存储根据密钥*/
System.out.println(hashOperations.entries("redisHash"));
//结果：{age=26, class=6, name=666}
/** Cursor<Map.Entry<HK, HV>> scan(H key, ScanOptions options);
使用Cursor在key的hash中迭代，相当于迭代器。*/
Cursor<Map.Entry<Object, Object>> curosr = hashOperations.scan("redisHash",
ScanOptions.NONE);
while(curosr.hasNext()){
Map.Entry<Object, Object> entry = curosr.next();
System.out.println(entry.getKey() ":" entry.getValue());
}
//结果：age:27 class:6 name:666
/**
* Long delete(H key, Object... hashKeys);
* 删除给定的哈希hashKeys
*/
System.out.println(hashOperations.delete("redisHash","name"));
System.out.println(hashOperations.entries("redisHash"));
//结果：1
//结果：{class=6, age=26}三、Redis 列表(List)
代码语言：javascript复制/**设置过期时间*/
redisTemplate.expire("redisHash",10, TimeUnit.SECONDS);
ListOperations listOperations = redisTemplate.opsForList();
/**leftPush Long
* 将指定的值插入存储在键的列表的头部。（从左边插入）*/
Long aLong = listOperations.leftPush("listKey","kyee"); // 返回1
Long aLong1 = listOperations.leftPush("listKey","shinow");//返回2
Long aLong2 = listOperations.leftPushAll("listKey", "aa", "bb", "cc");
/** leftPushAll(K key, V... values) Long;
批量把一批参数插入到列表中
leftPushAll(Collection collection)
把一个集合插入List表
*/
String[] str = {"1","2","3"};
List<String> strings = Arrays.asList(str);
Long aLong3 = listOperations.leftPushAll("listKey", "aa", "bb", "cc");
Long aLong4 = listOperations.leftPushAll("listKey", strings);
/**leftPush && leftPushAll 两个命令和上述类似，不做介绍*/
/** set(K key, long index, V value) 在列表中index的位置设置并覆盖value值*/
listOperations.set("listKey",2,"test");
//结果：kyee,shinow,test,bb,cc, .....
/**Long remove(K key, long count, Object value);
* count<0 删除从尾到头的第一个等于value的元素
* count=0 删除所有等于value的元素
* count>0 删除从头到尾第一个等于value的元素
* */
Long remove0 = listOperations.remove("listKey", 0, "aa");
Long remove1 = listOperations.remove("listKey", 1, "aa");
Long remove2 = listOperations.remove("listKey", -1, "aa");
/**Object index(K key, long index);
* 根据下表获取列表中的值*/
listOperations.index("listKey",2);
/**Object leftPop(K key);
弹出最左边的元素，弹出之后该值在列表中将不复存在*/
listOperations.leftPop("listKey");
/**
* leftPop(K key, long timeout, TimeUnit unit)
*移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。*/
listOperations.leftPop("listKey",10,TimeUnit.SECONDS);
/**rightPop 两个命令和上述类似，不做介绍*/四、Redis 集合(Set)
代码语言：javascript复制SetOperations setOperations = redisTemplate.opsForSet();
/**Long add(K key, V... values);
无序集合中添加元素，返回添加个数
也可以直接在add里面添加多个值 如：template.opsForSet().add("setTest","aaa","bbb")*/
String[] strs= new String[]{"str1","str2"};
System.out.println(setOperations.add("setTest", strs));
//结果：2
/**Long remove(K key, Object... values);
移除集合中一个或多个成员*/
System.out.println(setOperations.remove("setTest",strs));
//结果：2
/**V pop(K key);
移除并返回集合中的一个随机元素*/
System.out.println(setOperations.pop("setTest"));
System.out.println(setOperations.members("setTest"));
//结果：bbb
//结果： [aaa, ccc]
/**Boolean move(K key, V value, K destKey);
将 member 元素从 source 集合移动到 destination 集合*/
setOperations.move("setTest","aaa","setTest2");
System.out.println(setOperations.members("setTest"));
System.out.println(setOperations.members("setTest2"));
//结果：[ccc]
//结果：[aaa]
/**Cursor<V> scan(K key, ScanOptions options);
遍历set*/
Cursor<Object> curosr = setOperations.scan("setTest", ScanOptions.NONE);
while(curosr.hasNext()){
System.out.println(curosr.next());
}五、Redis 有序集合(sorted set)
代码语言：javascript复制ZSetOperations zSetOperations = redisTemplate.opsForZSet();
/**
* Boolean add(K key, V value, double score);
* 新增一个有序集合，存在的话为false，不存在的话为true
* ZSet内部是按照score排序
* */
zSetOperations.add("Z-set1","abc",2);
/**Long add(K key, Set<TypedTuple<V>> tuples);*/
ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zset-5",9.6);
ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zset-6",9.9);
Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<ZSetOperations.TypedTuple<Object>>();
tuples.add(objectTypedTuple1);
tuples.add(objectTypedTuple2);
System.out.println(zSetOperations.add("zset1",tuples));
System.out.println(zSetOperations.range("zset1",0,-1));
//结果：[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]
/**Long size(K key);
获取有序集合的成员数，内部调用的就是zCard方法*/
System.out.println(zSetOperations.size("zset1"));
//结果：6
/**Long remove(K key, Object... values);
从有序集合中移除一个或者多个元素*/
System.out.println(zSetOperations.range("zset1",0,-1));
System.out.println(zSetOperations.remove("zset1","zset-6"));
System.out.println(zSetOperations.range("zset1",0,-1));
//结果：[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]
//结果： 1
//结果：[zset-1, zset-2, zset-3, zset-4, zset-5]
/**Long rank(K key, Object o);
返回有序集中指定成员的排名，其中有序集成员按分数值递增(从小到大)顺序排列*/
System.out.println(zSetOperations.range("zset1",0,-1));
System.out.println(zSetOperations.rank("zset1","zset-2"));
//结果：[zset-2, zset-1, zset-3, zset-4, zset-5]
//结果：0 表明排名第一
/**Cursor<TypedTuple<V>> scan(K key, ScanOptions options);
遍历zset*/
Cursor<ZSetOperations.TypedTuple<Object>> cursor = zSetOperations.scan("zzset1", ScanOptions.NONE);
while (cursor.hasNext()){
ZSetOperations.TypedTuple<Object> item = cursor.next();
System.out.println(item.getValue() ":" item.getScore());
}
//结果：zset-1:1.0
//结果：zset-2:2.0
//结果：zset-3:3.0
//结果：zset-4:6.0
/**Long count(K key, double min, double max);
通过分数返回有序集合指定区间内的成员个数*/
System.out.println(zSetOperations.rangeByScore("zset1",0,5));
System.out.println(zSetOperations.count("zset1",0,5));
//结果：[zset-2, zset-1, zset-3]
//结果： 3
/**Double score(K key, Object o);
获取指定成员的score值*/
System.out.println(zSetOperations.score("zset1","zset-1"));
//结果：2.2
/**Long removeRange(K key, long start, long end);
移除指定索引位置的成员，其中有序集成员按分数值递增(从小到大)顺序排列*/
System.out.println(zSetOperations.range("zset2",0,-1));
System.out.println(zSetOperations.removeRange("zset2",1,2));
System.out.println(zSetOperations.range("zset2",0,-1));
//结果：[zset-1, zset-2, zset-3, zset-4]
//结果：2
//结果：[zset-1, zset-4]
