SpringBoot2.x系列教程33--SpringBoot中整合Redis实现持久化缓存效果

女爷i 2023-09-23 16:58 98阅读 0赞

### 前言 ###

在上一章节中，壹哥 带大家利用默认的ConcurrentHashMap，实现了一种默认的内存级别的缓存效果。但是这种缓存方案，并没有把数据实现持久化缓存，也就是说一旦内存被释放，缓存的数据也就不存在了。所以在本章节中，我会带大家结合之前学过的Redis，带各位把数据持久化缓存到Redis中。

本案例我会直接在上一节的案例基础上进行改造。

### 一. Spring Boot整合Redis实现缓存 ###

#### 1. 创建Web项目 ####

我们按照之前的经验，创建一个SpringBoot的Web程序，具体过程略。

![format_png][]

#### 2. 添加依赖包 ####

我们在上一章节的基础上，添加2个新的依赖包，redis和json的。

<dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-cache</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.39</version>
    			</dependency>
    复制代码

#### 3. 修改application.yml配置文件 ####

主要是添加关于redis的配置信息，以及设置缓存类型。

cache:
      default-exp: 1000 #单位秒,缓存的过期时间
    server:
      port: 8080
    spring:
      application:
        name: cache-demo
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        username: root
        password: syc
        url: jdbc:mysql://localhost:3306/spring-security?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&serverTimezone=UTC
      redis:
        host: localhost
        port: 6379
        database: 0
        #password:
      cache:
        type: redis #由redis进行缓存,一共有10种缓存方案
      jpa:
        database: mysql
        show-sql: true #开发阶段,打印要执行的sql语句.
        hibernate:
          ddl-auto: update
    复制代码

#### 4. 修改缓存管理器等配置类 ####

这里我创建一个CacheConfig缓存配置类，对Redis进行基本的配置。

package com.yyg.boot.config;
    
    import com.alibaba.fastjson.JSON;
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.lang.reflect.Method;
    import java.time.Duration;
    
    /**
     * @Author 一一哥Sun
     * @Date Created in 2020/4/14
     * @Description Description
     * EnableCaching启用缓存
     */
    @Configuration
    @EnableCaching
    public class CacheConfig {
    
        @Value("${cache.default-exp}")
        private long exps;
    
        @Value("${spring.redis.host}")
        private String host;
    
        @Value("${spring.redis.port}")
        private int port;
    
        //@Value("${spring.redis.timeout}")
        //private int timeout;
    
        //@Value("${spring.redis.password}")
        //private String password;
    
        @Bean
        public KeyGenerator keyGenerator() {
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    StringBuffer sb = new StringBuffer();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) {
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
    
        /**
         * RedisTemplate配置
         */
        @Bean
        public RedisTemplate<?, ?> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(redisConnectionFactory);
            // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
            Jackson2JsonRedisSerializer<JSON> serializer = new Jackson2JsonRedisSerializer<JSON>(JSON.class);
            ObjectMapper mapper = new ObjectMapper();
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            serializer.setObjectMapper(mapper);
            template.setValueSerializer(serializer);
            template.setHashValueSerializer(serializer);
            // 使用StringRedisSerializer来序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
            template.afterPropertiesSet();
            return template;
        }
    
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
            // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
            RedisSerializer<String> redisSerializer = new StringRedisSerializer();
            // 使用Jackson2JsnRedisSerializer来序列化和反序列化redis的value值
            Jackson2JsonRedisSerializer<JSON> serializer = new Jackson2JsonRedisSerializer<>(JSON.class);
            // 配置序列化
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
            config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer));
            config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));
            // 设置缓存的默认过期时间
            config.entryTtl(Duration.ofSeconds(exps));
            // 不缓存空值
            config.disableCachingNullValues();
            return  RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build();
        }
    
    }
    复制代码

#### 5. 创建实体类 ####

这里我们创建一个实体类，封装用户信息。

package com.yyg.boot.domain;
    
    import lombok.Data;
    import lombok.ToString;
    
    import javax.persistence.*;
    import java.io.Serializable;
    
    @Entity
    @Table(name="user")
    @Data
    @ToString
    public class User implements Serializable {
    
        //IllegalArgumentException: DefaultSerializer requires a Serializable payload
        // but received an object of type [com.syc.redis.domain.User]
    
        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        private Long id;
    
        @Column
        private String username;
    
        @Column
        private String password;
    
    }
    复制代码

#### 6. 创建User仓库类 ####

再定义一个JpaRepository，用于对User类进行CRUD操作。

package com.yyg.boot.repository;
    
    import com.yyg.boot.domain.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    
    public interface UserRepository extends JpaRepository<User,Long> {
    }
    复制代码

#### 7. 创建Service服务类 ####

然后我们在service层定义几个方法，实现对User信息的增删改查操作。

7.1 定义UserService接口

package com.yyg.boot.service;
    
    import com.yyg.boot.domain.User;
    
    public interface UserService {
    
        User findById(Long id);
    
        User save(User user);
    
        void deleteById(Long id);
    
    }
    复制代码

7.2 实现UserServiceImpl类

package com.yyg.boot.service.impl;
    
    import com.yyg.boot.domain.User;
    import com.yyg.boot.repository.UserRepository;
    import com.yyg.boot.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.CachePut;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserRepository userRepository;
    
        //普通的缓存+数据库查询代码实现逻辑:
        //User user=RedisUtil.get(key);
        //   if(user==null){
        //   	  user=userDao.findById(id);
        //   	  //redis的key="product_item_"+id
        //   	  RedisUtil.set(key,user);
        //   }
        //   return user;
    
        /**
         *  注解@Cacheable:查询的时候才使用该注解!
         *  注意:在Cacheable注解中支持EL表达式
         *  redis缓存的key=user_1/2/3....
         *  redis的缓存雪崩,缓存穿透,缓存预热,缓存更新...
         *  condition = "#result ne null",条件表达式,当满足某个条件的时候才进行缓存
         *  unless = "#result eq null":当user对象为空的时候,不进行缓存
         */
        @Cacheable(value = "user", key = "#id", unless = "#result eq null")
        @Override
        public User findById(Long id) {
    
            return userRepository.findById(id).orElse(null);
        }
    
        /**
         * 注解@CachePut:一般用在添加和修改方法中
         * 既往数据库中添加一个新的对象,于此同时也往redis缓存中添加一个对应的缓存.
         * 这样可以达到缓存预热的目的.
         */
        @CachePut(value = "user", key = "#result.id", unless = "#result eq null")
        @Override
        public User save(User user) {
            return userRepository.save(user);
        }
    
        /**
         * CacheEvict:一般用在删除方法中
         */
        @CacheEvict(value = "user", key = "#id")
        @Override
        public void deleteById(Long id) {
            userRepository.deleteById(id);
        }
    
    }
    复制代码

#### 8. 创建Controller接口方法 ####

创建一个Controller，定义几个URL接口进行测试。

package com.yyg.boot.web;
    
    import com.yyg.boot.domain.User;
    import com.yyg.boot.service.UserService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.*;
    
    @RestController
    @RequestMapping("/user")
    @Slf4j
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        @PostMapping
        public User saveUser(@RequestBody User user) {
            return userService.save(user);
        }
    
        @GetMapping("/{id}")
        public ResponseEntity<User> getUserById(@PathVariable("id") Long id) {
            User user = userService.findById(id);
            log.warn("user="+user.hashCode());
            HttpStatus status = user == null ? HttpStatus.NOT_FOUND : HttpStatus.OK;
            return new ResponseEntity<>(user, status);
        }
    
        @DeleteMapping("/{id}")
        public String removeUser(@PathVariable("id") Long id) {
            userService.deleteById(id);
            return "ok";
        }
    
    }
    复制代码

#### 9. 创建入口类 ####

最后我们创建一个入口类，启动项目。

package com.yyg.boot;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class CacheApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(CacheApplication.class, args);
        }
    
    }
    复制代码

#### 10. 项目代码结构 ####

如下是完整的项目代码结构，各位可以参考创建。

![format_png 1][]

#### 11. 重新项目进行测试 ####

首先可以看到，我的redis中此时没有任何缓存数据。

![format_png 2][]

接下来我在Postman中进行查询测试。

![format_png 3][]

此时在Redis Desktop Manager中，我们重新加载一下数据，可以看到已经有了缓存的redis数据了。

![format_png 4][]

控制台中也可以看到User的hashCode依然相同，说明我们已经成功的利用Redis实现了缓存，并且实现了持久化，因为Redis会自动把数据保存到内存和硬盘上，自带持久化策略。

![format_png 5][]

### 结语 ###

这样，**壹哥** 就在SpringBoot中，把数据持久化缓存到了Redis中，这样我们就不用担心数据会丢失了，而且因为有了缓存，所以效率与数据安全性都得到了保证。

**今日小作业：**

**再次改造学生信息管理系统，实现学生缓存信息的持久化。**

[format_png]: https://img-blog.csdnimg.cn/img_convert/e9274f89d12bae1d2cd57e72978622a7.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/36238f6d9d855d92cfccbe627e0896f4.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/f286fc37eef735b9bee0433b6876b536.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/bc54ac82eec050ae1231c81316e4507e.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/c5aae35047f4ffbabcca5fcfaaaa78c7.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/378424a464114bee46844ee57ae85cd0.webp?x-oss-process=image/format,png