从零开始 Spring Boot 47：缓存

图源：简书 (jianshu.com)

Spring 提供一个简单但使用的缓存（Cache）机制，我们可以利用它来优化代码执行效率。

简单示例

老规矩，我们从一个简单示例开始：

@Service
public class FibonacciService2 {
    @Clock
    public long fibonacci(int n) {
        return doFibonacci(n);
    }

    private long doFibonacci(int n) {
        if (n <= 0) {
            throw new IllegalArgumentException("n不能小于等于0");
        }
        if (n <= 2) {
            return 1;
        }
        return this.doFibonacci(n - 2) + this.doFibonacci(n - 1);
    }
}

FibonacciService2用于计算斐波那契数列，具体采用递归方式进行计算，这很消耗时间。

• @Clock是一个自定义的注解，用一个自定义 AOP 切面来处理，以统计方法的执行时长，感兴趣的可以查看完整代码。
• 这里将实际的计算逻辑拆分为dodoFibonacci方法（与外部调用方法fibonacci分开），是因为方便统计方法执行时长，以及后期的缓存优化。

编写一个测试用例并执行：

@SpringJUnitConfig(classes = {CacheApplication.class})
@Import(ClockConfig.class)
public class FibonacciService2Tests {
    @Autowired
    FibonacciService2 fibonacciService;

    @Test
    void testFibonacci() {
        var result = fibonacciService.fibonacci(40);
        Assertions.assertEquals(102334155L, result);
    }
}

执行结果：

com.example.cache.FibonacciService2.fibonacci() is called, use 211 mills.

执行时长有211毫秒，并且随着计算位数的增加，计算时长会指数增加。

这个问题很明显可以通过缓存来进行优化，因为计算一个高位斐波那契数会涉及低位斐波那契数的重复计算，只要将这些计算缓存起来，就会很快得出一个高位斐波那契数。

要使用 Spring 缓存，需要添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

这是 Spring Boot 的方式，如果是 Spring，需要添加不同的依赖，具体可以参考这篇文章。

其次需要给配置类（@Configuration）添加上@EnableCaching注解以启用缓存功能：

@Configuration
@EnableCaching
public class WebConfig {
	// ...
}

要使用缓存，还需要添加一个CacheManager类型的 bean，默认情况下 Spring Boot 会创建一个ConcurrentMapCacheManager 作为CacheManager bean，因此一般不需要手动添加。

如果我们要修改默认创建的ConcurrentMapCacheManager，可以通过定义一个或多个CacheManagerCustomizer<ConcurrentMapCacheManager>类型的 bean 来实现：

@Configuration
@EnableCaching
public class WebConfig {
    @Bean
    CacheManagerCustomizer<ConcurrentMapCacheManager> cacheManagerCustomizer() {
        return cacheManager -> {
            cacheManager.setCacheNames(List.of("fibonacci", "cache2"));
        };
    }
	// ...
}

Spring 会获取这些CacheManagerCustomizer类型的 bean，并利用它们对CacheManager进行初始化。

这个过程由自动配置类CacheAutoConfiguration实现。

可以利用CacheManagerCustomizer设置CacheManager的（多个）缓存名称：

cacheManager.setCacheNames(List.of("fibonacci", "cache2"));

现在修改代码，给需要进行缓存的方法添加上@Cacheable注解：

@Service
public class FibonacciService3 {
	// ...
    @Cacheable("fibonacci")
    protected long doFibonacci(int n) {
        if (n <= 0) {
            throw new IllegalArgumentException("n不能小于等于0");
        }
        if (n <= 2) {
            return 1;
        }
        return this.doFibonacci(n - 2) + this.doFibonacci(n - 1);
    }
}

要注意的是，@Cacheable只能作用于public或protected方法，对于private方法是不起作用的。原因也很简单，和之前介绍过的异步执行（@Async）类似，它们都是通过AOP 实现的，而 AOP 又是通过代理（JDK或CGLIB）实现的。而这里FibonacciService3没有接口，所以显然是使用 CGLIB 代理实现（类继承），因此存在这样的限制。

• 关于 AOP 实现原理及相应的限制，可以阅读我的这篇文章。
• 如果对protected方法使用@Cacheable，idea 会有错误提示——@Cacheable只能错用于 public 方法。但实际上在通过 CGLIB 进行代理的情况下，是的确可以对protected方法缓存的，且会正常通过编译并执行。所以这大概是 idea 的一种“粗鲁”提示。

我们可以给@Cacheable注解指定一个（或多个）使用的缓存（@Cacheable("fibonacci")），这里使用的是之前通过CacheManager设置的名称为fibonacci的缓存。

现在是不是可以利用缓存提升代码执行效率了？并不会！

实际运行测试用例就会发现，时间几乎一致，并没有显著提升。

原因是这里进行缓存的方法进行了自调用，我们之前在介绍 AOP 的时候提到过，因为 Spring AOP 通过代理实现，所以默认情况下不能处理“自调用”。

具体到我们这里的示例，fibonacci自调用了doFibonacci，而doFibonacci又对自己进行了递归调用，所以实际上不会触发任何缓存。

当然，我们可以对外部调用方法fibonacci进行缓存：

@Service
public class FibonacciService3 {
    @Clock
    @Cacheable("fibonacci")
    public long fibonacci(int n) {
        return doFibonacci(n);
    }
}

但这样用处不大，仅仅可以缩减“重复获取斐波那契数”的执行效率：

@SpringJUnitConfig(classes = {CacheApplication.class})
@Import(ClockConfig.class)
public class FibonacciService3Tests {
    @Autowired
    FibonacciService3 fibonacciService;

    @Test
    void testFibonacci() {
        var result = fibonacciService.fibonacci(40);
        Assertions.assertEquals(102334155L, result);
        var result2 = fibonacciService.fibonacci(40);
        Assertions.assertEquals(result2, result);
        fibonacciService.fibonacci(39);
    }
}

执行结果：

com.example.cache.FibonacciService3.fibonacci() is called, use 214 mills.
com.example.cache.FibonacciService3.fibonacci() is called, use 0 mills.
com.example.cache.FibonacciService3.fibonacci() is called, use 126 mills.

所以，我们要想办法让“中间斐波那契数”的计算能够被缓存。通过之前的文章我们知道，可以通过手动调用代理的方式让“自调用”也能够触发 AOP 的 advice，因此我们可以修改代码：

@Service
public class FibonacciService {
    @Clock
    public long fibonacci(int n) {
        var aopProxy = (FibonacciService) AopContext.currentProxy();
        return aopProxy.doFibonacci(n);
    }

    @Cacheable("fibonacci")
    protected long doFibonacci(int n) {
        if (n <= 0) {
            throw new IllegalArgumentException("n不能小于等于0");
        }
        if (n <= 2) {
            return 1;
        }
        var aopProxy = (FibonacciService) AopContext.currentProxy();
        return aopProxy.doFibonacci(n - 2) + aopProxy.doFibonacci(n - 1);
    }
}

要使用AopContext.currentProxy()，还必须修改相关配置：

@Configuration
@EnableCaching
public class WebConfig {
	// ...
    @Bean
    static BeanFactoryPostProcessor forceAutoProxyCreatorToExposeProxy() {
        return (beanFactory) -> {
            if (beanFactory instanceof BeanDefinitionRegistry) {
                BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        };
    }
}

现在，所有对doFibonacci方法的调用都被缓存起来了，只要存在“重复调用”，就会查询缓存并直接返回结果。

可以用测试用例检查：

@SpringJUnitConfig(classes = {CacheApplication.class})
@Import(ClockConfig.class)
public class FibonacciServiceTests {
    @Autowired
    FibonacciService fibonacciService;

    @Test
    void testFibonacci() {
        var result = fibonacciService.fibonacci(40);
        Assertions.assertEquals(102334155L, result);
        var result2 = fibonacciService.fibonacci(40);
        Assertions.assertEquals(result2, result);
        fibonacciService.fibonacci(39);
    }
}

执行结果：

com.example.cache.FibonacciService.fibonacci() is called, use 4 mills.
com.example.cache.FibonacciService.fibonacci() is called, use 0 mills.
com.example.cache.FibonacciService.fibonacci() is called, use 0 mills.

只有第一次调用（fibonacci方法）花费了一点时间，但与之前相比依然可以忽略不计，而后两次的调用因为使用了缓存结果，所以几乎是不花费时间的。

多缓存

可以给@Cacheable指定多个缓存，默认情况下@Cacheable使用方法参数作为缓存的key。此时只要有一个缓存中有缓存结果，就直接返回。否则执行方法调用，并将结果缓存到所有缓存中。

我们看下面这个例子：

@Service
@Log4j2
public class UserService {
    private final Map<String, String> longNameAddresses = new HashMap<>();

    {
        longNameAddresses.put("DavisMiller", "上海南京路15号");
        longNameAddresses.put("RodriguezSmith", "马德里圣玛利亚街101号");
    }

    private final Map<String, String> shortNameAddresses = new HashMap<>();

    {
        shortNameAddresses.put("LiLei", "北京王府井115号");
        shortNameAddresses.put("XiaoMin", "纽约大十字街11号");
    }

    @Cacheable({"addresses1", "addresses2"})
    public String getAddress(@NonNull String name) {
        log.info("query name: %s".formatted(name));
        var proxy = (UserService) AopContext.currentProxy();
        if (name.length() <= 8) {
            return proxy.getShortNameAddress(name);
        }
        return proxy.getLongNameAddress(name);
    }

    @Cacheable("addresses1")
    protected String getLongNameAddress(String name) {
        log.info("query long name: %s".formatted(name));
        if (longNameAddresses.containsKey(name)) {
            return longNameAddresses.get(name);
        }
        return null;
    }

    @Cacheable("addresses2")
    protected String getShortNameAddress(String name) {
        log.info("query short name: %s".formatted(name));
        if (shortNameAddresses.containsKey(name)) {
            return shortNameAddresses.get(name);
        }
        return null;
    }
}

可能是出于效率的考量，这里将短姓名的地址和长姓名的地址分开存放，并由单独的方法（getLongNameAddress和getShortNameAddress）获取对应的地址信息。并且使用两个独立的缓存进行存储（addresses1和addresses2），方法getAddress被设计成根据姓名长度决定调用哪个方法来完成具体查询。

为了能够提高getAddress的执行效率，对其使用了缓存（@Cacheable({"addresses1", "addresses2"})），也就是说无论getLongNameAddress和getShortNameAddress哪个方法调用过（产生缓存），getAddress都能利用。

其实这个示例存在一点问题，比如如果先调用getAddress查询某个姓名，此时会将这个查询结果同时缓存到2个缓存中，这样无论是调用getLongNameAddress还是getShortNameAddress都能查出结果，而不会返回null，这样不符合方法原本的逻辑。

@CacheEvict

如果大量使用@Cacheable，可能会造成缓存容量增长占用内存的情况。此时我们可以用@CacheEvict来清除缓存内容：

@Service
@Log4j2
public class UserService {
	// ...
    @CacheEvict(value = {"addresses1", "addresses2"}, allEntries = true)
    public String clearCacheAndGetAddress(String name) {
        log.info("clear cache and query name: %s".formatted(name));
        return getAddress(name);
    }
}

调用clearCacheAndGetAddress方法会清除addresses1、addresses2缓存中的所有内容。

如果allEntries=false，仅会清除对应key的缓存信息。

@CachePut

@CachePut和@Cacheable的区别是，后者会先检查缓存中是否有缓存结果，如果有，直接使用，如果没有再执行方法并缓存结果。而@CachePut不论缓存中的情况如何，都会先执行方法调用，然后缓存结果。

示例：

@Service
@Log4j2
public class UserService {
    // ...
    @CachePut(value = {"addresses1","addresses2"})
    public String updateCacheAndGetAddress(String name){
        log.info("update cache and query name: %s".formatted(name));
        return getAddressWithNoCache(name);
    }
}

这里有一个奇怪的现象，如果用@CachePut方法去调用@Cacheable方法，并且它们使用相同的缓存，就可能导致一些奇怪的现象（缓存没有正确被更新为新的内容）。

@Caching

有时候你可能想在一个方法上使用多个缓存注解：

@CacheEvict(value = "addresses1", allEntries = true),
@CacheEvict(value = "addresses2", allEntries = true)
public String clearCacheAndGetAddress(String name) {
    log.info("clear cache and query name: %s".formatted(name));
    return getAddress(name);
}

这是不被允许的，无法通过编译，因为@CacheEvict注解不允许重复使用。

早期的注解都不能重复使用，后期可以通过修改注解定义，让注解允许重复使用，但如果注解定义中缺少相应的声明，就无法这么做。

此时我们要借助@Caching注解：

@Caching(evict = {
    @CacheEvict(value = "addresses1", allEntries = true),
    @CacheEvict(value = "addresses2", allEntries = true)
})
public String clearCacheAndGetAddress(String name) {
    log.info("clear cache and query name: %s".formatted(name));
    return getAddress(name);
}

当然，这里的示例并不恰当，因为完全可以使用一个@CacheEvict实现，只是为了说明@Caching的用途。

@CacheConfig

可以使用@CacheConfig指定类中方法默认使用的缓存：

@Service
@Log4j2
@CacheConfig(cacheNames = {"addresses1", "addresses2"})
public class UserService {
    @Cacheable()
    public String getAddress(@NonNull String name) {
        // ...
    }
    @CachePut()
    public String updateCacheAndGetAddress(String name) {
        log.info("update cache and query name: %s".formatted(name));
        return getAddressWithNoCache(name);
    }
    // ...
}

条件缓存

看示例：

@Service
@Log4j2
@CacheConfig(cacheNames = {"addresses1", "addresses2"})
public class UserService {
    // ...
	@Cacheable(condition = "#name.equals('DavisMiller')")
    public String getAddressWithConditionCache(@NonNull String name){
        return getAddressWithNoCache(name);
    }
}

这个示例中，只有参数name是DavisMiller时结果才会缓存。

当然，更常见的实际示例应当是缓存某个高频分页查询的前N页。

condition条件满足就会被缓存，相应的，可以用unless条件进行排除：

@Service
@Log4j2
@CacheConfig(cacheNames = {"addresses1", "addresses2"})
public class UserService {
    // ...
    @Cacheable(unless = "#result.equals('上海南京路15号')")
    public String getAddressWithConditionCache2(@NonNull String name){
        return getAddressWithNoCache(name);
    }
}

示例中返回结果是上海南京路15号的时候不会缓存，其余结果都会被缓存。

CacheManager

前面我们说过，默认情况下 Spring Boot 会创建一个ConcurrentMapCacheManager作为CacheManager。当然，如果需要的话，我们也可以自行创建：

@Configuration
@EnableCaching
public class WebConfig {
    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager.setCaches(List.of(
                new ConcurrentMapCache("fibonacci"),
                new ConcurrentMapCache("addresses1"),
                new ConcurrentMapCache("addresses2")));
        return cacheManager;
    }
    // ...
}

CacheUtil

为了方便打印缓存内容，我编写了一个工具类：

@Component
public class CacheUtil {
    @Autowired
    private CacheManager cacheManager;

    /**
     * 打印 CacheManager 中的所有缓存
     */
    public void printCacheManager() {
        var names = cacheManager.getCacheNames();
        names.forEach(this::printCache);
    }

    /**
     * 打印 CacheManager 中的指定缓存（必须是 ConcurrentMapCache 实现）
     *
     * @param cacheName 缓存名称
     */
    public void printCache(String cacheName) {
        var cache = cacheManager.getCache(cacheName);
        System.out.println("cache:%s".formatted(cacheName));
        if (cache instanceof ConcurrentMapCache) {
            var cmCache = (ConcurrentMapCache) cache;
            var nCache = cmCache.getNativeCache();
            nCache.forEach((key, value) -> {
                System.out.println("key=%s,value=%s".formatted(key, value));
            });
        }
    }
}

The End，谢谢阅读。

可以从这里获取本文的完整示例代码。

参考资料

• 从零开始 Spring Boot 32：AOP II - 红茶的个人站点 (icexmoon.cn)
• A Guide To Caching in Spring | Baeldung