RedisTemplate使用

String類型

    @Override
    public void testString() {
        // t11();
        String key = "k1";
        String currentNum;
        // 用法1：key是否存在
        Boolean value = client.hasKey(key);
        log.info("[{}]是否存在[{}]", key, value);
        // 用法2：添加元素
        client.opsForValue().set(key, "v1", DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        // 用法3：獲取元素
        String getValue = client.opsForValue().get(key);
        log.info("getValue : [{}]", getValue);
        // 用法4：計數
        String counter = "counter:key";
        client.opsForValue().set(counter, "0", DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        client.opsForValue().increment(counter);
        client.opsForValue().increment(counter);
        currentNum = client.opsForValue().get(counter);
        log.info("currentNum : [{}]", currentNum);
        client.opsForValue().decrement(counter);
        currentNum = client.opsForValue().get(counter);
        log.info("currentNum : [{}]", currentNum);

        // 用法5：存儲list<map>結構數據
        List<Map<String, String>> multiMapList = Lists.newArrayList();
        for (int i = 0; i < 5; i++) {
            LinkedHashMap<String, String> itemMap = Maps.newLinkedHashMap();
            itemMap.put("name", "jack" + i);
            if (i % 2 == 0) {
                itemMap.put("age", String.valueOf(10 + i));
                itemMap.put("sex", "男");
            } else {
                itemMap.put("age", String.valueOf(11 + i));
                itemMap.put("sex", "女");
            }
            multiMapList.add(itemMap);
        }
        String multiMapStr = JSON.toJSONString(multiMapList);
        client.opsForValue().set("str:multiusers", multiMapStr, DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        String userList = client.opsForValue().get("str:multiusers");
        List<Map<String, String>> maps = CastBeanUtil.castListMap(JSON.parse(userList), String.class, String.class);
        log.info("maps : [{}]", maps);

        // 用法6：存儲list<entity>
        List<TzArea> areaList = Lists.newArrayList();
        for (int i = 0; i < 10; i++) {
            TzArea item = new TzArea();
            item.setAreaId((long) i);
            item.setAreaName("江蘇省");
            item.setLevel(1);
            item.setParentId(1L);
            areaList.add(item);
        }

        client.opsForValue().set("str:multiareas", JSON.toJSONString(areaList), DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        String res = client.opsForValue().get("str:multiareas");
        List<TzArea> tzAreas = JSON.parseArray(res, TzArea.class);
        log.info("tzAreas : [{}]", JSON.toJSONString(tzAreas));


    }

Hash類型

@Override
    public void testHash() {
        // 用法1：添加一個字段
        client.opsForHash().put("hash:user:single", "name", "pmb");
        client.expire("user", DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        Map<Object, Object> result = client.opsForHash().entries("hash:user:single");
        log.info("result : [{}]", result);
        // 用法2：添加一個對象信息
        Map<Object, Object> handleMap = Maps.newLinkedHashMap();
        handleMap.put("name", "jack");
        handleMap.put("age", "18");
        handleMap.put("sex", "男");
        String key = "hash:user:all";
        client.opsForHash().putAll(key, handleMap);
        Map<Object, Object> allElements = client.opsForHash().entries(key);
        log.info("allElements : [{}]", allElements);
        // 用法3：只獲取map中key集合
        Set<Object> keyList = client.opsForHash().keys(key);
        log.info("keyList : [{}]", keyList);
        // 用法4：只獲取map中value集合
        List<Object> valueList = client.opsForHash().values(key);
        log.info("valueList : [{}]", valueList);
    }

List類型

    @Override
    public void testList() {
        // 用法1：順序添 加元素1,2,3,4
        // rightPush 列表右側添加元素
        String key = "list:phoneList";
        client.opsForList().rightPush(key, "16607024161");
        client.opsForList().rightPush(key, "16607024162");
        client.opsForList().rightPush(key, "16607024163");
        client.expire(key, DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        // 刪除元素
        client.opsForList().rightPop(key);
        // 元素個數
        Long size = client.opsForList().size(key);
        assert size !=null;
        log.info(SIZE_FORMAT, size);
        // 查找元素
        // index 查找指定下標的元素 下標從0開始，最后一個size-1
        String firstItem = client.opsForList().index(key, 0);
        log.info("firstItem : [{}]", firstItem);
        String secondItem = client.opsForList().index(key, 1);
        log.info("secondItem : [{}]", secondItem);
        String thirdItem = client.opsForList().index(key, 2);
        log.info("thirdItem : [{}]", thirdItem);
        // list中所有元素
        List<String> res = client.opsForList().range(key, 0, size - 1);
        log.info("res : [{}]", res);
        // 修改制定位置數據
        client.opsForList().set(key, 0, "12");
        // 實現棧 先進后出
        client.opsForList().leftPush(key, "1");
        client.opsForList().leftPush(key, "2");
        client.opsForList().leftPush(key, "3");
        client.opsForList().leftPop(key);
        client.opsForList().leftPop(key);
        client.opsForList().leftPop(key);
       
        // 實現隊列 先進先出
        client.opsForList().leftPush(key, "one");
        client.opsForList().leftPush(key, "two");
        client.opsForList().rightPop(key);
        client.opsForList().rightPop(key);
    }

Set類型

   @Override
    public void testSet() {
        String key = "set:nums";
        // 用法1：添加元素
        client.opsForSet().add(key, "1", "2", "3");
        client.expire(key, DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        //用法2：獲取集合的元素
        Set<String> members = client.opsForSet().members(key);
        log.info("members : [{}]", members);
        // 用法3：判斷某個元素是否存在
        Boolean member = client.opsForSet().isMember(key, "2");
        log.info("member : [{}]", member);
        String intersection = "set:nums:intersection";
        // 用法4：交集
        client.opsForSet().add(intersection, "1", "2");
        client.expire(intersection, DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        Set<String> intersectList = client.opsForSet().intersect(key, intersection);
        log.info("intersectList : [{}]", intersectList);
        // 用法5：并集
        Set<String> unionList = client.opsForSet().union(key, intersection);
        log.info("unionList : [{}]", unionList);
        // 用法6：查集
        Set<String> differenceList = client.opsForSet().difference(key, intersection);
        log.info("differenceList : [{}]", differenceList);


    }

Zset類型

  @Override
    public void testZset() {
        String key = "zset:nums";
        // 用法1：添加元素
        client.opsForZSet().add(key, "one", 1);
        client.opsForZSet().add(key, "three", 30);
        client.opsForZSet().add(key, "two", 20);
        client.opsForZSet().add(key, "four", 44);
        client.opsForZSet().add(key, "five", 55);
        client.expire(key, DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        // 用法2：返回指定元素排名
        Long one = client.opsForZSet().rank(key, "five");
        log.info("rank : [{}]", one);
        Long size = client.opsForZSet().size(key);
        assert size !=null;
        log.info(SIZE_FORMAT, size);
        // 用法3：返回指定區間元素
        Set<String> range = client.opsForZSet().range(key, 0, size - 1);
        log.info("range : [{}]", range);
        // 用法4：指定分數區間用戶
        Set<String> userList = client.opsForZSet().rangeByScore(key, 1, 60);
        log.info("userList : [{}]", userList);
        // 用法5：移除一個或者多個元素
        client.opsForZSet().remove(key, "two");
        log.info(SIZE_FORMAT, client.opsForZSet().size(key));
        // 用法6：計算指定分數之間用戶個數
        Long count = client.opsForZSet().count(key, 1, 20);
        log.info("count : [{}]", count);
        Set<String> invertedOrder = client.opsForZSet().reverseRange(key, 0, -1);
        log.info("InvertedOrder : [{}]", invertedOrder);
        // 用法7：顯示所有成員score以及對應用戶
        Set<ZSetOperations.TypedTuple<String>> allLis = client.opsForZSet().rangeWithScores(key, 0, -1);
        assert allLis != null;
        for (ZSetOperations.TypedTuple<String> next : allLis) {
            String value = next.getValue();
            Double score = next.getScore();
            log.info("通過rangeWithScores(K key, long start, long end)方法獲取RedisZSetCommands.Tuples的區間值:[{}]，[{}]", value, score);
        }

        // 用法8：相同score返回處理,取值第一個
        String lexKey = "zset:lex";
        client.delete(lexKey);
        client.opsForZSet().add(lexKey, "zs", 55);
        client.opsForZSet().add(lexKey, "ls", 55);
        client.opsForZSet().add(lexKey, "ww", 54);
        client.opsForZSet().add(lexKey, "zl", 55);
        client.expire(lexKey, DateConstant.TIME_OF_DAY, TimeUnit.SECONDS);
        // 取出score集合
        Set<ZSetOperations.TypedTuple<String>> typedTuples = client.opsForZSet().rangeWithScores(lexKey, 0, -1);
        if(Objects.isNull(typedTuples)){
            throw new IllegalArgumentException("出現異常了");
        }
        Map<String, Double> cachedMap = new ConcurrentHashMap<>(16);
        Iterator<ZSetOperations.TypedTuple<String>> scoreIterator = typedTuples.iterator();
        String firstUser = null;
        while (scoreIterator.hasNext()) {
            ZSetOperations.TypedTuple<String> item = scoreIterator.next();
            Double score = item.getScore();
            String value = item.getValue();
            if (cachedMap.containsValue(score)) {
                // 找到重復score
                firstUser = value;
            }
            cachedMap.put(value, score);
        }
        log.info("firstUser : [{}]", firstUser);

       
    }