Spring Cache

Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术。并支持使用JCache（JSR-107）注解简化开发。

Cache接口为缓存的组件规范定义，包含缓存的各种操作集合。例如Cache接口下Spring 提供了各种xxxCache 的实现； 如RedisCache ， EhCacheCache ,ConcurrentMapCache等

每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。

Spring Boot集成Cache缓存

引入依赖

	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>

创建ehcache.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
	updateCheck="false">
	<diskStore path="java.io.tmpdir/Tmp_EhCache" />

	<!-- 默认配置 -->
	<defaultCache maxElementsInMemory="5000" eternal="false"
		timeToIdleSeconds="120" timeToLiveSeconds="120"
		memoryStoreEvictionPolicy="LRU" overflowToDisk="false" />

	<cache name="baseCache" maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="120" maxElementsOnDisk="100000"
		   overflowToDisk="true" diskSpoolBufferSizeMB="50" 
		   maxEntriesLocalDisk="6" diskPersistent="false" 
		   diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU" clearOnFlush="true"/>
</ehcache>

配置信息

	<!--
	name:缓存名称
	maxElementsInMemory：缓存最大个数
	eternal:对象是否永久有效，一但设置了，timeout将不起作用
	timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大
	timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大
	overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中
	diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区
	maxElementsOnDisk：硬盘最大缓存个数
	diskPersistent：是否缓存在虚拟机重启后数据任然存在，默认false
	diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒
	memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）
	clearOnFlush：内存数量最大时是否清除
	-->

开启缓存

SpringBoot的启动类添加： @EnableCaching注解开启缓存功能

使用缓存

@CacheConfig(cacheNames = "baseCache")
public interface UserMapper {
	@Cacheable
	@Select(" select * from user where id = #{id} ")
	public User selectUser(@Param("id") long id);
}

清除缓存

@Autowired
private CacheManager cacheManager;

cacheManager.getCache("baseCache").clear();

Spring Boot集成Redis

1.添加依赖

<!-- 配置使用redis启动器 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.配置redis连接信息

  # Redis
  redis:
    port: 6379  # Redis服务器连接端口
    host: 127.0.0.1 # Redis服务器地址
    timeout: 3000 # 连接超时时间（毫秒）
    password: 123456  # Redis服务器连接密码（默认为空）
    database: 5 # Redis数据库索引（默认为0）
    # jedis连接池
#    jedis:
#      pool:
#        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
#        max-idle: 8 # 连接池中的最大空闲连接
#        min-idle: 0 # 连接池中的最小空闲连接
#        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
    # lettuce连接池 ，推荐使用
    lettuce:
      pool:
        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
        max-idle: 8 # 连接池中的最大空闲连接
        min-idle: 0 # 连接池中的最小空闲连接
        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）

3.执行测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application .class)
public class RedisTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 保存
     *
     * @param key
     * @param value
     */
    public void setStr(String key, String value) {
        setStr(key, value, null);
    }

    /**
     * 保存同时设置过期时间
     *
     * @param key
     * @param value
     * @param time
     */
    public void setStr(String key, String value, Long time) {
        stringRedisTemplate.opsForValue().set(key, value);
        if (time != null) {
            stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    }

    /**
     * 获取
     *
     * @param key
     * @return
     */
    public String getKey(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除
     *
     * @param key
     */
    public void delKey(String key) {
        stringRedisTemplate.delete(key);
    }

    @Test
    public void test() {
        this.setStr("test", "hello");
        System.out.println(this.getKey("test"));
        System.out.println("----------------");

        this.setStr("test", "hello", 5L);
        System.out.println(this.getKey("test"));
        System.out.println("----------------");

        this.delKey("test");
        System.out.println(this.getKey("test"));
    }
}

4.自定义序列化类

redisTemplate序列化默认使用的jdkSerializeable, 存储二进制字节码, Redis客户端工具使用时，看到的是二进制，不便于阅读，所以自定义序列化类。

@Configuration
public class RedisTemplateConfiguration {


    /**
     * 自定义序列化类
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置key和value的序列化规则
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());

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

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}