RedisTemplate

• is Spring Data提供的用于操作redis数据库的模板对象！！！
  String
Hash:即java中的Map
Set:java中的set无重复元素
List：有下标，可重复
ZSet：有分数可据此排序
  实操redisTemplate。结合redis的RMD图形化管理工具来实践

1. 创建SpringBoot项目
2. 引入SpringDataRedis依赖

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>

3. 注入RedisTemplate进行测试。
   注意：实验中使用了StringRedisTemplate。原因是要使用图形化工具查看数据情况。

@SpringBootTest
class RedisTemplateItemApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 通用方法测试*/
    @Test
    void generalOperation() {
        //操作方式
        //1.
        redisTemplate.boundValueOps("name").set("yh");
        redisTemplate.expire("name",1, TimeUnit.MINUTES);
        //2.
        BoundValueOperations address = redisTemplate.boundValueOps("address");
        address.set("bj");
        address.expire(1, TimeUnit.MINUTES);
        //3.
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("class","高一七班",1,TimeUnit.MINUTES);

        //4. 使用stringRedisTemplate操作数据和redisTemplate的区别是该方式存储序列化的数据是可读的。两者的序列化方式不同。
        stringRedisTemplate.boundValueOps("name").set("yh");
        stringRedisTemplate.expire("name",1, TimeUnit.MINUTES);

        //通用操作
        //1.根据key删除值
        Boolean name = stringRedisTemplate.delete("name");
        System.out.println(name);
        //2.根据key集合删除多个值
        Long delete = stringRedisTemplate.delete(Arrays.asList("name", "zSet", "list"));
        System.out.println("删除的个数为"+delete);
        //3.根据key名称设置key的过期时间
        stringRedisTemplate.expire("name",1,TimeUnit.MINUTES);
        //4.根据key名称获取过期时间
        Long time = stringRedisTemplate.getExpire("name");
        System.out.println("该key的过期时间为"+time);
        //5.根据key判断redis是否有值
        Boolean hasKey = stringRedisTemplate.hasKey("name");
        System.out.println(hasKey);
    }

    /**
     * String类型操作*/
    @Test
    void StringType() {
        //1.String类型操作
        ValueOperations<String, String> strings = stringRedisTemplate.opsForValue();
        strings.set("address","bj+hrb+lz");
        strings.set("address","bj",1,TimeUnit.MINUTES);
        strings.get("address");
        String address = strings.get("address", 0, 3);//>=0,<3
        System.out.println(address);
        //String类型的特殊操作。key对应的value值每次递增。
        stringRedisTemplate.boundValueOps("increase").increment(3L);
        //递减
        stringRedisTemplate.boundValueOps("increase").increment(-3L);

    }
/**
 * Hash类型操作*/
    @Test
    void HashType() {
    //2.Hash类型操作
        HashOperations<String, Object, Object> hash =
                stringRedisTemplate.opsForHash();
        hash.put("mapName","name","zq");
        hash.put("mapName","age","16");
        hash.put("mapName","address","bj");
        hash.put("mapName","class","g-1");
        //设置过期时间
        stringRedisTemplate.expire("mapName",1,TimeUnit.MINUTES);
        //添加map集合
        HashMap<String, String> map = new HashMap<>();
        map.put("name","yk");
        map.put("age","10");
        map.put("address","bj");
        map.put("class","s-1");
        hash.putAll("yhMap",map);
        //获取map所有key
        Set<Object> keys = hash.keys("yhMap");
        System.out.println(keys);
        //获取所有value
        List<Object> yhMap = hash.values("yhMap");
        System.out.println(yhMap);
        //根据key获取value
        Object o = hash.get("yhMap", "name");
        System.out.println(o);
        //获取所有键值对集合
        Map<Object, Object> entries = hash.entries("yhMap");
        System.out.println(entries);
        //根据key删除某个value
        Long delete = hash.delete("yhMap", "class");
        System.out.println(delete);
        //根据key删除整个map
        //stringRedisTemplate.delete("yhMap");
        //System.out.println(redisTemplate.boundValueOps("name").get());
        //判断map中是否有key对应的值
        Boolean aBoolean = hash.hasKey("yhMap", "name");
        System.out.println(aBoolean);
        Boolean aBoolean1 = hash.hasKey("yhMap", "class");
        System.out.println(aBoolean1);
        Long mapSize = hash.size("yhMap");
        System.out.println(mapSize);
    }

    /**
     * Set类型操作
     *  自动去重*/
    @Test
    void SetType(){
        //3.Set类型操作。无下标
        SetOperations<String, String> SET = stringRedisTemplate.opsForSet();
        Long add = SET.add("setName", "ZQ", "YK", "ZY","ZQ");
        System.out.println(add);
        //获取所有值
        Set<String> setName = SET.members("setName");
        System.out.println(setName);
        //根据value判断set中有无
        Boolean member = SET.isMember("setName", "YK");
        System.out.println(member);
        //移除指定元素
        Long remove = SET.remove("setName", "ZQ");
        System.out.println(remove);
        Long setSize = SET.size("setName");
        System.out.println(setSize);

    }

    /**
     * list类型操作*/
    @Test
    void ListType(){
        //4.List相关操作。有索引0开始、可重复
        ListOperations<String, String> list = stringRedisTemplate.opsForList();
//        list.leftPush("names","a");
//        list.leftPush("names","b");
//        list.rightPush("names","c");
//        list.rightPush("names","d");
        //获取list的全部内容
        List<String> lists = list.range("names",0, -1);
        System.out.println(lists);
        //根据索引查询元素
        String names = list.index("names", 1);
        System.out.println(names);
        //根据索引修改值
        //list.set("names",1,"111");
        //从左或者右弹出一个元素.删除了
        String names1 = list.leftPop("names");
        String names2 = list.rightPop("names");
        System.out.println(names1);
        System.out.println(names2);
        //移除N个值为value的值
//        Long remove1 = list.remove("names", 1, "b");
//        System.out.println(remove1);
        Long listSize = list.size("names");
        System.out.println(listSize);
    }
    /**
     *ZSet类型操作 */
    @Test
    void ZSetType(){
        //5.ZSet操作。有序即可。根据score的值进行排序
        ZSetOperations<String, String> zSet = stringRedisTemplate.opsForZSet();
        zSet.add("zSet","grade0",10d);
        //添加多个元素并设置分数
        DefaultTypedTuple<String> x1=new DefaultTypedTuple<>("grade1",100d);
        DefaultTypedTuple<String> x2=new DefaultTypedTuple<>("grade2",50d);
        DefaultTypedTuple<String> x3=new DefaultTypedTuple<>("grade3",70d);
        Set<ZSetOperations.TypedTuple<String>> many=new HashSet<>();
        many.add(x1);
        many.add(x2);
        many.add(x3);
        // List<DefaultTypedTuple<String>> defaultTypedTuples = Arrays.asList(x1, x2, x3);
        zSet.add("zSet",many);
        //获取所有元素。按分数从低到高排列
        Set<String> range = zSet.range("zSet",0, -1);
        System.out.println(range);
        //获取指定元素的分数
        Double score = zSet.score("zSet", "grade2");
        System.out.println(score);
        //获取分数范围内的元素个数
        Long zSet2 = zSet.count("zSet", 50d, 100d);
        System.out.println(zSet2);
        //获取分数范围内的元素.该范围是闭合的范围即包括等于
        Set<String> zSet1 = zSet.rangeByScore("zSet", 50d, 100d);
        System.out.println(zSet1);
        //key值、起始分数、结束分数、偏移量(即从符合分数范围的里边移动几个)、从偏移量处取几个
        Set<String> zSet3 = zSet.rangeByScore("zSet", 15d, 100d, 3, 1);
        System.out.println(zSet3);
        //返回集合范围内元素的排名，以及分数（从小到大）
        Set<ZSetOperations.TypedTuple<String>> zSet4 = zSet.rangeWithScores("zSet", 0, -1);
        for (ZSetOperations.TypedTuple<String> t : zSet4) {
            System.out.println(t.getValue()+"::"+t.getScore());
        }
        Long zSetSize = zSet.size("zSet");
        System.out.println(zSetSize);
    }
}