SpringBoot整合redis做数据缓存

Spring的支持

Spring对redis的支持也是通过Spring Data Redis来实现的，Spring Data JPA为我们提供了链接相关的ConnectionFactory和数据库操作相关的RedisTemplate。

Spring Data Redis提供了两种JedisConnectionFactory和LettuceConnectionFactory。默认使用的是LettuceConnectionFactory。

Spring Data Redis为我们提供了RedisTemplate和StringRedisTemplate两个模板来进行数据操作，其中，StringRedisTemplate只针对键值都是字符串的数据进行操作。

StringRedisTemplate和RedisTemplate提供的主要数据访问方法如下：

方法	说明
opsForValue()	操作只有简单属性的数据
opsForList()	操作含有list的数据
opsForSet()	操作含有set的数据
opsForZSet()	操作含有ZSet的数据
opsForHash()	操作含有hash的数据

当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer。

Spring Data JPA为我们提供了6中Serializer：GenericJackson2JsonRedisSerializer、GenericToStringSerializer、Jackson2JsonRedisSerializer、JdkSerializationRedisSerializer、OxmSerializer、StringRedisSerializer。

我们在做数据缓存的时候可以手动使用RedisTemplate来操作Redis数据库，也可以使用注解来操作。

• 使用RedisTemplate来操作

添加依赖

        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

添加redis数据库连接

#==============spring cache redis==============
spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database=0
spring.redis.password=

这里只是列举了几个主要的配置，其他的可以查看RedisProperties类，里面有redis的配置属性，还有它的默认值。

添加RedisTemplate的bean

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        //使用FastJsonRedisSerializer
//        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);

        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        //开启事务支持
        template.setEnableTransactionSupport(true);

        template.afterPropertiesSet();
        return template;
    }

即使不添加redisTemplate的bean也可以直接注入。SpringBoot会为我们配置默认的RedisTemplate，SpringBoot默认的RedisTemplate使用的是JdkSerializationRedisSerializer，JdkSerializationRedisSerializer使用的是二进制形式存储数据，不便于观察，所以在这里改为使用Jackson2JsonRedisSerializer，当然还可以是用第三方FastJsonRedisSerializer。

public class RedisUserServiceImpl implements RedisUserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;

//    @Resource(name = "redisTemplate")
//    ValueOperations<Object, Object> valOps;

    @Override

    public void saveUser(User user) {
        redisTemplate.opsForValue().set(user.getId(), user);
    }

    @Override
    public User findUserById(Long id) {
        User user = (User) redisTemplate.opsForValue().get("id");
        if (user == null) {
            user = userMapper.selectByPrimaryKey(id);
            // 将数据存入redis缓存
            redisTemplate.opsForValue().set(user.getId(), user);
//            valOps.set(user.getId(), user);
//            valOps.get(user.getId());
        }
        return user;
    }
}

在Service里面注入RedisTemplate，来操作Redis数据库。

• 使用注解的方式

注解的使用可以参照SpringBoot整合Cache缓存数据，这里只说一下cacheManager的配置。参照一下代码：

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 设置CacheManager的值序列化方式为Jackson2JsonRedisSerializer,默认就是使用StringRedisSerializer序列化key,JdkSerializationRedisSerializer序列化value
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
                Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 配置value序列化方式为Jackson2JsonRedisSerializer,key序列化方式采用默认的StringRedisSerializer
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
        // 每一类信息进行缓存配置
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        // 用户信息
        redisCacheConfigurationMap.put(RedisConstant.USER, cacheConfiguration.entryTtl(Duration.ofDays(10))
                .disableCachingNullValues().prefixKeysWith(RedisConstant.USER));

        // 初始化一个RedisCacheWriter
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
        // 设置默认超过期时间是1天(短时间的已经做了其他的处理,不会采用注解形式加入缓存)
        defaultCacheConfig.entryTtl(Duration.ofDays(1));
        // 初始化RedisCacheManager
        RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig,
                redisCacheConfigurationMap);
//        RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
        return cacheManager;
    }

cacheManager不是必须配置的，之前也说了SpringBoot默认使用的是JdkSerializationRedisSerializer，存入的是二进制数据，不便于查看，所以配置了cacheManager。

RedisCacheManager一共有6个构造方法，文中用到这个这个构造方法区别在于redisCacheConfigurationMap是给指定的缓存名的数据缓存做配置，defaultCacheConfig是缓存的默认配置。除过指定名字之外的其他缓存使用默认配置也就是defaultCacheConfig。

RedisCacheConfiguration的配置有很多文中是配置了序列化方式，缓存过期时间，禁止缓存空数据，key前缀，其他配置可以查看RedisCacheConfiguration类。

贴出其他代码

public class RedisConstant {
    /**
     * 存储用户信息前缀
     */
    public static final String USER = "user:";

    public static final String LOG = "log:";
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;


    @Override
    @Cacheable(value = RedisConstant.USER, key = "#user.id",unless = "#result==null")
    public User getUserById(User user) {
        return userMapper.selectByPrimaryKey(user.getId());
    }

    @Override
    @CachePut(value = RedisConstant.USER, key = "#user.id", condition = "#result!=null")
    public User save(User user) {
        userMapper.insertSelective(user);
        return user;
    }

    @Override
    @CacheEvict(value = "people")
    public void deleteById(User user) {
        userMapper.deleteByPrimaryKey(user.getId());
    }

}

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogMapper logMapper;

    @Override
    @Cacheable(value = RedisConstant.LOG, key = "#logId", unless = "#result==null")
    public Log findLogById(Long logId) {
        return logMapper.selectByPrimaryKey(logId);
    }
}