为了提高性能，减少数据库的压力，使用缓存是非常好的手段之一。本文，讲解 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所示，实际客户端获取的是一个代理的引用，在调用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. <projectxmlns="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. publicclassCacheConfiguration{}

服务层

创建一个服务类

1. @Service("concurrenmapcache.cacheService")
2. publicclassCacheService{
3.  
4. }

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

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

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

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

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

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

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

控制层

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

1. @RestController("concurrenmapcache.cacheController")
2. @RequestMapping(value ="/concurrenmapcache/cache")
3. publicclassCacheController{
4. @Autowired
5. privateCacheService cacheService;
6.  
7. /**
8. * 查询方法
9. */
10. @RequestMapping(value ="", method =RequestMethod.GET)
11. publicString 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. publicvoid save(){
24. this.cacheService.save();
25. }
26.  
27. /**
28. * 删除方法
29. */
30. @RequestMapping(value ="", method =RequestMethod.DELETE)
31. publicvoiddelete(){
32. this.cacheService.delete();
33. }
34. }

运行

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

课后作业

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

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

扩展阅读

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

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

源代码

# 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));

    @Bean
    public CacheManagerCustomizer<RedisCacheManager> cacheManagerCustomizer() {
        return new CacheManagerCustomizer<RedisCacheManager>() {
            @Override
            public 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-name
                expires.put("myBiggerCache", 24L*60*60);
                cacheManager.setExpires(expires);  // expire per cache

                cacheManager.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 {
    @Bean
    public KeyGenerator customKeyGenerator() {
        return new KeyGenerator() {
          @Override
          public 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));
    }   
  //省略
}