spring data redis 操作redis五种数据类型 实例

 

导入依赖

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

application.yml

spring:
  # redis配置
  redis:
    # 服务器地址
    host: 127.0.0.1
    # 端口
    port: 6379
    password:
    # 数据库
    database: 1
    # 超时时间
    timeout: 10000ms
    lettuce:
      pool:
        # 最大连接数, 默认8
        max-active: 8
        # 最大连接阻塞等待时间, 默认-1
        max-wait: 10000ms
        # 最大空闲连接, 默认8
        max-idle: 200
        # 最小空闲连接, 默认0
        min-idle: 5
logging:
  level:
    com.xxx.seckill.mapper: debug

 

 

1、操作 string (常用)

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作 string
     *
     * @return
     */
    @RequestMapping("/string")
    @ResponseBody
    public void string(){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        // 插入一条数据
        valueOperations.set("userName","zhangsan");
        // 获取一条数据
        System.out.println(valueOperations.get("userName"));
        // 插入多条数据
        Map<String, Object> map = new HashMap<>();
        map.put("age","18");
        map.put("sex","1");
        valueOperations.multiSet(map);
        //获取多条数据
        List list = valueOperations.multiGet(Arrays.asList("userName", "age", "sex"));
        for (Object obj : list) {
            System.out.println(obj);
        }
        // 删除
        redisTemplate.delete("userName");
    }
}

 

 

2、操作 hash (常用)

    /**
     * 操作 hash
     *
     * @return
     */
    @RequestMapping("/hash")
    @ResponseBody
    public void hash(){
        HashOperations hashOperations = redisTemplate.opsForHash();
        /**
         * 添加一条数据
         *      参数1: redis的key
         *      参数2: hash 的key
         *      参数3: hash 的value
         */
        hashOperations.put("userInfo","name","lisi");
        // 获取一条数据
        String name = String.valueOf(hashOperations.get("userInfo", "name"));
        System.out.println(name);

        // 插入多条数据
        Map<String, String> map = new HashMap<>();
        map.put("age","20");
        map.put("sex","0");
        hashOperations.putAll("userInfo",map);

        // 获取多条数据
        List list = hashOperations.multiGet("userInfo", Arrays.asList("name", "age", "sex"));
        for (Object obj : list) {
            System.out.println(String.valueOf(obj));
        }
        // 删除 用于删除hash类型数据
        hashOperations.delete("userInfo","sex");
    }

 

values(H key)
	// 获取指定变量中的hashMap值。
	List<Object> hashList = redisTemplate.opsForHash().values("hashValue");  
	
entries(H key)
	// 获取变量中的键值对。
	Map<Object,Object> map = redisTemplate.opsForHash().entries("hashValue");  
	
get(H key, Object hashKey)
	// 获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null。
	Object mapValue = redisTemplate.opsForHash().get("hashValue","map1");  
	
hasKey(H key, Object hashKey)
	// 判断变量中是否有指定的map键。
	boolean hashKeyBoolean = redisTemplate.opsForHash().hasKey("hashValue","map3");  
	
keys(H key)
	// 获取变量中的键。
	Set<Object> keySet = redisTemplate.opsForHash().keys("hashValue");  
	  
	
increment(H key, HK hashKey, double delta) 
	// 使变量中的键以double值的大小进行自增长。
	double hashIncDouble = redisTemplate.opsForHash().increment("hashInc","map1",3);   
	
increment(H key, HK hashKey, long delta)
	// 使变量中的键以long值的大小进行自增长。
	long hashIncLong = redisTemplate.opsForHash().increment("hashInc","map2",6);  
	
	
putIfAbsent(H key, HK hashKey, HV value)
	// 如果变量值存在，在变量中可以添加不存在的的键值对，如果变量不存在，则新增一个变量，同时将键值对添加到该变量。
	redisTemplate.opsForHash().putIfAbsent("hashValue","map6","map6-6");  
	map = redisTemplate.opsForHash().entries("hashValue");  
	 
scan(H key, ScanOptions options)
	// 匹配获取键位map1的键值对,不能模糊匹配。
	Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("hashValue",ScanOptions.scanOptions().match("map1").build());  
	// ScanOptions.NONE为获取全部键对
	Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("hashValue",ScanOptions.NONE);  
	while (cursor.hasNext()){  
	    Map.Entry<Object,Object> entry = cursor.next();  
	} 

 

3、操作 list

    /**
     * 操作 list
     *
     * @return
     */
    @RequestMapping("/list")
    @ResponseBody
    public void list(){
        ListOperations listOperations = redisTemplate.opsForList();
        // 左添加一条
        listOperations.leftPush("student","zhangsan");
        // 左添加多条
        listOperations.leftPushAll("student","list","wangwu","zhaoliu");

        // 右添加一条
        listOperations.rightPush("student","xiaoming");
        // 右添加多条
        listOperations.rightPushAll("student","xiaohong","xiaohei");

        // 获取多条
        List list = listOperations.range("student", 0, 6);
        for (Object obj : list) {
            System.out.println(obj);
        }
        // 删除 从左边开始删
        listOperations.leftPop("student");
        // 删除 从右边开始删
        listOperations.rightPop("student");

        // 获取条数
        Long size = listOperations.size("student");
        System.out.println("size: "+size);
    }

 

 

 

4、操作 set

    /**
     * 操作无序 set
     *
     * @return
     */
    @RequestMapping("/set")
    @ResponseBody
    public void set(){
        SetOperations setOperations = redisTemplate.opsForSet();
        // 添加数据
        String[] letters = new String[]{"aaa", "bbb", "ccc", "ddd", "eee"};
        setOperations.add("letters",letters);

        // 获取数据
        Set let = setOperations.members("letters");
        for (Object letter : let) {
            System.out.println(letter);
        }

        // 删除
        setOperations.remove("letters","aaa","bbb");

        Long size = setOperations.size("letters");
        System.out.println("size: "+size);
    }

 

 

5、操作 sorted set

    /**
     * 操作有序 sorted set
     *
     * @return
     */
    @RequestMapping("/sortedSet")
    @ResponseBody
    public void sortedSet(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        // 插入单条
        zSetOperations.add("score","zhangsan",99D);
        // 插入多条
        Set<ZSetOperations.TypedTuple<Object>> set = new HashSet<>();
        DefaultTypedTuple<Object> objectDefaultTypedTuple1 =
                new DefaultTypedTuple<>("lisi", 92D);
        DefaultTypedTuple<Object> objectDefaultTypedTuple2 =
                new DefaultTypedTuple<>("wangwu", 92D);
        DefaultTypedTuple<Object> objectDefaultTypedTuple3 =
                new DefaultTypedTuple<>("zhaoliu", 100D);
        DefaultTypedTuple<Object> objectDefaultTypedTuple4 =
                new DefaultTypedTuple<>("tianqi", 95D);
        set.add(objectDefaultTypedTuple1);
        set.add(objectDefaultTypedTuple2);
        set.add(objectDefaultTypedTuple3);
        set.add(objectDefaultTypedTuple4);
        zSetOperations.add("score",set);

        // 获取数据
        Set scores = zSetOperations.range("score", 0, 4);
        for (Object score : scores) {
            System.out.println(score);
        }

        // 删除
        zSetOperations.remove("score","zhangsan","lisi");

        // 获取总条数
        Long size = zSetOperations.size("score");
        System.out.println("size: "+size);
    }