Spring Boot - 使用 redis 缓存数据

- 日理万妓 2023-10-12 21:07 128阅读 0赞

## 实体类 ##

package com.lfsun.springbootcacheredis.entity;
 
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.io.Serializable;
 
 /**
 * 
 * 用户实体
 * 
 */
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
 public class User implements Serializable {
 
 private static final long serialVersionUID = 2892248514883451461L;
 /**
 * 主键id
 */
 private Long id;
 /**
 * 姓名
 */
 private String name;
 }

## redis配置 ##

spring:
      redis:
        # 连接超时时间（记得添加单位，Duration）
        # Redis默认情况下有16个分片，这里配置具体使用的分片
        # database: 0
        lettuce:
          pool:
            # 连接池最大连接数（使用负值表示没有限制） 默认 8
            max-active: 8
            # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
            max-wait: -1ms
            # 连接池中的最大空闲连接 默认 8
            max-idle: 8
            # 连接池中的最小空闲连接 默认 0
            min-idle: 0
      cache:
        # 一般来说是不用配置的，Spring Cache 会根据依赖的包自行装配
        type: redis
      data:
        redis:
          host: localhost
          timeout: 10000ms
    logging:
      level:
        com.lfsun: debug

package com.lfsun.springbootcacheredis.config;
 
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.EnableCaching;
 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.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.RedisSerializationContext;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
 import java.io.Serializable;
 
 /**
 * 
 * redis配置
 * 
 */
 @Configuration
 @AutoConfigureAfter(RedisAutoConfiguration.class)
 @EnableCaching
 public class RedisConfig {
 
 
 /**
 * 默认情况下的模板只能支持RedisTemplate<String, String>，也就是只能存入字符串，因此支持序列化
 */
 @Bean
 public RedisTemplate<String, Serializable> redisCacheTemplate(LettuceConnectionFactory redisConnectionFactory) {
 
 RedisTemplate<String, Serializable> template = new RedisTemplate<>();
 template.setKeySerializer(new StringRedisSerializer());
 template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
 template.setConnectionFactory(redisConnectionFactory);
 return template;
 }
 
 /**
 * 配置使用注解的时候缓存配置，默认是序列化反序列化的形式，加上此配置则为 json 形式
 */
 @Bean
 public CacheManager cacheManager(RedisConnectionFactory factory) {
 
 // 配置序列化
 RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
 RedisCacheConfiguration redisCacheConfiguration = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())).serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
 
 return RedisCacheManager.builder(factory).cacheDefaults(redisCacheConfiguration).build();
 }
 }

## 接口与实现类 ##

package com.lfsun.springbootcacheredis.service;
 
 
 import com.lfsun.springbootcacheredis.entity.User;
 
 /**
 * 
 * UserService
 * 
 */
 public interface UserService {
 
 /**
 * 保存或修改用户
 *
 * @param user 用户对象
 * @return 操作结果
 */
 User saveOrUpdate(User user);
 
 /**
 * 获取用户
 *
 * @param id key值
 * @return 返回结果
 */
 User get(Long id);
 
 /**
 * 删除
 *
 * @param id key值
 */
 void delete(Long id);
 }

package com.lfsun.springbootcacheredis.service.impl;
 
 import com.google.common.collect.Maps;
 import com.lfsun.springbootcacheredis.entity.User;
 import com.lfsun.springbootcacheredis.service.UserService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.CachePut;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 
 import java.util.Map;
 
 /**
 * 
 * UserService
 * 
 */
 @Service
 @Slf4j
 public class UserServiceImpl implements UserService {
 
 /**
 * 模拟数据库
 */
 private static final Map<Long, User> DATABASES = Maps.newConcurrentMap();
 
 /**
 * 初始化数据
 */
 static {
 
 DATABASES.put(1L, new User(1L, "user1"));
 DATABASES.put(2L, new User(2L, "user2"));
 DATABASES.put(3L, new User(3L, "user3"));
 }
 
 /**
 * 保存或修改用户
 *
 * @param user 用户对象
 * @return 操作结果
 */
 @CachePut(value = "user", key = "#user.id")
 @Override
 public User saveOrUpdate(User user) {
 
 DATABASES.put(user.getId(), user);
 log.info("保存用户【user】= {}", user);
 return user;
 }
 
 /**
 * 获取用户
 *
 * @param id key值
 * @return 返回结果
 */
 @Cacheable(value = "user", key = "#id")
 @Override
 public User get(Long id) {
 
 // 我们假设从数据库读取
 log.info("查询用户【id】= {}", id);
 return DATABASES.get(id);
 }
 
 /**
 * 删除
 *
 * @param id key值
 */
 @CacheEvict(value = "user", key = "#id")
 @Override
 public void delete(Long id) {
 
 DATABASES.remove(id);
 log.info("删除用户【id】= {}", id);
 }
 }

## 测试 ##

package com.lfsun.springbootcacheredis;
 
 import com.lfsun.springbootcacheredis.entity.User;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.StringRedisTemplate;
 
 import java.io.Serializable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.stream.IntStream;
 
 /**
 * 
 * Redis测试
 * 
 */
 @Slf4j
 public class RedisTest extends SpringBootCacheRedisApplicationTests {
 
 
 @Autowired
 private StringRedisTemplate stringRedisTemplate;
 
 @Autowired
 private RedisTemplate<String, Serializable> redisCacheTemplate;
 
 /**
 * 测试 Redis 操作
 */
 @Test
 public void get() {
 
 // 测试线程安全，程序结束查看redis中count的值是否为1000
 ExecutorService executorService = Executors.newFixedThreadPool(1000);
 IntStream.range(0, 1000).forEach(i -> executorService.execute(() -> stringRedisTemplate.opsForValue().increment("count", 1)));
 
 stringRedisTemplate.opsForValue().set("k1", "v1");
 String k1 = stringRedisTemplate.opsForValue().get("k1");
 log.debug("【k1】= {}", k1);
 
 // 以下演示整合，具体Redis命令可以参考官方文档
 String key = "lfsun:user:1";
 redisCacheTemplate.opsForValue().set(key, new User(1L, "user1"));
 // 对应 String（字符串）
 User user = (User) redisCacheTemplate.opsForValue().get(key);
 log.debug("【user】= {}", user);
 }
 }

package com.lfsun.springbootcacheredis.service;
 
 
 import com.lfsun.springbootcacheredis.SpringBootCacheRedisApplicationTests;
 import com.lfsun.springbootcacheredis.entity.User;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 
 /**
 * 
 * Redis - 缓存测试
 * 
 */
 @Slf4j
 public class UserServiceTest extends SpringBootCacheRedisApplicationTests {
 
 @Autowired
 private UserService userService;
 
 /**
 * 获取两次，查看日志验证缓存
 */
 @Test
 public void getTwice() {
 
 // 模拟查询id为1的用户
 User user1 = userService.get(1L);
 log.debug("【user1】= {}", user1);
 
 // 再次查询
 User user2 = userService.get(1L);
 log.debug("【user2】= {}", user2);
 // 查看日志，只打印一次日志，证明缓存生效
 }
 
 /**
 * 先存，再查询，查看日志验证缓存
 */
 @Test
 public void getAfterSave() {
 
 userService.saveOrUpdate(new User(4L, "测试中文"));
 
 User user = userService.get(4L);
 log.debug("【user】= {}", user);
 // 查看日志，只打印保存用户的日志，查询是未触发查询日志，因此缓存生效
 }
 
 /**
 * 测试删除，查看redis是否存在缓存数据
 */
 @Test
 public void deleteUser() {
 
 // 查询一次，使redis中存在缓存数据
 userService.get(1L);
 // 删除，查看redis是否存在缓存数据
 userService.delete(1L);
 }
 
 }

## 完整代码案例地址 ##

[Spring Boot 集成 redis][Spring Boot _ redis]

[Spring Boot _ redis]: https://gitee.com/lfsun666/springboot-study-2023/tree/master/spring-boot-cache-redis