springboot2.4.0缓存的工作原理与@Cacheable运行流程-笔记

查阅相关资料，观看相关学习视频，结合自我debug流程追踪，记录学习过程。

---

---

一、JSR107核心概念

Java Caching作为JSR107的规范已经在最终的制定中，我们的项目准备以JCache作为基础来扩展，因此这里参考JSR107规范文档进行简单的介绍。
Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。
CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。
CacheManager定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有。
Cache是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有。
Entry是一个存储在Cache中的key-value对。
Expiry 每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间，条目为过期的状态。一旦过期，条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置。

---

二、spring中的缓存抽象

Spring从3.1开始定义了 org.springframework.cache.Cache 和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术，
并支持使用JCache（JSR-107）注解简化我们开发。

Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合；
Cache 接口下Spring提供了各种xxxCache的实现；如RedisCache， EhCacheCache , ConcurrentMapCache 等；

每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。
使用Spring缓存抽象时我们需要关注以下两点:

1. 确定方法需要被缓存以及他们的缓存策略
2. 从缓存中读取之前缓存存储的数据

---

三、spring中的缓存概念和注解

1.几个概念

• Cache : 缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、ConcurrentMapCache等
• CacheManager : 缓存管理器，管理各种缓存（Cache）组件
• keyGenerator : 缓存数据时key生成策略
• serialize : 缓存数据时value序列化策略

2. 注解

注解	注解说明
@Cacheable	主要针对方法配置，能够根据方法的请求参数对其结果进行缓存
@CacheEvict	清空缓存
@CachePut	保证方法被调用，又希望结果被缓存
@EnableCaching	开启基于注解的缓存

3.@Cacheable/@CachePut/@CacheEvict注解上的主要参数

4.缓存注解上SpEL表达式可使用的元数据

四、快速体验缓存的使用入门步骤

1.引入依赖以及准备环境

1. 导入数据库文件 创建 department 和 employee 表
2. 创建javaBean封装数据
3. 整合MyBatis操作数据库
   3.1 配置数据源信息
   3.2 使用注解版的MyBatis，@MapperScan指定需要扫描的mapper接口所在的包

<dependencies>
		<!--引入缓存启动器 这是主角-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <!--web模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>
		<!--数据库依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--<scope>runtime</scope>-->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

2.快速入门

① @EnableCaching注解

在主程序入口添加 @EnableCaching 注解，用于开启基于注解的缓存。

@SpringBootApplication
@MapperScan("xiaojiang.springboot.mapper")
@EnableCaching
public class SpringBoot09CacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBoot09CacheApplication.class, args);
    }
}

② 标注缓存注解

在我们原先的不使用缓存的方法中，通过controller调用业务层方法时，控制台打印如下所示，它会重复查询数据库。

我们知道，mybatis是自动默认开启一级缓存的，不过它是基于sqlSession级别的，这里的两次请求是不同的sqlsession，使用不同的一级缓存，所以需要重新查询数据库。

查询1号员工
2020-12-22 17:21:00.117 DEBUG 16212 --- [nio-8080-exec-8] x.s.mapper.EmployeeMapper.getEmpById     : ==>  Preparing: select * from employee where id = ?
2020-12-22 17:21:00.117 DEBUG 16212 --- [nio-8080-exec-8] x.s.mapper.EmployeeMapper.getEmpById     : ==> Parameters: 1(Integer)
2020-12-22 17:21:00.119 DEBUG 16212 --- [nio-8080-exec-8] x.s.mapper.EmployeeMapper.getEmpById     : <==      Total: 1
2020-12-22 17:21:00.122 DEBUG 16212 --- [nio-8080-exec-8] m.m.a.RequestResponseBodyMethodProcessor : Using 'application/json;q=0.8', given [text/html, application/xhtml+xml, image/webp, image/apng, application/signed-exchange;v=b3, application/xml;q=0.9, */*;q=0.8] and supported [application/json, application/*+json, application/json, application/*+json]
2020-12-22 17:21:00.122 DEBUG 16212 --- [nio-8080-exec-8] m.m.a.RequestResponseBodyMethodProcessor : Writing [Employee [id=1, lastName=zhangsan, email=275487678@qq.com, gender=0, dId=1]]
2020-12-22 17:21:00.123 DEBUG 16212 --- [nio-8080-exec-8] o.s.web.servlet.DispatcherServlet        : Completed 200 OK
2020-12-22 17:21:00.449 DEBUG 16212 --- [nio-8080-exec-9] o.s.web.servlet.DispatcherServlet        : GET "/emp/1", parameters={}
2020-12-22 17:21:00.450 DEBUG 16212 --- [nio-8080-exec-9] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped to xiaojiang.springboot.controller.EmployeeController#getEmp(Integer)
查询1号员工
2020-12-22 17:21:00.451 DEBUG 16212 --- [nio-8080-exec-9] x.s.mapper.EmployeeMapper.getEmpById     : ==>  Preparing: select * from employee where id = ?
2020-12-22 17:21:00.451 DEBUG 16212 --- [nio-8080-exec-9] x.s.mapper.EmployeeMapper.getEmpById     : ==> Parameters: 1(Integer)
2020-12-22 17:21:00.452 DEBUG 16212 --- [nio-8080-exec-9] x.s.mapper.EmployeeMapper.getEmpById     : <==      Total: 1
2020-12-22 17:21:00.454 DEBUG 16212 --- [nio-8080-exec-9] m.m.a.RequestResponseBodyMethodProcessor : Using 'application/json;q=0.8', given [text/html, application/xhtml+xml, image/webp, image/apng, application/signed-exchange;v=b3, application/xml;q=0.9, */*;q=0.8] and supported [application/json, application/*+json, application/json, application/*+json]
2020-12-22 17:21:00.455 DEBUG 16212 --- [nio-8080-exec-9] m.m.a.RequestResponseBodyMethodProcessor : Writing [Employee [id=1, lastName=zhangsan, email=275487678@qq.com, gender=0, dId=1]]
2020-12-22 17:21:00.456 DEBUG 16212 --- [nio-8080-exec-9] o.s.web.servlet.DispatcherServlet        : Completed 200 OK

诸如@Cacheable、@CacheEvict、@CachePut等缓存注解。这里我们使用@Cacheable标注方法使用缓存。

	@Cacheable
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }

当我们添加该注解时，就会将方法的运行结果进行缓存，以后再要相同的数据，直接从缓存中获取，不用调用方法。
那么我们来研究一下@Cacheable注解的几个属性。

③ @Cacheable注解的几个属性

• cacheNames/value : 指定缓存组件的名字，将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存。

	@Cacheable(cacheNames = {"emp","emp1","emp2"})
    @Override
    public Employee getEmp(Integer id) {
        ...
    }

• key : 缓存数据使用的key，可以用它来指定，默认是使用方法参数的值 : 方法的返回值 —> 我们可以编写SpEl来自定义属性值，如(详情见上面的SpEL)，比如说我们想写成getEmp[2]，我们可以写成key = “#root.methodName + ‘[’ + #id + ‘]’”。

	@Cacheable(cacheNames = "emp", key = "#root.methodName + '[' + #id + ']'")
    @Override
    public Employee getEmp(Integer id) {
        ...
    }

• keyGenerator : key的生成器，也可以自己指定key的生成器的组件id，可以自己写一个config类，通过注册自己的KeyGenerator组件，来定义key的生成策略，如下所示。

@Configuration
public class MyCacheConfig {

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                return method.getName() + '[' + Arrays.asList(objects).toString() + ']';
            }
        };
    }
}

---------------------------------------------------------------------------

	@Cacheable(cacheNames = "emp",keyGenerator = "myKeyGenerator")
    @Override
    public Employee getEmp(Integer id) {
        ...
    }

key / keyGenerator 二选一使用

• cacheManager : 指定缓存管理器， 或者cacheResolver : 指定缓存解析器

cacheManager / cacheResolver 二选一使用

• condition : 指定符合条件的情况下才缓存。
  比如 condition = “#id > 0” 如果传入参数 > 0 ，则缓存。

	//传入的第一个参数的值 > 0，并且方法名字等于getEmp时，方法返回值才会缓存
	@Cacheable(cacheNames = "emp", condition = "#a0 > 0 and #root.methodName eq 'getEmp'")
    @Override
    public Employee getEmp(Integer id) {
        ...
    }

• unless : 否定缓存，当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断
  unless = “#result == null” 如果查询结果为空，则不缓存

	// 如果结果为空，或者传入的第一个参数的值为2时，方法不缓存
	@Cacheable(cacheNames = "emp", unless = "#result == null or #a0 == 2")
    @Override
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }

如果condition和unless都为true，那么unless会否定前面的condition，则会不缓存

• sync : 是否使用异步模式，默认是同步模式(方法执行完，以同步的方式将方法返回的结果存入缓存中)，异步模式的情况下，就不支持unless了。

五、缓存工作原理&Cacheable运行流程

下面我们将根据这个方法来了解缓存的工作原理。

@Cacheable(cacheNames = "emp", key = "#id", condition = "#id > 0", unless = "#result == null")
    @Override
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }

分析运行流程，首先要先从自动配置类入手，缓存的自动配置类为CacheAutoConfiguration，其中它在@Import中导入了CacheAutoConfiguration.CacheConfigurationImportSelector.class

static class CacheConfigurationImportSelector implements ImportSelector {

        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            CacheType[] types = CacheType.values();
            String[] imports = new String[types.length];
            for(int i = 0; i < types.length; ++i) {
                imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
            }
            return imports;
        }
    }

这个方法是用于给我们的缓存导入需要的配置组件，因此我们在返回值上打上断点，发现导入了如下的缓存配置组件，这十个就是在springboot2.4.0中所有的缓存配置组件。

那么我们哪个配置类默认生效呢？在他们每一个类头上都标注了几个注解，以org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration为例。

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnBean({Cache.class})
@ConditionalOnMissingBean({CacheManager.class})
@Conditional({CacheCondition.class})
class GenericCacheConfiguration {

那么我们为了在控制台上观察它的自动配置报告，我们现在application.properties全局配置文件中开启

debug=true

运行主程序，打印控制台，发现只有一个SimpleCacheConfiguration匹配上。所以默认是它生效的。

而SimpleCacheConfiguration就是给容器中注册了一个ConcurrentMapCacheManager缓存管理器。

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnMissingBean({CacheManager.class})
@Conditional({CacheCondition.class})
class SimpleCacheConfiguration {

    @Bean
    ConcurrentMapCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers cacheManagerCustomizers) {
        ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
        List<String> cacheNames = cacheProperties.getCacheNames();
        if (!cacheNames.isEmpty()) {
            cacheManager.setCacheNames(cacheNames);
        }
        return (ConcurrentMapCacheManager)cacheManagerCustomizers.customize(cacheManager);
    }
}

其中getCache() 方法(实现CacheManager接口的方法)，可以获取和创建ConcurrentMapCache类型的缓存组件，它的作用是将数据保存在ConcurrentMap中。

这里双重判断是因为，第一次判断为空可能多线程同时满足，第一个线程创建完成，第二个线程就重复创建了，而第二个判断为空前面有sync锁，所以不存在多个线程同时进去的情况，所以双重判断为空是用来提高效率并重复创建。

通过debug了解运行流程

我们在service方法上、CacheManager的getCache方法、Cache中的lookup方法与put方法上打上断点进行debug运行。

流程一

我们调用查询方法，发现进入CacheManager的getCache方法，我们就知道，在方法运行之前，先去查询Cache(缓存组件)，按照cacheNames指定的名字获取。【CacheManager先获取相应的缓存】

第一次如果没有cache组件的话会自动调用createConcurrentMapCache创建一个缓存。

流程二

我们直接进入第二个断点，进入ConcurrentMapCache的lookup方法，去Cache中查找缓存的内容，传入的参数是一个key，默认就是方法的参数。

但是key是如何生成的呢？我们就能猜测它是根据某种策略定义生成的，默认是调用context.generateKey 中的ConcurrentMap的实现SimpleKeyGenerator生成key。

流程三

当它获取值为空时(即没有查到缓存时)，它就会进入目标方法了。

流程四

将目标方法返回的结果，放进缓存中

流程五 : key生成策略分析一

我们进行第二次查询。前面debug跳过，跳到generateKey方法上，查看它是如何创建key的。层层进入，发现它先是调用了自身私有的generateKey方法，其中通过上下文context调用generateKey方法，而在它的方法中，是通过keyGnerator对象来制定key的生成策略。

流程六 : key生成策略分析二

那么我们来看一下KeyGnerator接口，它在这个方法中使用的实现类是SimpleKeyGnerator对象。

SimpleKeyGnerator中，定义了生成策略，它通过接受传入的可变参数数组(默认为方法的参数，可通过CacheNames设置)，通过判断为空、一个、多个来决定不同的策略。

SimpleKeyGenerator生成key的默认策略：

• 如果没有参数，key = new SimpleKey()；
• 如果有一个参数，key = 参数的值
• 如果有多个参数，key = new SimpleKey(params);

流程七

生成完key之后，便在里面寻找key。

因为之前缓存这个数据，所以能通过get方法获取到该缓存数据。


因为数据不等于空，返回缓存数据。

流程总结

@Cacheable注解标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，如果没有就运行方法，并将结果存入缓存，以后再来调用就可以直接使用缓存中的数据。
核心 :

1. 使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
2. key是使用KeyGenerator生成的，默认是SimpleKeyGenerator