SpringBoot中Cache的使用及源码分析

参考资料:尚硅谷雷封阳SpringBoot视频

尚硅谷雷封阳SpringBoot

文章目录

  • 一、缓存的作用
    • 1. JSR107
  • 二、Spring缓存抽象
  • 三、几个重要概念&缓存注解
    • 1. 重要概念&缓存注解
    • 2. @Cacheable/@CachePut/@CacheEvict注解下的常用属性
    • 3. SpEL表达式详解
  • 四、缓存使用
    • 1. 环境搭建
      • 1. 测试环境
      • 2. 数据库构建
      • 3. 依赖导入
      • 4. 配置文件设置
      • 5. 代码生成器配置
      • 6. 项目结构如下
      • 7. 开启缓存注解
    • 2. @CacheConfig&@Cacheable注解的使用
      • 1. 运行流程
      • 2. 详细代码
    • 3. @CachePut注解的使用
      • 1. 运行流程
      • 2. 详细代码
    • 4. @CacheEvict注解使用
      • 1. 运行流程
      • 2. 详细代码
    • 5. @Caching注解的使用
      • 1. 详细代码
  • 五、Cache原理解析(深入源码)
    • 1. SpringBoot自动配置Cache原理分析
    • 2. ConcurrentMapCachemanager类分析
      • 1. 获取Cache的方法
      • 2. 创建Cache的方法
    • 3. @Cacheable注解原理分析
      • 1. 尝试获取cache
      • 2. 使用指定key在cache中查找数据
      • 3. 将数据添加到cache中(缓存中没有对应数据时执行)
      • 4. @Cacheable注解执行流程图

一、缓存的作用

​ 随着用户群体的扩展,系统所需要处理的数据请求将成几何式增长,数据库很容易会因为无法处理庞大的请求而产生宕机现象,这对一个软件来说是十分可怕的,而缓存就是解决这一问题的一个方案。缓存的使用将大大提高数据库的承载能力,提高系统的承载力和安全性。

1. JSR107

​ Java Caching定义了5个核心接口,分别是CachingProvider, CacheManager, Cache, EntryExpiry

  • CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。

  • CacheManager定义了创建、配置、获取、管理和控制多个唯一命名的Cache,这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有。

  • Cache是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有。

  • Entry是一个存储在Cache中的key-value对。

  • Expiry 每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间,条目为过期的状态。一旦过期,条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置。

    ​ 其中,CacheManagerCache是最常用的。他们的关系类似于MySQL数据库中数据库和表的关系,和MySQl不同的是:Cache中存储的是key-value形式的Entry。

如图

SpringBoot中Cache的使用及源码分析_第1张图片

二、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. 从缓存中读取之前缓存存储的数据

图解如下:

SpringBoot中Cache的使用及源码分析_第2张图片

三、几个重要概念&缓存注解

1. 重要概念&缓存注解

Cache 缓存接口,定义缓存操作。实现有:RedisCacheEhCacheCacheConcurrentMapCache
CacheManager 缓存管理器,管理各种缓存(Cache组件)
@Cacheable 主要针对方法配置,能够根据方法的请求参数对其结果进行缓存
@CacheEvict 清空缓存(和==@Cacheable==配合使用才有意义)
@CachePut 保证方法被调用,又希望结果被缓存。(和==@Cacheable==配合使用才有意义)
@Caching 组合注解,可同时使用上面三个注解。用于实现复杂的缓存策略
@CacheConfig 一般用在类上,抽取配置其他注解的共有属性,例如cacheNames
@EnableCaching 开启基于注解的缓存
keyGenerator 缓存数据时key生成策略
serialize 缓存数据时value序列化策略

2. @Cacheable/@CachePut/@CacheEvict注解下的常用属性

属性名 详解 示例
cacheNames 缓存的名称,在 spring 配置文件中定义,必须指定至少一个 例如: @Cacheable(cacheNames=”mycache”) 或者 @Cacheable(cacheNames={”cache1”,”cache2”}
value 等效于cacheNames 例如: @Cacheable(value=”mycache”) 或者 @Cacheable(value={”cache1”,”cache2”}
key 缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则默认使用SimpleKeyGenerator策略生成key 例如: @Cacheable(value=”testcache”,key=”#userName”)
keyGenerator 指定key的生成策略 例如:keyGenerator = “myKeyGenerator”
condition 缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存/清除缓存,在调用方法之前之后都能判断 例如: @Cacheable(value=”testcache”,condition=”#userName.length()>2”)
allEntries (@CacheEvict ) 是否清空所有缓存内容,缺省为 false,如果指定为 true,则方法调用后将立即清空所有缓存 (指定CacheName下的缓存) 例如: @CachEvict(value=”testcache”,allEntries=true)
beforeInvocation (@CacheEvict) 是否在方法执行前就清空,缺省为 false,如果指定为 true,则在方法还没有执行的时候就清空缓存,缺省情况下,如果方法执行抛出异常,则不会清空缓存 例如: @CachEvict(value=”testcache”,beforeInvocation=true)
unless (@CachePut) (@Cacheable) 用于否决缓存的,不像condition,该表达式只在方法执行之后判断,此时可以拿到返回值result进行判断。条件为true不会缓存,fasle才缓存 例如: @Cacheable(value=”testcache”,unless=”#result == null”)

需注意

  1. key和keyGenerator二选一使用

3. SpEL表达式详解

名字 位置 描述 示例
methodName root.object 当前被调用的方法名 #root.methodName
method root.object 当前被调用的方法 #root.method.name
target root.object 当前被调用的目标对象 #root.target
targetClass root.object 当前被调用的目标对象类 #root.targetClass
args root.object 当前被调用的方法的参数列表 #root.args[0]
caches root object 当前方法调用使用的缓存列表(如@Cacheable(value={“cache1”, “cache2”})),则有两个cache #root.caches[0].name
argument name evaluation context 方法参数的名字. 可以直接==#参数名==,也可以使用 #p0或==#a0== 的形式,0代表参数的索引 #iban 、 #a0 、 #p0
result evaluation context 方法执行后的返回值(仅当方法执行之后的判断有效,如‘unless’,’cache put’的表达式 ’cache evict’的表达式beforeInvocation=false) #result

四、缓存使用

部分注释看不懂没有关系,第五部分将会依据测试代码进行源码解析。不要放弃!

1. 环境搭建

1. 测试环境

  • JDK:1.8
  • IDE:IntelliJ IDEA 2019.3 x64
  • maven:apache-maven-3.5.2
  • mysql:MySQl Server 5.5
  • swagger2:2.7.0
  • mybatisplus:3.4.0
  1. 整合Swagger2便于测试
  2. 整合lombok+mybatis-plus减少代码书写量(偷个懒)

2. 数据库构建

缓存注解推荐在Service层使用,因为Service层是负责业务逻辑操作数据的

/*
SQLyog Enterprise v12.09 (64 bit)
MySQL - 5.5.40 : Database - springboot_cache
*********************************************************************
*/


/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`springboot_cache` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `springboot_cache`;

/*Table structure for table `employee` */

DROP TABLE IF EXISTS `employee`;

CREATE TABLE `employee` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `lastName` varchar(255) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
  `gender` int(2) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

/*Data for the table `employee` */

insert  into `employee`(`id`,`lastName`,`email`,`gender`) values (1,'花花','232342@',2),(2,'叶子','2342432323@',3);

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

3. 依赖导入

<dependencies>

        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
            <version>2.1.3version>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-cacheartifactId>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.37version>
            <scope>runtimescope>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>

        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>3.4.0version>
        dependency>
    	
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-generatorartifactId>
            <version>3.4.0version>
        dependency>
        <dependency>
            <groupId>org.apache.velocitygroupId>
            <artifactId>velocity-engine-coreartifactId>
            <version>2.2version>
        dependency>
        
        <dependency>
            <groupId>io.springfoxgroupId>
            <artifactId>springfox-swagger2artifactId>
            <version>2.7.0version>
        dependency>
        <dependency>
            <groupId>io.springfoxgroupId>
            <artifactId>springfox-swagger-uiartifactId>
            <version>2.7.0version>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>
    dependencies>

4. 配置文件设置

dev2的环境将在整合redis时使用

spring:
  profiles:
    active: dev1

---
spring:
  profiles: dev1
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_cache
    username: root
    password: root
server:
  port: 8080
#控制台打印配置信息
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: com.yezi.redistest.pojo
  mapper-locations: classpath:com/yezi/redistest/mapper/xml/*.xml
debug: true
---

spring:
  profiles: dev2
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_cache
    username: root
    password: root
  redis:
    host: localhost
    port: 6379
    database: 0
    timeout: 1800000
    lettuce:
      pool:
        max-active: 20
        max-wait: -1  # 最大阻塞时间,负数表示没有限制
        max-idle: 5
        min-idle: 0
server:
  port: 8080
#控制台打印配置信息
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: com.yezi.redistest.pojo
  mapper-locations: classpath:com/yezi/redistest/mapper/xml/*.xml

5. 代码生成器配置

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.junit.jupiter.api.Test;

/**
 *
 * @author 叶子
 * @since 2020/10/28
 */
public class CodeGenerator {
     

    @Test
    public void run() {
     

        // 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 2、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");//得到当前文件夹路径
        gc.setOutputDir(projectPath + "/src/main/java");//代码生成目录
        gc.setAuthor("叶子");
        gc.setOpen(false); //生成后是否打开资源管理器
        gc.setFileOverride(false); //重新生成时文件是否覆盖
        gc.setServiceName("%sService");	//去掉Service接口的首字母I
        gc.setIdType(IdType.ID_WORKER_STR); //主键策略
        gc.setDateType(DateType.ONLY_DATE);//定义生成的实体类中日期类型
        gc.setSwagger2(true);//开启Swagger2模式

        mpg.setGlobalConfig(gc);

        // 3、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/springboot_cache");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 4、包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.yezi.redistest");
        /*pc.setModuleName("ucenter"); //模块名*/
        pc.setController("controller");
        pc.setEntity("pojo");
        pc.setService("service");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

        // 5、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("department","employee");//表名称
        strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略
        strategy.setTablePrefix(pc.getModuleName() + "_"); //生成实体时去掉表前缀

        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作

        strategy.setRestControllerStyle(true); //restful api风格控制器
        strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符

        mpg.setStrategy(strategy);


        // 6、执行
        mpg.execute();
    }
}

6. 项目结构如下

SpringBoot中Cache的使用及源码分析_第3张图片

7. 开启缓存注解

@SpringBootApplication
@MapperScan(basePackages = "com.yezi.redistest.mapper")
@EnableCaching /* 开启缓存注解 */
public class SpringbootRedisCatchApplication {
     

    public static void main(String[] args) {
     
        SpringApplication.run(SpringbootRedisCatchApplication.class, args);
    }

}

2. @CacheConfig&@Cacheable注解的使用

1. 运行流程

@Cacheable:
1、service方法运行之前,先去查询Cache(缓存组件),按照cacheNames指定的名字获取;
(CacheManager先获取相应的缓存),第一次获取缓存如果没有Cache组件会自动创建。
2、去Cache中查找缓存的内容,使用一个key,默认就是方法的参数;
key是按照某种策略生成的;默认是使用keyGenerator生成的,默认使用SimpleKeyGenerator生 > 成key;
SimpleKeyGenerator生成key的默认策略;
如果没有参数;key=new SimpleKey();
如果有一个参数:key=参数的值
如果有多个参数:key=new SimpleKey(params);
3、没有查到缓存就调用目标方法;
4、将目标方法返回的结果,放进缓存中

2. 详细代码

package com.yezi.redistest.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.yezi.redistest.pojo.Employee;
import com.yezi.redistest.mapper.EmployeeMapper;
import com.yezi.redistest.service.EmployeeService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.cache.annotation.*;
import org.springframework.stereotype.Service;

/**
 * 

* 服务实现类 *

* * @author 叶子 * @since 2020-10-27 */
@Service @CacheConfig(cacheNames = "employee") /* 指定Cache组件名,本类的所有缓存都会被存储在名为employee的缓存组件中 */ public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements EmployeeService { /** * 将方法的运行结果进行缓存;以后再要相同的数据,直接从缓存中获取,不用调用方法; * CacheManager管理多个Cache组件的,对缓存的真正CRUD操作在Cache组件中,每一个缓存组件有自己唯一一个名字; * CacheManager和Cache的关系类似于MySQL数据库中 数据库和表的关系 * @Cacheable标注的方法执行之前先来检查缓存中有没有这个数据,默认按照参数的值作为key去查询缓存, * 如果没有就运行方法并将结果放入缓存;以后再来调用就可以直接使用缓存中的数据; * * 核心: * 1)、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件 * 2)、key使用keyGenerator生成的,默认是SimpleKeyGenerator * @param id * @return */ @Override @Cacheable(key = "#id") public Employee getEmployeeById(Integer id) { return baseMapper.selectById(id); } }

3. @CachePut注解的使用

请注意:

此注解需和@Cacheable注解配合使用才有意义

作用:更新数据后缓存中相应的数据也被更新,再次查询该数据时依然是从缓存中获取(已更新),提高了效率

1. 运行流程

@CachePut

  1. 首先执行service方法,查询数据库得到数据
  2. 查询Cache(缓存组件),按照cacheNames指定的名字获取;(CacheManager先获取相应的缓存)
  3. 使用指定的key查询Cache中是否有对应数据,如果有就进行更新,没有就创建

2. 详细代码

本方法在EmployeeServiceImpl类中

    /**
     * unless = "#result == null"
     *  当返回值为null时就不进行缓存
     * @param employee
     * @return
     */
    @Override
    @CachePut(key = "#employee.id",unless = "#result == null")
    public Employee update(Employee employee) {
     
        System.out.println(employee.getId());
        UpdateWrapper<Employee> wrapper = new UpdateWrapper<>();
        
        int i = baseMapper.updateById(employee);
        if (i > 0){
     
            return employee;
        }

        return null;
    }

4. @CacheEvict注解使用

请注意:

此注解需和@Cacheable注解配合使用才有意义

作用:删除数据后缓存中相应的数据也被删除

1. 运行流程

@CacheEvict

  1. 先执行service方法
  2. 如果service方法成功执行就移除指定Cache下的指定key的数据,不成功就不进行移除操作

2. 详细代码

本方法在EmployeeServiceImpl类中

    @Override
    @CacheEvict(key = "#id")
    public void deleteById(Integer id) {
     
        baseMapper.deleteById(id);
    }

5. @Caching注解的使用

本方法在EmployeeServiceImpl类中

1. 详细代码

    /**
     * 这里我没有具体指定缓存策略
     * 但是我们可以看到:
     *      使用这个注解可以同时使用@Cacheable、@CachePut和@CacheEvict注解
     *      从而实现一些复杂的缓存策略
     * @param lastName
     * @return
     */
    @Override
    @Caching(cacheable = {
     
            @Cacheable
    },put = {
     
            @CachePut
    },evict = {
     
            @CacheEvict
    })
    public Employee getByLastName(String lastName) {
     
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.eq("lastName",lastName);
        Employee employee = baseMapper.selectOne(wrapper);

        return employee;
    }

五、Cache原理解析(深入源码)

这一部分主要通过对以下两方面的分析来学习SpringBoot缓存的原理

  1. SpringBoot启动过程中对Cache的自动导入
  2. @Cacheable注解的执行流程

1. SpringBoot自动配置Cache原理分析

​ 根据SpringBoot的自动配置原理,我们肯定要去找一个叫做×××AutoConfiguration的类,在此就应该是CacheAutoConfiguration自动配置类

CacheAutoConfiguration类截图

可以看到,这个类导入了一个CacheConfigurationImportSelector类(翻译过来就是:缓存配置导入选择器),那么它导入了哪些配置类呢?进入CacheConfigurationImportSelector源码进行查看

CacheConfigurationImportSelector源码

/**
	 * {@link ImportSelector} to add {@link CacheType} configuration classes.
	 */
static class CacheConfigurationImportSelector implements ImportSelector {
     

    @Override
    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;
    }

}

可以看到,CacheConfigurationImportSelector通过调用CacheConfigurations类的getConfigurationClass()方法拿到需要导入的配置类的名单(封装配置类全限定名的String数组)

我们通过debug模式查看导入的配置类有哪些:

SpringBoot中Cache的使用及源码分析_第4张图片

一共导入了10个缓存配置类,包括RedisCacheConfigurationSimpleCacheConfiguration等,这其中有许多是用来自动配置一些缓存中间件的,比如RedisCacheConfiguration,当Redis的依赖被引入时,这个配置类就会生效,帮我们自动配置使用Redis实现缓存技术。

关于SpringBoot集成redis实现缓存的操作以及原理,我将在另一篇博客中进行具体介绍。

那么在我们没有使用任何缓存中间件的情况下,SpringBoot默认使用哪个缓存配置类呢?

我们关闭程序,在yml(或者properties)文件中配置以debug级别打印日志,然后启动

debug: true

SpringBoot中Cache的使用及源码分析_第5张图片

通过日志信息我们知道了:SpringBoot自动帮我们注入了SimpleCacheConfiguration配置类

SimpleCacheConfiguration配置类帮我们配置了哪些内容呢?我们通过他的源码来分析:

/**
 * Simplest cache configuration, usually used as a fallback.
 *
 * @author Stephane Nicoll
 */
@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 cacheManagerCustomizers.customize(cacheManager);
	}

}

可以看到,他帮我们注册了一个cacheManager(缓存管理器) --> ConcurrentMapCacheManager

经过前面的学习,我们知道,一个cacheManager管理多个Cache,在这里SpringBoot帮我们自动注册了一个cacheManager–> ConcurrentMapCacheManager,那么我们可以大胆推测:之后的缓存操作都将使用ConcurrentMapCacheManager这个类。事实上正是如此,我们将在对@Cacheable注解的分析中来证实这一点。

2. ConcurrentMapCachemanager类分析

源码过长,在此只针对部分代码进行分析。小伙伴们可自行点开源码结合博客一起食用

如果你看到这一部分感到吃力,请结合
@Cacheable注解原理分析一起食用

1. 获取Cache的方法

ConcurrentMapCachemanager类中有一个方法用来通过Cache的名称来获取Cache。

源码如下

    /**
     * 非源码注释
     * @param name cache名称,即由cacheNames和value属性指定的那个名称
     * @return 如果不存在指定Cache,就根据名称创建Cache。如果存在,就返回该Cache
     */
    @Override
    @Nullable
    public Cache getCache(String name) {
     
        Cache cache = this.cacheMap.get(name);
        if (cache == null && this.dynamic) {
     
            synchronized (this.cacheMap) {
     
                cache = this.cacheMap.get(name);
                if (cache == null) {
     
                    cache = createConcurrentMapCache(name);//其实就是创建了一个Map集合,后面会讲到
                    this.cacheMap.put(name, cache);
                }
            }
        }
        return cache;
    }

​ 通过这个方法我们可以知道:cache是被存储在ConcurrentMapCachemanager类中的cacheMap属性中的,那这个cacheMap具体是什么呢?我们继续来查看源码。

SpringBoot中Cache的使用及源码分析_第6张图片

​ 在ConcurrentMapCachemanager类中找到这个属性后,我们发现他就是一个HashMap集合!

由此我们可以得出结论:

ConcurrentMapCachemanager默认使用一个HashMap集合来实现缓存。在这个集合中:key就是Cache的名称value就是具体的Cache

2. 创建Cache的方法

createConcurrentMapCache(String name)方法源码:

	/**
	 * Create a new ConcurrentMapCache instance for the specified cache name.
	 * @param name the name of the cache
	 * @return the ConcurrentMapCache (or a decorator thereof)
	 */
	protected Cache createConcurrentMapCache(String name) {
     
		SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
		return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256), isAllowNullValues(), actualSerialization);
	}

我们可以看到在这里,Cache其实是用的是:ConcurrentMapCache实现类。那我们继续来分析ConcurrentMapCache源码

SpringBoot中Cache的使用及源码分析_第7张图片

这里我们重点来关注这个store属性,其实他存储的就是我们前面所说的Entry

至此,我们就可以明白SpringBoot默认使用的Cache实现机制了,下面我用一幅图来展现以上这两个类的关系(ConcurrentMapCachemanagerConcurrentMapCache

SpringBoot中Cache的使用及源码分析_第8张图片

在这里,我们使用的缓存管理器就是ConcurrentMapCachemanager,而具体的缓存接口实现类就是ConcurrentMapCache

这两个类中还有其他方法未做讲解。有一部分会在@Cacheable注解原理分析中进行讲解,而另一部分则不再赘述。

3. @Cacheable注解原理分析

1. 尝试获取cache

​ 在之前使用此注解的时候,我们提到他会先查询Cache(缓存组件),所以这个注解肯定会首先调用ConcurrentMapCachemanager类中的getCache方法,我们为这个方法打上断点,进行调试。

补充:这里我使用Swagger接口文档对获取employee的接口进行了测试(还是上面的测试项目)

SpringBoot中Cache的使用及源码分析_第9张图片

可以看到,@Cacheable注解调用了这个方法,并使用我们指定的cacheName(employee)去查询是否存在这个Cache(缓存组件)。由于是第一次调用,所以缓存中是肯定没有这个Cache的,它将为我们创建一个名为employee的缓存组件。

点击下一步,正如我们预测的,它创建了这个cache

SpringBoot中Cache的使用及源码分析_第10张图片

至此,获取缓存组件的过程就结束了。接下来根据我们之前对@Cacheable执行过程的分析,他将会使用我们指定的key(在这里就是员工的id)来获取对应的value。在ConcurrentMapCache类中有一个对应的方法:lookup(Object key)。建议提前为其打上断点!

2. 使用指定key在cache中查找数据

我们对程序进行放行,得到:

SpringBoot中Cache的使用及源码分析_第11张图片

​ 由于这是第一次调用,所以缓存中肯定是没有这个数据的。此时@Cacheable注解将会调用service方法,获取数据

我们继续放行

SpringBoot中Cache的使用及源码分析_第12张图片

3. 将数据添加到cache中(缓存中没有对应数据时执行)

添加数据(Entry)的操作将会调用ConcurrentMapCache类中的==put(Object key, @Nullable Object value)==方法,建议提前打上断点

继续放行

SpringBoot中Cache的使用及源码分析_第13张图片

这样,查询得到的数据就被添加到缓存中了。下次调用就会直接从缓存中获取数据而不用再次调用service方法

4. @Cacheable注解执行流程图

SpringBoot中Cache的使用及源码分析_第14张图片

如有不当之处,请各位指教

转载请注明出处

你可能感兴趣的:(Spring,Boot,spring,boot,java)