SpringBoot操作Redis

1、首先在我们的pom文件中导入spring data redis坐标

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

2、在application.yml中配置redis

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0

3、创建一个RedisConfig配置类，注入自定义RedisTemplate的Bean（非必要）；因为springboot中默认的key序列化器是JdkSerializationRedisSerializer，导致在本地redis-cli.exe中查看key时会出现乱码。配置该类主要是为了在本地的redis-cli.exe中查看key时不会乱码）

package com.zzuli.reggie.config;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){

        RedisTemplate<Object,Object> redisTemplate = new RedisTemplate<>();

        //springboot中默认的key序列化器是：JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.setConnectionFactory(redisConnectionFactory);

        return redisTemplate;
    }
}
        
        

4、使用

只需要在使用reids做缓存的类中自动注入一个由IOC容器管理的RedisTemplate，然后调用相应的类型方法即可。

package com.zzuli.redistest4;

import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@SpringBootTest()
@RunWith(SpringRunner.class)
class RedisTest4ApplicationTests {


    //注入RedisTemplate
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() throws InterruptedException {
        /**
         * 简单的k-v操作
         */
        ValueOperations valueOperations = redisTemplate.opsForValue();

        valueOperations.set("chengshi","河南南阳",15L,TimeUnit.SECONDS);
        String city = (String) valueOperations.get("chengshi");
        System.out.println("chengshi设置的值-->" + city);//河南南阳

        valueOperations.set("key1","十秒钟后过期",10L, TimeUnit.SECONDS);
        System.out.println("睡眠之前-->"+valueOperations.get("key1"));//十秒钟后过期
        Thread.sleep(11000);
        System.out.println(valueOperations.get("睡眠10s之后-->" + "key1"));//null

        Boolean ifAbsent = valueOperations.setIfAbsent("chengshi", "山东济南");
        System.out.println("chengshi没过期-->" + ifAbsent);//false

        Thread.sleep(6000);
        System.out.println("chengshi过期了-->"+valueOperations.setIfAbsent("chengshi","好客山东"));//true

        System.out.println(valueOperations.get("chengshi"));//好客山东
//---------------------------------------------------------------------------------------
        /**
         * set类型的操作
         */
        SetOperations setOperations = redisTemplate.opsForSet();
        /**
         * zset类型的操作
         */
        HashOperations hashOperations = redisTemplate.opsForHash();
        /**
         * 针对map类型的数据操作
         */
        ListOperations listOperations = redisTemplate.opsForList();
        /**
         * 针对list类型的数据操作
         */
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    }


    /**
     * hash类型
     */
    @Test
    void hashTest(){
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.put("001","name","张三");
        hashOperations.put("001","age","13");
        hashOperations.put("001","sex","男");
        Set keys = hashOperations.keys("001");
        for (Object key : keys) {
            System.out.println(key);
        }
        List<Object> values = hashOperations.values("001");
        List<Object> list = values.stream().map((item) ->{
            System.out.println(item);
            return item;
        }).collect(Collectors.toList());
    }

    /**
     * list类型
     */

    @Test
    void listTest(){
        ListOperations listOperations = redisTemplate.opsForList();
        listOperations.leftPush("phone","iphone");
        listOperations.leftPushAll("phone","huawei","chuzi","ztx");
        List<Object> phone = listOperations.range("phone", 0, -1);
        phone.stream().map((item) ->{
            System.out.println(item);
            listOperations.rightPop("phone");
            return item;
        }).collect(Collectors.toList());
        System.out.println("==========================================");
        List<Object> phone1 = listOperations.range("phone", 1, -1);
        phone1.stream().map((item) ->{
            System.out.println(item);
            return item;
        }).collect(Collectors.toList());
    }

    /**
     * set类型
     */
    @Test
    void setTest(){
        SetOperations setOperations = redisTemplate.opsForSet();
        setOperations.add("myset","西瓜","大大西瓜","大西瓜");

        Set myset = setOperations.members("myset");
        for (Object o : myset) {
            System.out.println(o);
        }

        setOperations.remove("myset","大西瓜","大大西瓜");

        Set mysetq = setOperations.members("myset");
        for (Object o : mysetq) {
            System.out.println(o);
        }

    }

    /**
     * 操作zset
     */
    @Test
    void zsetTest(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        zSetOperations.add("myZset","kele",3.0);
        zSetOperations.add("myZset","fenda",5.0);
        zSetOperations.add("myZset","maidong",6.0);
        zSetOperations.add("myZset","kele",7.0);

        Set<String > myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }

        zSetOperations.incrementScore("myZset","fenda",10.0);

        Set<String> myZset1 = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset1) {
            System.out.println(s);
        }
        zSetOperations.removeRangeByScore("myZset",7.0,7.0);

        Set<String> myZset2 = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset2) {
            System.out.println(s);
        }

    }

    /**
     * 通用操作
     */
    @Test
    void commonTest(){
        //获取redis中所有的key
        Set<String> keys = redisTemplate.keys("*");
        int count = 0;
        for (String key : keys) {
            System.out.println("第" + count + "号key是" + key);
            count++;
        }

        //判断某个key是否存在
        System.out.println("判断chengshi是否存在——>" + redisTemplate.hasKey("chengshi"));

        //删除指定key
        redisTemplate.delete("chengshi");
        System.out.println("删除chengshi之后是否还存在city————>" + redisTemplate.hasKey("chengshi"));

        //获取指定key对应的指定数据类型
        DataType myZset = redisTemplate.type("myZset");
        System.out.println("myZset的类型是：" + myZset.toString());

    }
}