package com.hl.chapter29.web;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* 测试接口
*/
@Controller
public class DemoController {
@Autowired
private RedisTemplate redisTemplate;
/**
* String类型
*/
@PostMapping(value = "/string")
@ResponseBody
public String stringTest(HttpServletRequest request, @RequestBody String req) {
// 插入一个key值
redisTemplate.opsForValue().set("a", 1000);
// 判断是否有key对应的值,有返回true,没有返回false
boolean isExist = redisTemplate.hasKey("a");
System.out.println(isExist);
// 取出key对应的值
redisTemplate.opsForValue().get("a");
// 删除某个key
redisTemplate.delete("a");
// 批量删除key
List keys = new ArrayList<String>();
keys.add("a");
keys.add("b");
redisTemplate.delete(keys);
// 将当前传入的key值序列化为btye[]类型
redisTemplate.opsForValue().set("b", 2000);
System.out.println(redisTemplate.dump("b"));
// 设置过期时间
redisTemplate.expire("b", 10000, TimeUnit.MILLISECONDS);
// System.out.println(redisTemplate.expireAt("b", new Date()));
// 查找匹配的key值,返回set集合
redisTemplate.opsForValue().set("a", 1100);
redisTemplate.opsForValue().set("c", 3000);
System.out.println(redisTemplate.keys("*"));
// 修改key名称
redisTemplate.rename("a", "aa");
// 返回传入key存储的数据类型
System.out.println(redisTemplate.type("aa"));
// 随机取出一个key
System.out.println(redisTemplate.randomKey());
// 返回当前key剩余过期时间
System.out.println(redisTemplate.getExpire("aa"));
System.out.println(redisTemplate.getExpire("aa", TimeUnit.SECONDS));
// 将key持久化
redisTemplate.persist("c");
// 将当前key迁移到指定数据库中
redisTemplate.move("c", 1);
// 返回部分字符
System.out.println(redisTemplate.opsForValue().get("a", 0, 2));
// 批量获取值
List keys2 = new ArrayList();
keys2.add("a");
keys2.add("b");
keys2.add("c");
System.out.println(redisTemplate.opsForValue().multiGet(keys2));
// 新增字符串
redisTemplate.opsForValue().append("a", "1000");
// 如果对应的map集合名称不存在,则添加否则不做修改
Map valueMap = new HashMap();
valueMap.put("valueMap1", "map1");
valueMap.put("valueMap2", "map2");
valueMap.put("valueMap3", "map3");
redisTemplate.opsForValue().multiSetIfAbsent(valueMap);
// 设置map集合到redis
Map valueMap2 = new HashMap();
valueMap2.put("valueMap1", "map1");
valueMap2.put("valueMap2", "map2");
valueMap2.put("valueMap3", "map3");
redisTemplate.opsForValue().multiSet(valueMap2);
// 获取字符串的长度
redisTemplate.opsForValue().size("a");
// 重新设置key对应的值,如果存在返回false,否则返回true
redisTemplate.opsForValue().setIfAbsent("a", 33);
// 将值 value 关联到 key,并将 key 的过期时间设为 timeout
redisTemplate.opsForValue().set("a", 2000, 10, TimeUnit.HOURS);
// 将二进制第offset位值变为value
// redisTemplate.opsForValue().setBit(key, offset, value);
// 对key所储存的字符串值,获取指定偏移量上的位(bit)
// redisTemplate.opsForValue().getBit(key, offset);
return JSONObject.parseObject(req).toJSONString();
}
/**
* hash类型
*/
@RequestMapping(value = "/hash")
@ResponseBody
public String hashTest(HttpServletRequest request) {
// 新增hashMap值
redisTemplate.opsForHash().put("hash", "a", "第一个");
// 获取指定map键是否有值,有就返回,没有返回null
System.out.println(redisTemplate.opsForHash().get("hash", "a"));
// 获取指定key中所有键值对
redisTemplate.opsForHash().put("hash", "b", "第二个");
redisTemplate.opsForHash().put("hash", "c", "第三个");
System.out.println(redisTemplate.opsForHash().entries("hash"));
// 以Map集合的方式添加键值对
Map map = new HashMap<String, String>();
map.put("d", "第四个");
map.put("e", "第五个");
redisTemplate.opsForHash().putAll("hash", map);
System.out.println(redisTemplate.opsForHash().entries("hash"));
// 仅当hashKey不存在时才设置
redisTemplate.opsForHash().putIfAbsent("hash", "a", "不是第一个了");
redisTemplate.opsForHash().putIfAbsent("hash", "f", "第六个");
System.out.println(redisTemplate.opsForHash().entries("hash"));
// 删除一个或多个hash表字段
redisTemplate.opsForHash().delete("hash", "e", "f");
System.out.println(redisTemplate.opsForHash().entries("hash"));
// 查看hash表中指定字段是否存在
System.out.println(redisTemplate.opsForHash().hasKey("hash", "f"));
// 给hash表中指定字段的整数值加上增量increment
redisTemplate.opsForHash().put("hash", "e", 10);
redisTemplate.opsForHash().increment("hash", "e", 10);
System.out.println(redisTemplate.opsForHash().get("hash", "e"));
// 给hash表中指定字段的浮点值加上increment
// redisTemplate.opsForHash().put("hash", "f", 15.5);
// redisTemplate.opsForHash().increment("hash", "f", 21.1);
// System.out.println(redisTemplate.opsForHash().get("hash", "f"));
// 获取hash表中所有字段
System.out.println(redisTemplate.opsForHash().keys("hash"));
// 获取hash表中字段数量
System.out.println(redisTemplate.opsForHash().size("hash"));
// 获取hash表中存在的所有值
System.out.println(redisTemplate.opsForHash().values("hash"));
// 匹配获取键值对
try {
Cursor<Map.Entry<Object, Object>> cursor = redisTemplate.opsForHash().scan("hash", ScanOptions.NONE);
while (cursor.hasNext()) {
Map.Entry<Object, Object> entry = cursor.next();
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + ": " + value);
}
cursor.close();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* list类型
*/
@RequestMapping(value = "/list")
@ResponseBody
public String listTest(HttpServletRequest request) {
// 向列表中头部添加元素
redisTemplate.opsForList().leftPush("list", "第一个list元素");
// 通过index获取列表中的元素
System.out.println(redisTemplate.opsForList().index("list", 0));
// 把多个值存入列表头部
redisTemplate.opsForList().leftPushAll("list", "第二个list元素", "第三个list元素", "第四个list元素");
// 获取列表指定范围内元素,start起始位置,end结束位置,-1返回所有
System.out.println(redisTemplate.opsForList().range("list", 0, 3));
// list存在的时候再加入
redisTemplate.opsForList().leftPushIfPresent("list", "第六个list元素");
System.out.println(redisTemplate.opsForList().range("list", 0, -1));
// 在pivot值存在时在pivot前面添加
redisTemplate.opsForList().leftPush("list", "第六个list元素", "第五个半list元素");
System.out.println(redisTemplate.opsForList().range("list", 0, -1));
// 按照先进先出的原则添加多个值
redisTemplate.opsForList().rightPush("list", "第七个list元素");
redisTemplate.opsForList().rightPushAll("list", "第八个list元素", "第九个list元素");
System.out.println(redisTemplate.opsForList().range("list", 0, -1));
// 在pivot右边添加值
redisTemplate.opsForList().rightPush("list", "第七个list元素", "第七个半list元素");
System.out.println(redisTemplate.opsForList().range("list", 0, -1));
// 设置指定索引处元素的值
redisTemplate.opsForList().set("list", 5, "修改后的list元素");
// 移除并获取列表中第一个元素
System.out.println(redisTemplate.opsForList().leftPop("list"));
System.out.println(redisTemplate.opsForList().leftPop("list", 10, TimeUnit.SECONDS));
// 移除并获取列表中最后一个元素
System.out.println(redisTemplate.opsForList().rightPop("list"));
System.out.println(redisTemplate.opsForList().rightPop("list", 8, TimeUnit.SECONDS));
// 从一个列表右边弹出一个元素并将该元素插入另一个列表的左边
redisTemplate.opsForList().rightPopAndLeftPush("list", "list2");
redisTemplate.opsForList().rightPopAndLeftPush("list", "list2", 10, TimeUnit.SECONDS);
// 删除列表中值等于指定value的元素,index=0删除所有,index>0删除头部开始第一个,index<0删除尾部开始第一个
redisTemplate.opsForList().remove("list", 0, "第三个list元素");
System.out.println(redisTemplate.opsForList().range("list", 0, -1));
// 列表进行裁剪
redisTemplate.opsForList().trim("list", 1, 4);
System.out.println(redisTemplate.opsForList().range("list", 0, -1));
// 获取当前列表长度
System.out.println(redisTemplate.opsForList().size("list"));
return null;
}
/**
* set类型
*/
@GetMapping(value = "/set")
@ResponseBody
public String setTest(HttpServletRequest request) {
// 添加元素
redisTemplate.opsForSet().add("set", "第一个set元素");
redisTemplate.opsForSet().add("set", "第二个set元素");
redisTemplate.opsForSet().add("set", "第三个set元素");
redisTemplate.opsForSet().add("set", "第四个set元素");
redisTemplate.opsForSet().add("set", "第五个set元素");
// 获取集合中所有元素
System.out.println(redisTemplate.opsForSet().members("set"));
// 移除元素
redisTemplate.opsForSet().remove("set", "第一个set元素", "第三个set元素");
System.out.println(redisTemplate.opsForSet().members("set"));
// 删除并返回一个随机元素
System.out.println(redisTemplate.opsForSet().pop("set"));
// 获取集合大小
System.out.println(redisTemplate.opsForSet().size("set"));
// 判断集合是否包含value
System.out.println(redisTemplate.opsForSet().isMember("set", "第四个set元素"));
redisTemplate.opsForSet().add("otherSet", "第一个set元素");
redisTemplate.opsForSet().add("otherSet", "第二个set元素");
redisTemplate.opsForSet().add("otherSet", "第三个set元素");
redisTemplate.opsForSet().add("otherSet", "第四个set元素");
// 获取两个集合的交集
System.out.println(redisTemplate.opsForSet().intersect("set", "otherSet"));
// 获取多个集合的交集
redisTemplate.opsForSet().add("thirdSet", "第二个set元素");
Set otherKeys = new HashSet();
otherKeys.add("otherSet");
otherKeys.add("thirdSet");
System.out.println(redisTemplate.opsForSet().intersect("set", otherKeys));
// set集合与otherSet集合的交集存储到targetSet集合中
redisTemplate.opsForSet().intersectAndStore("set", "otherSet", "targetSet");
System.out.println(redisTemplate.opsForSet().members("targetSet"));
// set集合与多个集合的交集存储到targetSet集合中
redisTemplate.opsForSet().intersectAndStore("set", otherKeys, "targetSet");
System.out.println(redisTemplate.opsForSet().members("targetSet"));
// 获取两个或者多个集合的并集
System.out.println(redisTemplate.opsForSet().union("set", "otherSet"));
System.out.println(redisTemplate.opsForSet().union("set", otherKeys));
// set集合与多个集合的并集存储到targetSet集合中
redisTemplate.opsForSet().unionAndStore("set", otherKeys, "targetSet2");
System.out.println(redisTemplate.opsForSet().members("targetSets"));
// 获取两个或者多个集合的差集
System.out.println(redisTemplate.opsForSet().difference("set", otherKeys));
// 差集存储到targetSet中
redisTemplate.opsForSet().unionAndStore("set", otherKeys, "targetSet3");
System.out.println(redisTemplate.opsForSet().members("targetSet3"));
// 随机获取集合中的一个元素
System.out.println(redisTemplate.opsForSet().randomMember("set"));
// 随机获取集合中若干个元素
System.out.println(redisTemplate.opsForSet().randomMembers("set", 5));
// 遍历set,类似于iterator
try {
Cursor<Map.Entry<Object, Object>> cursor = redisTemplate.opsForSet().scan("set", ScanOptions.NONE);
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
cursor.close();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* zset类型
*/
@GetMapping(value = "/zset")
@ResponseBody
public String zsetTest(HttpServletRequest request) {
// 添加元素,有序集合按照score的值从小到大排序
redisTemplate.opsForZSet().add("zset", "第一个zset", 100);
redisTemplate.opsForZSet().add("zset", "第二个zset", 110);
redisTemplate.opsForZSet().add("zset", "第三个zset", 120);
redisTemplate.opsForZSet().add("zset", "第四个zset", 130);
redisTemplate.opsForZSet().add("zset", "第五个zset", 140);
// 获取元素在集合中的排名,按照score值从小到大排序
System.out.println("从小到大:" + redisTemplate.opsForZSet().rank("zset", "第二个zset"));
// 获取元素在集合中的排名,按照score值从大到小排序
System.out.println("从大到小:" + redisTemplate.opsForZSet().reverseRank("zset", "第二个zset"));
System.out.println("--------------------------------------");
// 获取集合中给定区间的元素,start开始位置,end结束位置,-1查询所有(从小到大)
// 返回值为:Set<ZSetOperations.TypedTuple<V>>
Iterator iterator = redisTemplate.opsForZSet().rangeWithScores("zset", 0, -1).iterator();
while (iterator.hasNext()) {
ZSetOperations.TypedTuple typedTuple = (ZSetOperations.TypedTuple) iterator.next();
System.out.println("从小到大:" + typedTuple.getValue() + ", " + typedTuple.getScore());
}
System.out.println("--------------------------------------");
// 获取集合中给定区间的元素,start开始位置,end结束位置,-1查询所有(从大到小)
Iterator iterator3 = redisTemplate.opsForZSet().reverseRangeWithScores("zset", 0, -1).iterator();
while (iterator3.hasNext()) {
ZSetOperations.TypedTuple typedTuple3 = (ZSetOperations.TypedTuple) iterator3.next();
System.out.println("从大到小:" + typedTuple3.getValue() + ", " + typedTuple3.getScore());
}
System.out.println("--------------------------------------");
// 按照score值查询集合中的元素,结果从小到大排序
System.out.println("从小到大:" + redisTemplate.opsForZSet().rangeByScore("zset", 100, 200));
Iterator iterator4 = redisTemplate.opsForZSet().rangeByScoreWithScores("zset", 100, 200).iterator();
while (iterator4.hasNext()) {
ZSetOperations.TypedTuple typedTuple4 = (ZSetOperations.TypedTuple) iterator4.next();
System.out.println("从小到大:" + typedTuple4.getValue() + ", " + typedTuple4.getScore());
}
System.out.println("--------------------------------------");
// 按照score值查询集合中的元素,结果从大到小排序
System.out.println("从大到小:" + redisTemplate.opsForZSet().reverseRangeByScore("zset", 100, 200));
Iterator iterator5 = redisTemplate.opsForZSet().reverseRangeByScoreWithScores("zset", 100, 200).iterator();
while (iterator5.hasNext()) {
ZSetOperations.TypedTuple typedTuple5 = (ZSetOperations.TypedTuple) iterator5.next();
System.out.println("从大到小:" + typedTuple5.getValue() + ", " + typedTuple5.getScore());
}
System.out.println("--------------------------------------");
// 从大到小排序获取集合中score在给定最大最小范围内的元素
System.out.println("从大到小:" + redisTemplate.opsForZSet().reverseRangeByScore("zset", 100, 1000, 0, -1));
System.out.println("--------------------------------------");
// 根据score获取集合元素数量
System.out.println(redisTemplate.opsForZSet().count("zset", 100, 150));
System.out.println("--------------------------------------");
// 获取集合大小
System.out.println(redisTemplate.opsForZSet().size("zset"));
System.out.println(redisTemplate.opsForZSet().zCard("zset"));
System.out.println("--------------------------------------");
// 获取集合中key value 对应的score
System.out.println(redisTemplate.opsForZSet().score("zset", "第三个zset"));
System.out.println("--------------------------------------");
// 移除指定索引位置的元素
redisTemplate.opsForZSet().removeRange("zset", 0, 1);
System.out.println(redisTemplate.opsForZSet().range("zset", 0, -1));
System.out.println("--------------------------------------");
// 获取key 和otherKey的交集并存储在targetKey
redisTemplate.opsForZSet().add("otherZset", "第二个zset", 200);
redisTemplate.opsForZSet().add("otherZset", "第三个zset", 200);
redisTemplate.opsForZSet().intersectAndStore("zset", "otherZset", "targetZset");
System.out.println(redisTemplate.opsForZSet().range("targetZset", 0, -1));
System.out.println("--------------------------------------");
// 获取key和otherKey的并集并且存储在targetKey中
redisTemplate.opsForZSet().unionAndStore("zset", "otherZset", "fourthZset");
System.out.println(redisTemplate.opsForZSet().range("fourthZset", 0, -1));
System.out.println("--------------------------------------");
// 遍历集合
try {
Cursor<ZSetOperations.TypedTuple> cursor = redisTemplate.opsForZSet().scan("zset", ScanOptions.NONE);
while (cursor.hasNext()) {
ZSetOperations.TypedTuple typedTuple = cursor.next();
System.out.println(typedTuple.getValue() + ", " + typedTuple.getScore());
}
cursor.close();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
redisTemplate常用API:
最新推荐文章于 2024-05-21 08:48:37 发布