Spring Boot demo系列：Redis缓存

我不是女神ヾ 2022-09-13 11:28 170阅读 0赞

### 目录 ###

*  Spring Boot demo系列 ：Redis缓存
 *   *   *  12.2.1 手动添加\`@class\`
         *  12.2.2 将实体类设置为\`open\`
 *

# Spring Boot demo系列 ：Redis缓存 #

本文演示了如何在`Spring Boot`中将`Redis`作为缓存使用，具体的内容包括：

*  环境搭建
 *  项目搭建
 *  测试
 *  `Redis`
 *  `MySQL`
 *  `MyBatis Plus`

`Redis`安装非常简单，以笔者的`Manjaro`为例，直接`paru`安装：

paru -S redis

`Ubuntu`、`CentOS`之类的都提供了软件包安装：

sudo apt install redis
    sudo yum install redis

如果想从源码编译安装：

wget http://download.redis.io/redis-stable.tar.gz
    tar xvzf redis-stable.tar.gz
    cd redis-stable
    make

`Windows`以及其他系统的安装可以参考[此处][Link 1]。

新建项目，加入如下依赖：

`Maven`：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.2</version>
    </dependency>

`Gradle`：

implementation("com.baomidou:mybatis-plus-boot-starter:3.4.2")
    implementation("mysql:mysql-connector-java:8.0.23")

项目结构：

[![在这里插入图片描述][20210223194201507.png]][20210223194201507.png]

`MyBatis Plus`\+`Redis`配置类：

@Configuration
    @MapperScan("com.example.demo.dao")
    public class MyBatisPlusConfig {
    }

@Configuration
    @AutoConfigureAfter(RedisAutoConfiguration.class)
    @EnableCaching
    public class RedisConfig {
        @Bean
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
            template.setConnectionFactory(factory);
            return template;
        }
    
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory factory) {
            RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
            .serializeKeysWith(
                RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())
            ).serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())
            );
            return RedisCacheManager.builder(factory).cacheDefaults(configuration).build();
        }
    }

重点说一下`Redis`配置类，这个类主要生成两个`Bean`：

*  `RedisTemplate`：简化`Redis`操作的数据访问类
 *  `CacheManager`：`Spring`的中央缓存管理器

其中`RedisTemplate`是一个模板类，第一个参数的类型是该`template`使用的键的类型，通常是`String`，第二个参数的类型是该`template`使用的值的类型，通常为`Object`或`Seriazable`。

`setKeySerializer`和`setValueSerializer`分别设置键值的序列化器。键一般为`String`类型，可以使用自带的`StringRedisSerializer`。对于值，可以使用自带的`GenericJackson2RedisSerializer`。

`CacheManager`的配置类似，就不重新说了。

@Getter
    @Setter
    @ToString
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        private Integer id;
        private String name;
    }

public interface UserMapper extends BaseMapper<User> {
    }

@org.springframework.stereotype.Service
    @Transactional
    @RequiredArgsConstructor(onConstructor = @__(@Autowired))
    public class Service {
        private final UserMapper mapper;
    
        @CachePut(value = "user",key = "#user.id")
        public User save(User user){
            User oldUser = mapper.selectById(user.getId());
            if(oldUser == null){
                mapper.insert(user);
                return user;
            }
            if(mapper.updateById(user) == 1)
                return user;
            return oldUser;
        }
    
        @CacheEvict(value = "user",key = "#id")
        public boolean delete(Integer id){
            return mapper.deleteById(id) == 1;
        }
    
        @Cacheable(value = "user",key = "#id")
        public User select(Integer id){
            return mapper.selectById(id);
        }
    
        @Cacheable(value="allUser",key = "#root.target+#root.methodName")
        //root.target是目标类，这里是com.example.demo.Service，root.methodName是方法名，这里是selectAll
        public List<User> selectAll(){
            return mapper.selectList(null);
        }
    }

注解说明如下：

*  `@CachePut`：执行方法体再将返回值缓存，一般用于更新数据
 *  `@CacheEvict`：删除缓存，一般用于删除数据
 *  `@Cacheable`：查询缓存，如果有缓存就直接返回，没有缓存的话执行方法体并将返回值存入缓存，一般用于查询数据

三个注解都涉及到了`key`以及`value`属性，实际上，真正的存入`Redis`的`key`是两者的组合，比如：

@Cacheable(value="user",key="#id")

则存入的`Redis`中的`key`为：

[![在这里插入图片描述][20210223210929435.png]][20210223210929435.png]

而存入对应的值为方法返回值序列化后的结果，比如如果返回值为`User`，则会被序列化为：

[![在这里插入图片描述][202102240035293.png]][202102240035293.png]

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/test
        username: root
        password: 123456
      redis:
        database: 0
        host: 127.0.0.1
        port: 6379
    logging:
      level:
        com.example.demo: debug

`spring.redis.database`指定数据库的索引，默认为0，`host`与`port`分别指定主机（默认本地）以及端口（默认`6379`）。

也就是说，简单配置的话可以完全省略`Redis`相关配置，仅指定数据库连接`url`、用户名以及密码：

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/test
        username: root
        password: 123456
    logging:
      level:
        com.example.demo: debug

`Redis`服务器启动需要一个配置文件，默认位置为`/etc/redis.conf`（源码编译安装的话在源文件夹内），建议先复制一份：

cp /etc/redis.conf ~/Desktop/

默认的配置文件为单机`Redis`配置，端口`6379`，`redis-server`可以直接运行：

sudo redis-server redis.conf

连接可以通过自带的`redis-cli`命令：

redis-cli -h localhost -p 6379

默认情况下可以直接使用

redis-cli

连接。

基本操作：

*  `keys *`：查询所有键
 *  `get key`：查询`key`所对应的值
 *  `flushall`：清空所有键

[![在这里插入图片描述][20210224002836614.png]][20210224002836614.png]

@SpringBootTest
    @RequiredArgsConstructor(onConstructor = @__(@Autowired))
    class DemoApplicationTests {
    
        private final Service service;
    
        @Test
        void select() {
            service.select(1);
            service.select(1);
        }
    
        @Test
        void selectAll(){
            service.selectAll();
            service.selectAll();
        }
    
        @Test
        void delete(){
            service.delete(1);
        }
    
        @Test
        void save(){
            User user = new User(1,"name1");
            service.save(user);
            service.select(user.getId());
            user.setName("name2");
            service.save(user);
            service.select(user.getId());
        }
    }

执行其中的`select`，会发现`MyBatis Plus`只有一次`select`的输出，证明缓存生效了：

[![在这里插入图片描述][20210223211341949.png]][20210223211341949.png]

而把缓存注解去掉后，会有两次`select`输出：

[![在这里插入图片描述][20210223211541773.png]][20210223211541773.png]

其它测试方法就不截图了，原理类似。

其实`@Cacheable`/`@CacheEvict`/`@CachePut`中的`value`都是`String []`，在`Java`中可以直接写上`value`，在`Kotlin`中需要`[value]`。

序列化到`Redis`时，实体类会被加上一个`@class`字段：

[![在这里插入图片描述][202102240035293.png]][202102240035293.png]

这个标识供`Jackson`反序列化时使用，笔者一开始的实体类实现是：

data class User(var id:Int?=null, var name:String="")

但是序列化后不携带`@class`字段：

[![在这里插入图片描述][20210224011003732.png]][20210224011003732.png]

在反序列化时直接报错：

Could not read JSON: Missing type id when trying to resolve subtype of [simple type, class java.lang.Object]: missing type id property '@class'
     at [Source: (byte[])"{"id":1,"name":"name2"}"; line: 1, column: 23]; nested exception is com.fasterxml.jackson.databind.exc.InvalidTypeIdException: Missing type id when trying to resolve subtype of [simple type, class java.lang.Object]: missing type id property '@class'
     at [Source: (byte[])"{"id":1,"name":"name2"}"; line: 1, column: 23]

解决方法有两个：

*  手动添加`@class`字段
 *  将实体类设为`open`

### 12.2.1 手动添加`@class` ###

准确来说并不是手动添加，而是让注解添加，需要添加一个类注解`@JsonTypeInfo`：

@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS)
    data class User(var id:Int?=null, var name:String="")

该注解的`use`用于指定类型标识码，该值只能为`JsonTypeInfo.Id.CLASS`。

### 12.2.2 将实体类设置为`open` ###

在`Java`中，实体类没有任何额外配置，`Redis`序列化/反序列化一样没有问题，是因为值序列化器`GenericJackson2JsonRedisSerializer`，该类会自动添加一个`@class`字段，因此不会出现上面的问题。

但是在`Kotlin`中，类默认不是`open`的，也就是无法添加`@class`字段，因此便会反序列化失败，解决方案是将实体类设置为`open`：

open class User(var id:Int?=null, var name:String="")

但是缺点是不能使用`data class`了。

`Java`版：

*  [Github][]
 *  [码云][Link 2]
 *  [CODECHINA][]

`Kotlin`版：

*  [Github][Github 1]
 *  [码云][Link 3]
 *  [CODECHINA][CODECHINA 1]

#  #

[Link 1]: https://www.redis.net.cn/tutorial/3503.html
[20210223194201507.png]: /images/20220828/9ad151195df74696b31e2a80d6cf3168.png
[20210223210929435.png]: /images/20220828/b809407dad8e4d639e703ce216d35743.png
[202102240035293.png]: /images/20220828/e8aca2024e6e483cb42ca15725cc3de6.png
[20210224002836614.png]: /images/20220828/5b505c05195e42f2846e98d02209bd3c.png
[20210223211341949.png]: /images/20220828/31ccccc1f40342c1a9577c3196ed87f8.png
[20210223211541773.png]: /images/20220828/d1a7458fafc24807b242c817615ad736.png
[20210224011003732.png]: /images/20220828/cb1ba8adcfbf4bd69a7f0bce0fa76cb9.png
[Github]: https://github.com/2293736867/SpringBootDemoJava/tree/main/RedisCache
[Link 2]: https://gitee.com/u6b7b5fc3/SpringBootDemoJava/tree/main/RedisCache
[CODECHINA]: https://codechina.csdn.net/qq_27525611/SpringBootDemoJava/-/tree/main/RedisCache
[Github 1]: https://github.com/2293736867/SpringBootDemoKotlin/tree/main/RedisCache
[Link 3]: https://gitee.com/u6b7b5fc3/SpringBootDemoKotlin/tree/main/RedisCache
[CODECHINA 1]: https://codechina.csdn.net/qq_27525611/SpringBootDemoKotlin/-/tree/main/RedisCache