（二十）Spring Boot 缓存【Redis 集群缓存】

一、搭建 Red is 集群

        参考连接：（十五）Spring Boot NoSQL【Redis集群环境搭建】

二、配置缓存

        当 Redis 集群搭建成功，并且能够从 Spring Boot 项目中访问 Redis 集群后，只需要进行简单Redis 缓存配置即可，代码如下：

import org.springframework.beans.factory.annotation.Autowired;
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.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class RedisCacheConfig {
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public RedisCacheManager redisCacheManager(){
        Map<String , RedisCacheConfiguration> configMap = new HashMap<>();
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .prefixKeysWith("sang:")
                //禁止缓存空数据
                .disableCachingNullValues()
                //设置缓存时间
                .entryTtl(Duration.ofMinutes(30));
        //将配置和缓存空间进行关联
        configMap.put("c1",redisCacheConfiguration);
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
        return new RedisCacheManager(redisCacheWriter,RedisCacheConfiguration.defaultCacheConfig(),configMap);
    }
}

代码解释:
• 在配置 Redis集群时，已经向 Spring客器中注册了一个 JedisConnectionfactory 的实例，这里将之注入到 RedisCacheConfig 配置文件中备用( RedisConnectionFactory 是 JedisConnectionfactory 的父类)。
• 在 RedisCacheConfig 中提供 RedisCacheManager 的实例，该实例的构建需要三个参数，第一个参数是一个 cacheWriter，直接通过 nonLockingRedisCacheWriter 方法构造出来即可；第二个参数是默认的缓存配置；第三个参数是提前定义好的缓存配置。
• RedisCachemanager 构造方法中第三个参数是一个提前定义好的缓存参数，它是一个Map类型的参数，该Map中的key就是指缓存名字，value就是该名称的缓存所对应的缓存配置，例如key的前缀、缓存过期时间等，若缓存注解中使用的缓存名称不存在于Map中，则使用RedisCacheManager 构造方法中第二个参数所定义的缓存策略进行数据缓存。例如如下两个缓存配置:

@Cacheable(value =”c1” )
@Cacheable(value =”c2” )

第1行的注解中，c1存在于 configMap 集合中，因此使用的缓存策略是 configmap 集合中 c1 所对应的缓存策略，c2不存在于 configMap集合中，因此使用的缓存策略是默认的缓存策略。
• 这次测试中默认缓存策略通过调用 RediscacheConfiguration中的 defaultCacheConfig方法获取,该方法部分源码如下:

由这一段源码可以看到，默认的缓存过期时间为0，即永不过期；第二个参数true表示允许存储null，第三个参数true表示开启key的前缀，第四个参数表示key的默认前缀是“缓存名::”，接下来两个参数表示key和vaue的序列化方式，最后一个参数则是一个类型转换器
• 该测试使用的配置信息是一个自定义的缓存配置，设置了key的前缀为“sang:”，禁止缓存一个null，设置缓存的过期时间为30分钟。

二、使用缓存

缓存配置完成后，接下来首先在项目启动类中通过＠EnableCaching 注解开启缓存 ，代码如下：

@SpringBootApplication
@EnableCaching
public class RedisCacheColonyApplication {

    public static void main(String[] args) {
        SpringApplication.run(RedisCacheColonyApplication.class, args);
    }
}

然后创建一 BookDao 使用缓存，代码如下：

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Repository;

@Repository
public class BookDao {
    @Cacheable(value = "c1")
    public String getBookById(Integer id) {
        System.out.println("getBookById");
        return "这本书是三国演义";
    }

    @CachePut(value = "c1")
    public String updateBookById(Integer id) {
        System.out.println("updateBookById");
        return "这是全新的三国演义";
    }

    @CacheEvict(value = "c1")
    public void deleteBookById(Integer id) {
        System.out.println("deleteBookById");
    }

    @Cacheable(value = "c2")
    public String getBookById2(Integer id) {
        System.out.println("getBookById2");
        return "这本书是红楼梦";
    }
}

最后创建单元测试，代码如下：

import com.weigang.redis.cache.colony.dao.BookDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisCacheColonyApplicationTest {

    @Autowired
    BookDao bookDao;

    @Test
    public void contextLoads() {
        bookDao.getBookById(100);
        String book1 = bookDao.getBookById(100);
        System.out.println("book1==>"+book1);
        bookDao.updateBookById(100);
        String book2 = bookDao.getBookById(100);
        System.out.println("book2==>"+book2);
        bookDao.deleteBookById(100);
        bookDao.getBookById(100);
        bookDao.getBookById2(99);
    }
}

单元测试执行结果如下图：

        由单元测试可以看到，一开始做了两次査询，但是查询方法只调用了一次，因为第二次使用了缓存，接下来执行了更新，当更新成功后再去查询，此时缓存也已更新成功；接下来执行了删除，删除成功后再去执行査询，查询方法又被调用，说明缓存也已经被删除了；最后查询了一个id为99的记录，这次使用的是默认缓存配置。在 Redis服务器上也可以看到缓存结果，如图所示。

        id为100的记录使用的缓存名为c1，因此key的前缀是“sang:”，这是上文配置的，过期时间还剩152秒(上文配置的过期时间是30分钟)；而id为99的记录使用的缓存名称为c2，因此使用了默认的缓存配置，默认的前缀为“缓存名∷”，即“c2∷”,默认的过期时间是永不过期。