SpringBoot2.x系列教程33--SpringBoot中整合Redis实现持久化缓存效果
前言
在上一章节中，壹哥 带大家利用默认的ConcurrentHashMap，实现了一种默认的内存级别的缓存效果。但是这种缓存方案，并没有把数据实现持久化缓存，也就是说一旦内存被释放，缓存的数据也就不存在了。所以在本章节中，我会带大家结合之前学过的Redis，带各位把数据持久化缓存到Redis中。
本案例我会直接在上一节的案例基础上进行改造。
一. Spring Boot整合Redis实现缓存
1. 创建Web项目
我们按照之前的经验，创建一个SpringBoot的Web程序，具体过程略。
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. 修改缓存管理器等配置类
这里我创建一个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. 项目代码结构
如下是完整的项目代码结构，各位可以参考创建。
11. 重新项目进行测试
首先可以看到，我的redis中此时没有任何缓存数据。
接下来我在Postman中进行查询测试。
此时在Redis Desktop Manager中，我们重新加载一下数据，可以看到已经有了缓存的redis数据了。
控制台中也可以看到User的hashCode依然相同，说明我们已经成功的利用Redis实现了缓存，并且实现了持久化，因为Redis会自动把数据保存到内存和硬盘上，自带持久化策略。
结语
这样，壹哥 就在SpringBoot中，把数据持久化缓存到了Redis中，这样我们就不用担心数据会丢失了，而且因为有了缓存，所以效率与数据安全性都得到了保证。
今日小作业：
再次改造学生信息管理系统，实现学生缓存信息的持久化。
作者：一一哥Sun
链接：https://juejin.cn/post/7170469344051200030