SpringBoot 第十六篇 之 Redis 基本数据类型操作

package com.chenyun.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisZSetCommands;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import redis.clients.jedis.Jedis;

import java.util.*;

@Controller
@ResponseBody
public class HelloRedisController {

    @RequestMapping("/test")
    public Map<String,Object> helloRedis(){

        Map<String,Object> map = new HashMap<>();
        map.put("success",true);
        map.put("asadfa","aad");

        return map;

    }


    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/stringAndHash")
    public Map<String,Object> testStringAndHash(){

        redisTemplate.opsForValue().set("key1","value1");

        //注意这里使用了JDK序列化器，所以redis保存时不是整数，不能运算
        redisTemplate.opsForValue().set("int_key","1");

        // 使用运算
        stringRedisTemplate.opsForValue().set("int","1");

        // 获取底层jedis链接
        Jedis jedis = (Jedis)stringRedisTemplate.getConnectionFactory().getConnection()
                .getNativeConnection();
        // 这个命令redisTemplate 不支持，所i我们先获取底层链接再操作
        jedis.decr("int");

        Map<String,String> hash = new HashMap<String, String>();
        hash.put("field1","value1");
        hash.put("field2"," value2");
        //  存入一个散列数类型
        stringRedisTemplate.opsForHash().putAll("hash",hash);

        //新增一个字段
        stringRedisTemplate.opsForHash().put("hash","field3","value3");
        // 绑定散列字段的key，这样可以链接对同一个散列数据类型进行操作
        BoundHashOperations hashOps = stringRedisTemplate.boundHashOps("hash");
        // 删除两个字段
        hashOps.delete("field1","field2");
        //新增一个字段
        hashOps.put("field4","value4");

        Map<String, Object> map = new HashMap<String, Object>();
        map.put("success",true);
        return map;



    }

    /**
     * 使用spring 操作链表（list）
     * 特性是：查询性能不高，增加删除节点性能高
     * */
    @RequestMapping("/list")
    public Map<String,Object> testList(){

        // 插入两个列表，注意他们在链表的顺序
        // 链表从左到右的顺序为v10,v8,v4,v2
        stringRedisTemplate.opsForList().leftPushAll("list1","v2","v4","v8","v10");
        // 链表从左到右的顺序为 v1,v2,v3,v5
        stringRedisTemplate.opsForList().rightPushAll("list2","v1","v2","v3","v5");

        // 绑定链表2操作
        BoundListOperations listops = stringRedisTemplate.boundListOps("list2");
        // 从右边弹出一个成员
        Object result1 = listops.rightPop();

        // 获取定位元素，Redis从0 开始，这里值为v2
        Object result2 = listops.index(1);

        // 从左边插入链表
        listops.leftPush("v0");

        // 求链表长度
        Long size = listops.size();

        // 求链表下标区间成员，整个链表下标范围0 到 size-1 ，这里不取最后一个元素
        List elements = listops.range(0, size-2);

        Map<String, Object> map = new HashMap<String, Object>();
        map.put("success",true);
        map.put("elements",elements);
        map.put("result1",result1);
        map.put("result2",result2);

        return map;
    }

    /**
     * 操作集合set
     * 特性，集合不允许重复，无顺序
     * */
    @RequestMapping("/set")
    public Map<String, Object> testSet() {
        stringRedisTemplate.opsForSet().add("set1","v1","v2","v3","v4");
        // 绑定集合操作
        BoundSetOperations setOps = stringRedisTemplate.boundSetOps("set1");
        // 增加元素
        setOps.add("v6", "v7");
        // 删除元素
        setOps.remove("v1");
        // 返回所有元素
        Set set1 = setOps.members();
        // 返回所有元素
        Long size = setOps.size();

        Map<String, Object>  map = new HashMap<>();
        map.put("set1",set1);
        return map;

    }

    /**
     * redis 提供有序集合zset，有序集合和集合差异不大，也是一种散列
     * 存储的方式，同时它的有序性只是靠它在树结构中增加一个属性-score分数
     * 为了支持这个变化，spring 提供了TypedTuple接口， 并定义了两个方法，
     * spring 还提供默认实现类，DefaultTypedTuple
     * */
    @RequestMapping("/zset")
    public void testZset(){
        Set<ZSetOperations.TypedTuple<String>> typedTuples = new HashSet<>();
        for (int i=1;i<=9;i++){
            // 分数
            double score = i*0.1;
            // 创建一个TypedTuple对象，存入值和分数
            ZSetOperations.TypedTuple<String> typedTuple = new DefaultTypedTuple<String>("value"+i,score);
            typedTuples.add(typedTuple);
        }

        //在集合中插入元素
        stringRedisTemplate.opsForZSet().add("zset1",typedTuples);

        // 绑定集合操作
        BoundZSetOperations<String,String> zSetOperations = stringRedisTemplate.boundZSetOps("zset1");

        // 增加一个元素
        zSetOperations.add("value10",0.26);
        Set<String> setScore = zSetOperations.range(1,6);
        // 按分数获取有序集合
        Set<String> setLex = zSetOperations.rangeByScore(0.2,0.6);
        //  定义值的范围
        RedisZSetCommands.Range range = new RedisZSetCommands.Range();
        // 大于value3
        range.gt("value3");
        // 大于等于value3
        range.gte("value3");

        // 删除元素
        zSetOperations.remove("value9");
        // 按分值从大到小排序
        Set<String> reverseSet =zSetOperations.reverseRange(2,8);

    }





}