为了提高性能，减少数据库的压力，使用缓存是非常好的手段之一。本文，讲解 Spring Boot 如何集成缓存管理。

Spring注解缓存

Spring 3.1之后，引入了注解缓存技术，其本质上不是一个具体的缓存实现方案，而是一个对缓存使用的抽象，通过在既有代码中添加少量自定义的各种annotation，即能够达到使用缓存对象和缓存方法的返回对象的效果。Spring的缓存技术具备相当的灵活性，不仅能够使用SpEL（Spring Expression Language）来定义缓存的key和各种condition，还提供开箱即用的缓存临时存储方案，也支持和主流的专业缓存集成。其特点总结如下：

• 少量的配置annotation注释即可使得既有代码支持缓存；
• 支持开箱即用，不用安装和部署额外的第三方组件即可使用缓存；
• 支持Spring Express Language（SpEL），能使用对象的任何属性或者方法来定义缓存的key和使用规则条件；
• 支持自定义key和自定义缓存管理者，具有相当的灵活性和可扩展性。

和Spring的事务管理类似，Spring Cache的关键原理就是Spring AOP，通过Spring AOP实现了在方法调用前、调用后获取方法的入参和返回值，进而实现了缓存的逻辑。而Spring Cache利用了Spring AOP的动态代理技术，即当客户端尝试调用pojo的foo()方法的时候，给它的不是pojo自身的引用，而是一个动态生成的代理类。

图12 Spring动态代理调用图

如图12所示，实际客户端获取的是一个代理的引用，在调用foo()方法的时候，会首先调用proxy的foo()方法，这个时候proxy可以整体控制实际的pojo.foo()方法的入参和返回值，比如缓存结果，比如直接略过执行实际的foo()方法等，都是可以轻松做到的。Spring Cache主要使用三个注释标签，即@Cacheable、@CachePut和@CacheEvict，主要针对方法上注解使用，部分场景也可以直接类上注解使用，当在类上使用时，该类所有方法都将受影响。我们总结一下其作用和配置方法，如表1所示。

表1

可扩展支持：Spring注解cache能够满足一般应用对缓存的需求，但随着应用服务的复杂化，大并发高可用性能要求下，需要进行一定的扩展，这时对其自身集成的缓存方案可能不太适用，该怎么办？Spring预先有考虑到这点，那么怎样利用Spring提供的扩展点实现我们自己的缓存，且在不改变原来已有代码的情况下进行扩展？是否在方法执行前就清空，默认为false，如果指定为true，则在方法还没有执行的时候就清空缓存，默认情况下，如果方法执行抛出异常，则不会清空缓存。

这基本能够满足一般应用对缓存的需求，但现实总是很复杂，当你的用户量上去或者性能跟不上，总需要进行扩展，这个时候你或许对其提供的内存缓存不满意了，因为其不支持高可用性，也不具备持久化数据能力，这个时候，你就需要自定义你的缓存方案了，还好，Spring也想到了这一点。

我们先不考虑如何持久化缓存，毕竟这种第三方的实现方案很多，我们要考虑的是，怎么利用Spring提供的扩展点实现我们自己的缓存，且在不改原来已有代码的情况下进行扩展。这需要简单的三步骤，首先需要提供一个CacheManager接口的实现（继承至AbstractCacheManager），管理自身的cache实例；其次，实现自己的cache实例MyCache(继承至Cache)，在这里面引入我们需要的第三方cache或自定义cache；最后就是对配置项进行声明，将MyCache实例注入CacheManager进行统一管理。

声明式缓存

Spring 定义 CacheManager 和 Cache 接口用来统一不同的缓存技术。例如 JCache、 EhCache、 Hazelcast、 Guava、 Redis 等。在使用 Spring 集成 Cache 的时候，我们需要注册实现的 CacheManager 的 Bean。

Spring Boot默认集成CacheManager

Spring Boot 为我们自动配置了多个 CacheManager 的实现。

Spring Boot 为我们自动配置了 JcacheCacheConfiguration、 EhCacheCacheConfiguration、HazelcastCacheConfiguration、GuavaCacheConfiguration、RedisCacheConfiguration、SimpleCacheConfiguration 等。

默认的 ConcurrenMapCacheManager

Spring 从 Spring3.1 开始基于 java.util.concurrent.ConcurrentHashMap 实现的缓存管理器。所以， Spring Boot 默认使用 ConcurrentMapCacheManager 作为缓存技术。

以下是我们不引入其他缓存依赖情况下，控制台打印的日志信息。

1. Bean 'cacheManager' of type [class org.springframework.cache.concurrent.ConcurrentMapCacheManager]

实战演练

Maven 依赖

首先，我们先创建一个 POM 文件。

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3. <modelVersion>4.0.0</modelVersion>
4. <parent>
5. <groupId>org.springframework.boot</groupId>
6. <artifactId>spring-boot-starter-parent</artifactId>
7. <version>1.3.3.RELEASE</version>
8. </parent>
9. <groupId>com.lianggzone.demo</groupId>
10. <artifactId>springboot-action-cache</artifactId>
11. <version>0.1</version>
12. <packaging>jar</packaging>
13. <name>springboot-action-cache</name>
14. <dependencies>
15. <dependency>
16. <groupId>org.springframework.boot</groupId>
17. <artifactId>spring-boot-starter</artifactId>
18. </dependency>
19. <dependency>
20. <groupId>org.springframework.boot</groupId>
21. <artifactId>spring-boot-starter-web</artifactId>
22. </dependency>
23. <dependency>
24. <groupId>org.springframework.boot</groupId>
25. <artifactId>spring-boot-starter-cache</artifactId>
26. </dependency>
27. </dependencies>
28. <build>
29. <plugins>
30. <plugin>
31. <groupId>org.apache.maven.plugins</groupId>
32. <artifactId>maven-compiler-plugin</artifactId>
33. <configuration>
34. <defaultLibBundleDir>lib</defaultLibBundleDir>
35. <source>1.7</source>
36. <target>1.7</target>
37. <encoding>UTF-8</encoding>
38. </configuration>
39. </plugin>
40. <plugin>
41. <groupId>org.apache.maven.plugins</groupId>
42. <artifactId>maven-resources-plugin</artifactId>
43. <configuration>
44. <encoding>UTF-8</encoding>
45. <useDefaultDelimiters>false</useDefaultDelimiters>
46. <escapeString>\</escapeString>
47. <delimiters>
48. <delimiter>${*}</delimiter>
49. </delimiters>
50. </configuration>
51. </plugin>
52. <plugin>
53. <groupId>org.springframework.boot</groupId>
54. <artifactId>spring-boot-maven-plugin</artifactId>
55. </plugin>
56. </plugins>
57. </build>
58. </project>

其中，最核心的是添加 spring-boot-starter-cache 依赖。

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

开启缓存支持

在 Spring Boot 中使用 @EnableCaching 开启缓存支持。

1. @Configuration
2. @EnableCaching
3. public class CacheConfiguration {}

服务层

创建一个服务类

1. @Service("concurrenmapcache.cacheService")
2. public class CacheService {
3. }

首先，我们先来讲解下 @Cacheable 注解。@Cacheable 在方法执行前 Spring 先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，调用方法并将方法返回值放进缓存。有两个重要的值， value，返回的内容将存储在 value 定义的缓存的名字对象中。key，如果不指定将使用默认的 KeyGenerator 生成。

我们在查询方法上，添加 @Cacheable 注解，其中缓存名称为 concurrenmapcache。

1. @Cacheable(value = "concurrenmapcache")
2. public long getByCache() {
3. try {
4. Thread.sleep(3 * 1000);
5. } catch (InterruptedException e) {
6. e.printStackTrace();
7. }
8. return new Timestamp(System.currentTimeMillis()).getTime();
9. }

@CachePut 与 @Cacheable 类似，但是它无论什么情况，都会将方法的返回值放到缓存中, 主要用于数据新增和修改方法。

1. @CachePut(value = "concurrenmapcache")
2. public long save() {
3. long timestamp = new Timestamp(System.currentTimeMillis()).getTime();
4. System.out.println("进行缓存：" + timestamp);
5. return timestamp;
6. }

@CacheEvict 将一条或多条数据从缓存中删除, 主要用于删除方法，用来从缓存中移除相应数据。

1. @CacheEvict(value = "concurrenmapcache")
2. public void delete() {
3. System.out.println("删除缓存");
4. }

控制层

为了展现效果，我们先定义一组简单的 RESTful API 接口进行测试。

1. @RestController("concurrenmapcache.cacheController")
2. @RequestMapping(value = "/concurrenmapcache/cache")
3. public class CacheController {
4. @Autowired
5. private CacheService cacheService;
6. /**
7. * 查询方法
8. */
9. @RequestMapping(value = "", method = RequestMethod.GET)
10. public String getByCache() {
11. Long startTime = System.currentTimeMillis();
12. long timestamp = this.cacheService.getByCache();
13. Long endTime = System.currentTimeMillis();
14. System.out.println("耗时: " + (endTime - startTime));
15. return timestamp+"";
16. }
17. /**
18. * 保存方法
19. */
20. @RequestMapping(value = "", method = RequestMethod.POST)
21. public void save() {
22. this.cacheService.save();
23. }
24. /**
25. * 删除方法
26. */
27. @RequestMapping(value = "", method = RequestMethod.DELETE)
28. public void delete() {
29. this.cacheService.delete();
30. }
31. }

运行

1. @RestController
2. @EnableAutoConfiguration
3. @ComponentScan(basePackages = { "com.lianggzone.springboot" })
4. public class WebMain {
5. public static void main(String[] args) throws Exception {
6. SpringApplication.run(WebMain.class, args);
7. }
8. }

课后作业

我们分为几个场景进行测试。

• 多次调用查询接口，查看缓存信息是否变化，控制台日志是否如下？你得到的结论是什么？
  
• 调用保存接口，再调用查询接口，查看缓存信息是否变化？你得到的结论是什么？
• 调用删除接口，再调用查询接口，接口响应是否变慢了？你再看看控制台日志，你得到的结论是什么？

扩展阅读

如果想更深入理解 Spring 的 Cache 机制，这边推荐两篇不错的文章。

• Spring Cache 抽象详解
• Spring 4.1 新特性 - Spring 缓存框架增强

源代码

Spring Boot In Practice：Redis缓存实战

# REDIS (RedisProperties)
spring.redis.host=localhost # Redis server host.
spring.redis.port=6379 # Redis server port.
spring.redis.password= # Login password of the redis server.

@SpringBootApplication
@EnableCaching//开启caching
public class NewsWebServer {
//省略内容
}

//通用的RedisTemplate
@Bean
public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory) {RedisTemplate<String, Object> template = new RedisTemplate<>();template.setConnectionFactory(jedisConnectionFactory);template.setKeySerializer(new StringRedisSerializer());template.setValueSerializer(new GenericJackson2JsonRedisSerializer());//template.setHashKeySerializer(template.getKeySerializer());//template.setHashValueSerializer(template.getValueSerializer());return template;
}

redis.setValueSerializer(new Jackson2JsonRedisSerializer<Product>(Product.class));

    @Beanpublic CacheManagerCustomizer<RedisCacheManager> cacheManagerCustomizer() {return new CacheManagerCustomizer<RedisCacheManager>() {@Overridepublic void customize(RedisCacheManager cacheManager) {cacheManager.setUsePrefix(true); //事实上这是Spring Boot的默认设置，为了避免key冲突Map<String, Long> expires = new HashMap<>();expires.put("myLittleCache", 12L*60*60);  // 设置过期时间 key is cache-nameexpires.put("myBiggerCache", 24L*60*60);cacheManager.setExpires(expires);  // expire per cachecacheManager.setDefaultExpiration(24*60*60);// 默认过期时间：24 hours}};}

@Cacheable(cacheNames = "user")public User findById(long id) {return userMapper.findById(id);}

@Configuration
@EnableCaching
public class CacheConfig extends CachingConfigurerSupport {@Beanpublic KeyGenerator customKeyGenerator() {return new KeyGenerator() {@Overridepublic Object generate(Object o, Method method, Object... objects) {StringBuilder sb = new StringBuilder();sb.append(o.getClass().getName());sb.append(method.getName());for (Object obj : objects) {sb.append(obj.toString());}return sb.toString();}};}
}

@Cacheable(cacheNames = "user", key="#id.toString()") public User findById(long id) {return userMapper.findById(id);}@Cacheable(cacheNames = "user", key="'admin'") public User findAdmin() {return userMapper.findAdminUser();}@Cacheable(cacheNames = "user", key="#userId + ':address'") public List<Address> findUserAddress(long userId) {return userMapper.findUserAddress(userId);}

@Service
public class FeedService {@Resource(name="redisTemplate") private ZSetOperations<String, Feed> feedOp;public List<Feed> getFeed(int count, long maxId) {return new ArrayList<>(feedOp.reverseRangeByScore(FEED_CACHE_KEY, 0, maxId, offset, count));}   //省略
}