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

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

作者：一一哥

在上一章节中，我们利用默认的ConcurrentHashMap来实现了一种默认的内存级别的缓存方案。但是该方案并没有进行持久化缓存，一旦内存被释放，缓存也就不存在了，所以本章节中，我带大家利用之前学过的Redis，来实现把缓存数据持久化到Redis中。

本案例中，我直接在上一节的案例上进行改造。

一. Spring Boot整合Redis实现缓存

1. 创建web项目

我们按照之前的经验，创建一个web程序，并将之改造成Spring Boot项目，具体过程略。



2. 添加依赖包

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

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- 改造:添加sql相关的依赖-->
        <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. 修改缓存管理器等配置类

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仓库类

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服务类

定义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);

}

实现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接口方法

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. 完整项目结构



11. 重新项目进行测试

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

解析来我在postman中进行查询。

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

控制台中也可以看到User的hashCode依然相同，说明我们已经成功的整合了Redis，实现了把数据缓存到了Redis中，进而实现了持久化。