32springboot——缓存之整合Redis

Posted 2021-03-01 Arbitrary233

springboot缓存默认使用ConcurrentMapCacheManager 将数据保存在下面的Map中

1、docker中开启Redis

 2、添加Redis相关依赖

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

我还多加了下面这个依赖才不会报错，具体原因尚未了解

<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
</dependency>

此时redis就引入再容器中

可以查看自动配置的类（RedisAutoConfiguration.class）分别注入了操作对象的类和操作字符串的类

public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

4、在配置文件中引入redis服务所在的ip地址：

 5、测试

测试：

此时两个操作redis的类都在容器中，在测试的时候直接进行注入使用

    @Autowired
    StringRedisTemplate stringRedisTemplate;    //操作k-v都是字符串的
    @Autowired
    RedisTemplate redisTemplate;        //操作k-v都是对象的

    @Test
    public void testRedis(){
        //给redis中保存数据
        stringRedisTemplate.opsForValue().append("name","lisi");
        //读数据
        String name = stringRedisTemplate.opsForValue().get("name");
        System.out.println(name);
        //放列表
        stringRedisTemplate.opsForList().leftPush("myList","1");
        stringRedisTemplate.opsForList().leftPush("myList","2");
        stringRedisTemplate.opsForList().leftPush("myList","3");
    }

在Redis Desk Manager中可以看到存入成功

 使用redisTemplate测试添加对象：

　　插入的对象实现类需要实现序列化

public class Employee  implements Serializable {

//测试保存对象
@Test
public  void test2(){
    //保存的是emp的对象
    Employee emp = employeeMapper.getEmpById(1);
    //保存的是employee的对象
    //默认如果使用保存对象，使用jdk序列化机制，序列化后的数据保存在redis中
    redisTemplate.opsForValue().set("emp01",emp);
}

插入后的数据如下：

 因为这个redisTemplate默认使用的是jdk的序列化机制；

 想要保存为json序列化格式则可以自定义一个redisTemplate进行设置json的序列化机制

　　创建一个MyRedisConfig类进行Redis自定义的相关配置

@Configuration
public class MyRedisConfig {
    //专门以json格式序列化Employee
    @Bean
    public RedisTemplate<Object, Employee> empRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Employee> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Employee> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
        template.setDefaultSerializer(jackson2JsonRedisSerializer);
        return template;
    }
}

下面的代码是RedisAutoConfiguration源码中注入默认RedisTemplate的代码

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

进行对比可以发现我们只是增加了json格式的序列化机制（红色部分代码）

还有其他的序列化机制（如下图），需要的时候进行配置即可

 此时在测试代码中再使用我们自己注入的empRedisTemplate

@Autowired              //注入
RedisTemplate<Object, Employee> empRedisTemplate;
//测试保存对象
@Test
public  void test2(){
    //保存的是emp的对象
    Employee emp = employeeMapper.getEmpById(1);
    //保存的是employee的对象
    //默认如果使用保存对象，使用jdk序列化机制，序列化后的数据保存在redis中
    empRedisTemplate.opsForValue().set("emp01",emp);
}

可以看到插入的数据就是json格式了