上篇文章介绍了各种缓存技术，前端技术等来提高web程序的性能，这篇文章主要介绍SpringBoot中的缓存技术来提高系统性能。在使用SpringBoot缓存技术使用比较简单，但也需要注意一些问题。本节先介绍 Spring Boot 自带的in-memory缓存，然后再介绍 EhCahce 和 Redis 缓存。一般in-memory缓存仅单体应用或者是一个小微系统，不适合用在分布式环境下。通常应用为分布式应用时，则需要集成 EhCache、Redis 等分布式缓存管理器。
为什么使用Spring Cache
没有SpringBoot之前，我们集成缓存，一般都是通过根据缓存技术提供的接口来实现缓存，每种缓存都需要单独实现，需要考虑线程安全，缓存过期，缓存高可用等等，不是一件简单的事。而Spring Cache 对 Cahce 进行了抽象，提供了 @Cacheable、@CachePut、@CacheEvict 等注解。Spring Boot 应用基于 Spring Cache，既提供了基于内存实现的缓存管理器，可以用于单体应用系统，也集成了 EhCache、Redis 等缓存服务器，可以用于大型系统或者分布式系统，因此可以根据自己的项目需求选择合理的缓存方案。关键它可以通过注解配置方式低侵入的给原有Spring应用增加缓存功能，提高数据访问性能。在Spring Boot中对于缓存的支持，提供了一系列的自动化配置，使我们可以非常方便的使用缓存。我们也可以轻易的在不同缓存方案中切换，无需修改任何代码。
Spring cache核心组件
Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。定义摘抄如下，从图上就能很好的理解它们之间的关系。
CachingProvider: Create, configure, acquire, manage, and control multiple CacheManager
CacheManager: Create, configure, acquire, manage, and control multiple uniquely named Caches that exist within the context of CacheManager.A CacheManager corresponds to only one CachingProvider
Cache:is managed by Cache Manager, which manages the life cycle of Cache. Cache exists in the context of Cache Manager and is a map-like data structure that temporarily stores key-indexed values.A Cache is owned by only one CacheManager
Entry:is a key-value pair stored in a Cache
Expiry: Each entry stored in a Cache has a defined expiration date.Once this time is exceeded, the entries will automatically expire, after which they will not be accessible, updated, and deleted.Cache validity can be set through ExpiryPolicy。
SpringBoot Cache常见注解
@CacheConfig，在类上设置当前缓存的一些公共设置，比如缓存名称；
@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface CacheConfig {String[] cacheNames() default {};String keyGenerator() default "";String cacheManager() default "";String cacheResolver() default "";}
@Cacheable，作用在方法上，触发缓存读取操作。表明该方法的结果是可以缓存的，如果缓存存在，则目标方法不会被调用，直接取出缓存。可以为方法声明多个缓存，如果至少有一个缓存有缓存项，则其缓存项将被返回；
@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface Cacheable {@AliasFor("cacheNames")String[] value() default {};@AliasFor("value")String[] cacheNames() default {};String key() default "";String keyGenerator() default "";String cacheManager() default "";String cacheResolver() default "";String condition() default "";String unless() default "";boolean sync() default false;}
@CacheEvict，作用在方法上，触发缓存失效操作，删除缓存项或者清空缓存；
@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface CacheEvict {@AliasFor("cacheNames")String[] value() default {};@AliasFor("value")String[] cacheNames() default {};String key() default "";String keyGenerator() default "";String cacheManager() default "";String cacheResolver() default "";String condition() default "";boolean allEntries() default false;boolean beforeInvocation() default false;}
@CachePut，作用在方法上，触发缓存更新操作，添加该注解后总是会执行方法体，并且使用返回的结果更新缓存，同 Cacheable 一样，支持 condition、unless、key 选项，也支持 KeyGenerator；
@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface CachePut {@AliasFor("cacheNames")String[] value() default {};@AliasFor("value")String[] cacheNames() default {};String key() default "";String keyGenerator() default "";String cacheManager() default "";String cacheResolver() default "";String condition() default "";String unless() default "";}
@Caching，作用在方法上，可以定义复杂的cache规则。
@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface Caching {Cacheable[] cacheable() default {};CachePut[] put() default {};CacheEvict[] evict() default {};}
使用SpringBoot Cache
Springs Caching Service是一个抽象，不是具体实现，需要用提供具体的cache provider来实现它，SpringBoot支持以下Cache Provider,改变cache provider，不会对现有代码做任何修改，只需要修改配置。
Ehcache 3（本文会介绍）HazelcastInfinispanCouchbaseRedis（本文会介绍）CaffeineSimple cache（本文会介绍）
1）开启缓存功能
定义一个CacheConfig配置类，加上@Configuration，@EnableCaching注解，也可以在启动类上添加 @EnableCaching注解。但建议增加一个configuration类，因为有些配置可以在此类中实现，比如key generator等。
@Configuration@EnableCachingpublic class CacheConfig {}
2）增加依赖
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency>
3）指定cache type
可以在application.properties里指定cache type,当有多个provider同时存在时，需要指定cache type，格式为
spring.cache.type=simple这是一个enum类型，支持的值为
CAFFEINECOUCHBASEEHCACHEHAZELCASTINFINISPANJCACHENONEREDISSIMPLE
大部分时候不需要指定cache type，SpringBoot会根据POM中引入的provider和配置来装配正确的缓存，除非引入了多个provider，这时需要指定cache type。这是一个容易犯错误的坑，我在项目中就犯过类似错误，因为之前项目中已经使用了Redis，后来我需要使用缓存，但我没有指定cache type，SpringBoot就会使用Redis作为缓存，但由于需要被缓存的数据没有实现序列化，所以导致没法存入到redis中，缓存功能就不生效，后来调试cache源码才发现这个坑，因此，将cache type设为simple，就可以按照Simple缓存方式工作了，不指定就会按照Redis缓存方式，这时类就需要实现序列化。
Simple cache
Spring Boot 自带了基于 ConcurrentHashMap 的 Simple 缓存管理器，使用非常简单，只需要添加spring-boot-starter-cache依赖项。被缓存的对象不需要实现序列化。
CaculationService.java
@Service@slf4jpublic class CalculationService {@Cacheable(value = "multiplyCache", key = "{#factor1, #factor2}")public double multiply(int factor1, int factor2) {log.info("Multiply {} with {}", factor1, factor2);return factor1 * factor2;}@CacheEvict(cacheNames = {"multiplyCache"}, allEntries = true)public void evictCache() {log.info("Evict all cache entries...");}}
上述是一个简单的calculation实例,第一次访问时会缓存计算结果，后面当相同的请求时直接从内存缓存中获取。使用的key是由参数#factor1,#factor2组成，也可以在config里自定义key generator。可以在@Cacheable中指定cache name，在@CacheEvict中指定多个cache清空，也可以根据清空指定的key。除了使用这些注解操作缓存外，我们也可以使用CacheManager来操作缓存，比如删除缓存，可以按照下面方式实现，同时我们结合Spring定时器来实现定时删除缓存。
@AutoWiredprivate CacheManager cacheManager;public void deleteCache() {Cache cache = cacheManager.getCache("multiplyCache");if(null != cache){cache.clear();}}@Scheduled(fixedRate = 6000)public void evictAllcachesAtIntervals() {deleteCache();}
CalculationRestController.java
@RestController@RequestMapping("/rest/calculate")public class CalculationRestController {private final CalculationService calculationService;@Autowiredpublic CalculationRestController(CalculationService calculationService) {this.calculationService = calculationService;}@GetMapping(path = "/multiply", produces = MediaType.APPLICATION_JSON_VALUE)public ResponseEntity<Double> multiply(@RequestParam int factor1, @RequestParam int factor2) {double result = calculationService.multiply(factor1, factor2);return ResponseEntity.ok(result);}@GetMapping(path = "/evict", produces = MediaType.APPLICATION_JSON_VALUE)public ResponseEntity<String> evictCache() {calculationService.evictCache();return ResponseEntity.ok("Cache successfully evicted!");}}
EHcache
1）增加依赖
<!--for ehcache provoder--><dependency><groupId>javax.cache</groupId><artifactId>cache-api</artifactId></dependency><dependency><groupId>org.ehcache</groupId><artifactId>ehcache</artifactId></dependency>
Spring boot 2之前支持ehcache 2.x，需要引入包net.sf.ehcache。新版本的Spring boot支持ehcache 3.x，需要引入包org.ehcache package。
2）启动缓存
我们也可以自定义key generator，如下，
@Configuration@EnableCachingpublic class EhcacheConfig {@Beanpublic KeyGenerator multiplyKeyGenerator() {return (Object target, Method method, Object... params) -> method.getName() + "_" + Arrays.toString(params);}}
StudentService.java
@Service@CacheConfig(cacheNames = "studentCache")public class StudentService {private static AtomicLong ID_CREATOR = new AtomicLong(0);private Map<Long, Student> students;public StudentService() {students = new ConcurrentHashMap<>();students.put(ID_CREATOR.incrementAndGet(), new Student(ID_CREATOR.get(), "John", "Doe", "Computer Science"));students.put(ID_CREATOR.incrementAndGet(), new Student(ID_CREATOR.get(), "Maria", "Thomson", "Information Systems"));students.put(ID_CREATOR.incrementAndGet(), new Student(ID_CREATOR.get(), "Peter", "Simpson", "Mathematics"));}@Cacheable(keyGenerator = "multiplyKeyGenerator")public Optional<Student> find(Long id) {LOG.info("Finding student with id '{}'", id);return Optional.ofNullable(students.get(id));}@CachePut(key = "#result.id")public Student create(String firstName, String lastName, String courseOfStudies) {LOG.info("Creating student with firstName={}, lastName={} and courseOfStudies={}", firstName, lastName, courseOfStudies);long newId = ID_CREATOR.incrementAndGet();Student newStudent = new Student(newId, firstName, lastName, courseOfStudies);students.put(newId, newStudent);return newStudent;}}
Student.java
@RequiredArgsConstructor@Getter@ToStringpublic class Student implements Serializable {private static final long serialVersionUID = 1L;private final long id;private final String firstName;private final String lastName;private final String courseOfStudies;}
注意，Student一定需要实现Serializable，否则缓存无法工作。
3）配置cache
ehcache.xml
<configxmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'xmlns='http://www.ehcache.org/v3'xsi:schemaLocation="http://www.ehcache.org/v3http://www.ehcache.org/schema/ehcache-core-3.7.xsd"><!-- Persistent cache directory --><persistence directory="spring-boot-ehcache/cache" /><!-- Default cache template --><cache-template name="default"><expiry><ttl unit="seconds">30</ttl></expiry><listeners><listener><class>com.example.ehcache.config.CacheLogger</class><event-firing-mode>ASYNCHRONOUS</event-firing-mode><event-ordering-mode>UNORDERED</event-ordering-mode><events-to-fire-on>CREATED</events-to-fire-on><events-to-fire-on>EXPIRED</events-to-fire-on><events-to-fire-on>EVICTED</events-to-fire-on></listener></listeners><resources><heap>1000</heap><offheap unit="MB">10</offheap><disk persistent="true" unit="MB">20</disk></resources></cache-template><cache alias="multiplyCache" uses-template="default"><key-type>java.lang.String</key-type><value-type>java.lang.Double</value-type></cache><cache alias="studentCache" uses-template="default"><key-type>java.lang.String</key-type><value-type>com.example.model.Student</value-type></cache></config>
4）实现Cache Event listener
@slf4j public class CacheLogger implements CacheEventListener<Object, Object> {@Overridepublic void onEvent(CacheEvent<?, ?> cacheEvent) {LOG.info("Key: {} | EventType: {} | Old value: {} | New value: {}",cacheEvent.getKey(), cacheEvent.getType(), cacheEvent.getOldValue(), cacheEvent.getNewValue());}}
在实例中，首先定义了一个模板，然后每个缓存可以基于此模板来设置每个缓存的key type和value type。支持Java的基本类型和类。listener可以监控cache的事件。
5）设置properties
spring.cache.jcache.config=classpath:ehcache.xmlRedis cache
Redis cache和EHCache类似，只需要引入redis provider和redis的相应配置即可，缓存类也必须实现序列化。
写在最后
使用SpringBoot的Cache使得可以做到代码无侵入的实现缓存，给程序带来很大的性能提升。对数据变化不频繁，请求频率比较高的应用场景是比较适合使用缓存技术。因此，可以根据数据模型，业务场景来设计合适的缓存策略。在使用缓存过程中，需要注意缓存类都需要实现序列化，除了内存缓存外，否则虽然业务功能正常，但缓存功能失效。另外，也需要注意项目中，是不是有多个cache provider，这时最好指定缓存类型。此外，也需要考虑缓存失效和过期时间设置，保证缓存及时更新，避免一些因为缓存问题而导致的Bug。
