Java使用RedisTemplate操作Redis常用API

谁借莪１个温暖的怀抱￠ 2023-01-15 03:56 99阅读 0赞

redisTemplate常用api：

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;
        }
    
    }