1.简介

本篇文章是阅读官方文档的一个随手笔记。介绍了SpringBoot官方文档中关于Caching的介绍。说到缓存我们首先想到的就是Redis，但是缓存并不局限于Redis一种。于是SpringFramework 提供了一种通用的注解方式，无须关心其具体的缓存实现。

2.SpringBoot默认的Cache实现

SpringBoot提供了缓存的开箱即用特性，只需要引入spring-boot-starter-cache依赖即可，默认的实现就是用concurrent maps，如果你想去选择缓存的具体实现的话，有两种方式可以选择

  • 显式的配置

  • 通过配置文件中sspring.cache.type配置项来指定

    3.各种缓存的使用方式（简单）

    这里我仅仅整合Redis和EhCache2.X，因为这两个缓存听说过，其他的都没用过。

    3.1EhCache2.X

    1.编写EhCache的Xml配置文件
    略
    2.导入EhCache的依赖

    1.    <dependency>
    2.        <groupId>net.sf.ehcache</groupId>
    3.        <artifactId>ehcache</artifactId>
    4.    </dependency>
    6.    <dependency>
    7.        <groupId>org.springframework.boot</groupId>
    8.        <artifactId>spring-boot-starter-cache</artifactId>
    9.    </dependency>

3.配置EhCache

  1. spring:
  2.     cache:
  3.         type: ehcache
  4.         ehcache:
  5.             config: "classpath:ehcache.xml"

3.2Redis

1.引入redis依赖

  1.         <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-data-redis</artifactId>
  4.         </dependency>

这个不需要引入spring-boot-starter-cache
2.配置文件

  1. spring:
  2.     cache:
  3.         type: redis
  4.         xxx
  5.     redis:
  6.         host: 127.0.0.1
  7.         port: 6379

4.通过代码配置

其他缓存的配置方式与上面的配置方式一致。下面来说一下使用代码配置缓存。
在官方文档中说明了，通过上面简单写配置文件这种方式配置后，如果想对其配置进行修改。可以用以下方式：

  1. import java.time.Duration;
  3. import org.springframework.boot.autoconfigure.cache.RedisCacheManagerBuilderCustomizer;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  8. @Configuration(proxyBeanMethods = false)
  9. public class MyRedisCacheManagerConfiguration {
  11.     @Bean
  12.     public RedisCacheManagerBuilderCustomizer myRedisCacheManagerBuilderCustomizer() {
  13.         return (builder) -> builder
  14.                 .withCacheConfiguration("cache1", RedisCacheConfiguration
  15.                         .defaultCacheConfig().entryTtl(Duration.ofSeconds(10)))
  16.                 .withCacheConfiguration("cache2", RedisCacheConfiguration
  17.                         .defaultCacheConfig().entryTtl(Duration.ofMinutes(1)));
  19.     }
  21. }

SpringBoot常用套路，你如果定义了CacheManage的话，就用你的。比如：

  1.     @Bean
  2.     public CacheManager cacheManager(RedisConnectionFactory factory) {
  3.         RedisSerializer<String> redisSerializer = new StringRedisSerializer();
  4.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  5. //解决查询缓存转换异常的问题
  6.         ObjectMapper om = new ObjectMapper();
  7.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  8.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  9.         jackson2JsonRedisSerializer.setObjectMapper(om);
  10. // 配置序列化（解决乱码的问题）,过期时间600秒
  11.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
  12.                 .entryTtl(Duration.ofSeconds(600))
  13.                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
  14.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
  15.                 .disableCachingNullValues();
  16.         RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
  17.                 .cacheDefaults(config)
  18.                 .build();
  19.         return cacheManager;
  20.     }

这样的方式，你都不需要指定如下配置：

  1. spring:
  2.     cache:
  3.         type: redis
  4.         xxx

只需要指定redis配置即可。