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

声明式缓存

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.  
5. <parent>
6. <groupId>org.springframework.boot</groupId>
7. <artifactId>spring-boot-starter-parent</artifactId>
8. <version>1.3.3.RELEASE</version>
9. </parent>
10.  
11. <groupId>com.lianggzone.demo</groupId>
12. <artifactId>springboot-action-cache</artifactId>
13. <version>0.1</version>
14. <packaging>jar</packaging>
15. <name>springboot-action-cache</name>
16.  
17. <dependencies>
18. <dependency>
19. <groupId>org.springframework.boot</groupId>
20. <artifactId>spring-boot-starter</artifactId>
21. </dependency>
22. <dependency>
23. <groupId>org.springframework.boot</groupId>
24. <artifactId>spring-boot-starter-web</artifactId>
25. </dependency>
26.  
27. <dependency>
28. <groupId>org.springframework.boot</groupId>
29. <artifactId>spring-boot-starter-cache</artifactId>
30. </dependency>
31. </dependencies>
32. <build>
33. <plugins>
34. <plugin>
35. <groupId>org.apache.maven.plugins</groupId>
36. <artifactId>maven-compiler-plugin</artifactId>
37. <configuration>
38. <defaultLibBundleDir>lib</defaultLibBundleDir>
39. <source>1.7</source>
40. <target>1.7</target>
41. <encoding>UTF-8</encoding>
42. </configuration>
43. </plugin>
44. <plugin>
45. <groupId>org.apache.maven.plugins</groupId>
46. <artifactId>maven-resources-plugin</artifactId>
47. <configuration>
48. <encoding>UTF-8</encoding>
49. <useDefaultDelimiters>false</useDefaultDelimiters>
50. <escapeString>\</escapeString>
51. <delimiters>
52. <delimiter>${*}</delimiter>
53. </delimiters>
54. </configuration>
55. </plugin>
56. <plugin>
57. <groupId>org.springframework.boot</groupId>
58. <artifactId>spring-boot-maven-plugin</artifactId>
59. </plugin>
60. </plugins>
61. </build>
62. </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.  
4. }

首先，我们先来讲解下 @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. */
10. @RequestMapping(value = "", method = RequestMethod.GET)
11. public String getByCache() {
12. Long startTime = System.currentTimeMillis();
13. long timestamp = this.cacheService.getByCache();
14. Long endTime = System.currentTimeMillis();
15. System.out.println("耗时: " + (endTime - startTime));
16. return timestamp+"";
17. }
18.  
19. /**
20. * 保存方法
21. */
22. @RequestMapping(value = "", method = RequestMethod.POST)
23. public void save() {
24. this.cacheService.save();
25. }
26.  
27. /**
28. * 删除方法
29. */
30. @RequestMapping(value = "", method = RequestMethod.DELETE)
31. public void delete() {
32. this.cacheService.delete();
33. }
34. }

运行

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

课后作业

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

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

扩展阅读

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

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

源代码

相关示例完整代码： springboot-action

(完)

Spring Boot 揭秘与实战（二） 数据缓存篇 - 快速入门