Redis 的存储结构，以及这些结构的常用方法

1.String ，字符串，是 redis 的最基本的类型，一个 key 对应一个 value。是二进

制安全的，最大能存储 512MB

  @Test
    void TestString(){

        User user = userMapper.selectById(3L);

        String key = "user_3";

        //把查询到的对象通过jsonutil工具类转换成一个json字符串再存入redis的string类型中
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(user));

        //通过get方法获得user
        String s = stringRedisTemplate.opsForValue().get(key);

        //打印取到的json字符串
        System.out.println(s); //{"version":3,"deleted":0,"name":"Tom","id":3,"age":13}

        //转换成user对象
        User user1 = JSONUtil.toBean(s, User.class);

        //打印对象
        System.out.println(user1);  //User(id=3, name=Tom, age=13, email=null, pwd=null, deleted=0, version=3)


    }

2.Hash， 散列，是一个键值(key=>value)对集合。string 类型的 field 和 value 的

映射表，特别适合用于存储对象。每个 hash 可以存储 232 -1 键值对（

40 多亿）

 @Test
    void TestHash(){

        // HSET haxi v c 设置哈希对象中给定字段的值。
        //相当于一个map集合，haxi为最外层的key，v为里层的key,c为value
        stringRedisTemplate.opsForHash().put("haxi","v","c");

       // HGET haxi v  获取哈希对象中给定字段的值。
        System.out.println(stringRedisTemplate.opsForHash().get("haxi", "v")); //c


        //HMSET：putAll(H key, Map<? extends HK, ? extends HV> m)，同时设置哈希对象的多个字段值。
        Map map = new HashMap();
        map.put("q","q");
        map.put("zzx","123");
        map.put("asd","455");
        stringRedisTemplate.opsForHash().putAll("haxi",map); 

        //HMGET：multiGet(H key, Collection<HK> hashKeys)，获取哈希对象中多个字段的值。
        List list = new ArrayList();
        list.add("q");
        list.add("zzx");
        list.add("asd");
        List list1 = stringRedisTemplate.opsForHash().multiGet("haxi", list); 
        System.out.println(list1);   //[q, 123, 455]

        //HGETALL：entries(H key)，获取哈希对象中的所有字段和值。
        Map<Object, Object> haxi = stringRedisTemplate.opsForHash().entries("haxi");
        System.out.println(haxi);  //{a=a, v=c, q=q, asd=455, zzx=123}

      //HEXISTS：hasKey(H key, Object hashKey)，判断哈希对象是否存在给定字段。
        Boolean aBoolean = stringRedisTemplate.opsForHash().hasKey("haxi", "zzx");
        System.out.println(aBoolean);  //true

    }

3.List，列表，是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列

边或者尾部（右边）。最多可存储 232 - 1 元素(4294967295, 每个列表可存储 40 亿)

    @Test
    void TestList(){

        // LPUSH aa aa
        //相当于一个双向队列，lpush从左边放入元素
        stringRedisTemplate.opsForList().leftPush("aa","aa");

        // RPOP aa
        //从右边取出元素，取出的第一个是从左边放入的第一个元素
        System.out.println(stringRedisTemplate.opsForList().rightPop("aa"));   //aa
    }

4.Set，集合，是 string 类型的无序集合，最大的成员数为 232 -1(4294967295, 每

个集合可存储 40 多亿个成员)。

 @Test
    void TestSet(){

        //SADD A A B C D  向set集合中存入A B C D ，key为A,set集合是一个无序不重复的集合
        stringRedisTemplate.opsForSet().add("A","A","B","C","D");


        // SREM A B   移除key为A的set集合中的B值,移除成功返回1，否则返回0
        Long remove = stringRedisTemplate.opsForSet().remove("A","B");

        System.out.println(remove); //1

        // SMEMBERS A  获取key为A的set集合中的所有值
        Set<String> a = stringRedisTemplate.opsForSet().members("A");

        System.out.println(a); //[C, A, D]

        // SISMEMBER A C  判断key为A的set集合中，有没有C值,有则返回true
        Boolean member = stringRedisTemplate.opsForSet().isMember("A", "C");
        System.out.println(member); //true
    }

5.Sorted set ，有序集合，和 set 一样也是 string 类型元素的集合,且不允许重复的

成员。不同的是每个元素都会关联一个 double 类型的分数。redis 正是通过分数来为集

合中的成员进行从小到大的排序。zset 的成员是唯一的,但分数(score)却可以重复。

 @Test
    void TestSortedset(){


        //ZADD：add(ZSetTypedTuple<K> key, Set<ZSetOperations.TypedTuple<V>> tuples)，
        // 将一个或多个有序集合成员及其分值添加到有序集合中
        stringRedisTemplate.opsForZSet().add("zset","A",1);
        stringRedisTemplate.opsForZSet().add("zset","B",2);
        stringRedisTemplate.opsForZSet().add("zset","C",3);

        //ZSCORE：score(K key, Object o)，获取有序集合中指定成员的分值。
        System.out.println(stringRedisTemplate.opsForZSet().score("zset", "A")); //1.0

        //ZRANGE：range(K key, long start, long end)，按照索引范围获取有序集合中的成员。
        System.out.println(stringRedisTemplate.opsForZSet().range("zset", 0L, 2L)); //[A, B, C]

        //ZREVRANGE：reverseRange(K key, long start, long end)，按照索引范围倒序获取有序集合中的成员。
        System.out.println(stringRedisTemplate.opsForZSet().reverseRange("zset", 0L, 2L)); //[C, B, A]

        //ZRANK：rank(K key, Object o)，获取有序集合中指定成员的排名（按照分值排序）。
        System.out.println(stringRedisTemplate.opsForZSet().rank("zset", "A")); //0

        //ZREVRANK：reverseRank(K key, Object o)，获取有序集合中指定成员的排名（按照分值倒序排序）。
        System.out.println(stringRedisTemplate.opsForZSet().reverseRank("zset", "A")); //2

        //ZCARD：size(K key)，获取有序集合的成员数量。
        System.out.println(stringRedisTemplate.opsForZSet().size("zset"));  //3

        //ZCOUNT：count(K key, double min, double max)，获取有序集合分值在指定范围内的成员数量。
        System.out.println(stringRedisTemplate.opsForZSet().count("zset", 1, 2)); //2

        //ZRANGEBYSCORE：rangeByScore(K key, double min, double max)，按照分值范围获取有序集合中的成员。
        System.out.println(stringRedisTemplate.opsForZSet().rangeByScore("zset", 1, 2)); //[A, B]



    }