SpringBootSpringBoot 缓存（十八）

Posted 2021-03-06 H__D

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBootSpringBoot 缓存（十八）相关的知识，希望对你有一定的参考价值。

　　本章介绍SpringBoot的缓存机制及使用

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

几个重要概念&缓存注解　　

　　　　缓存组件关系图

Cache	缓存接口，定义缓存操作。实现有:RedisCache、EhCacheCache、ConcurrentMapCache等
CacheManager	缓存管理器，管理各种缓存(Cache)组件
@Cacheable	主要针对方法配置，能够根据方法的请求参数对其结果进行缓存
@CacheEvict	清空缓存
@CachePut	保证方法被调用，又希望结果被缓存。
@EnableCaching	开启基于注解的缓存
keyGenerator	缓存数据时key生成策略
serialize	缓存数据时value序列化策略

　　　　缓存注解的主要参数

@Cacheable/@CachePut/@CacheEvict 主要的参数
value	缓存的名称，在 spring 配置文件中定义，必须指定至少一个	例如: @Cacheable(value=”mycache”) 或者 @Cacheable(value={”cache1”,”cache2”}
key	缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合	例如: @Cacheable(value=”testcache”,key=”#userName”)
condition	缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存/清除缓存，在调用方法之前之后都能判断	例如: @Cacheable(value=”testcache”,condition=”#userNam e.length()>2”)
allEntries (@CacheEvict )	是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存	例如: @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”)

　　　　缓存注解的SpEL（Spring Expression Language）

名字	位置	描述	示例
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、新建一个Spring Web工程，整合了mybatis，pom.xml文件如下：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <modelVersion>4.0.0</modelVersion>
 6 
 7     <groupId>com.test</groupId>
 8     <artifactId>test-springboot-cache</artifactId>
 9     <version>1.0-SNAPSHOT</version>
10 
11     <parent>
12         <groupId>org.springframework.boot</groupId>
13         <artifactId>spring-boot-starter-parent</artifactId>
14         <version>2.1.8.RELEASE</version>
15     </parent>
16 
17     <properties>
18 
19         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
20         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
21         <java.version>1.8</java.version>
22     </properties>
23 
24     <dependencies>
25 
26         <dependency>
27             <groupId>org.springframework.boot</groupId>
28             <artifactId>spring-boot-starter-web</artifactId>
29         </dependency>
30 
31         <dependency>
32             <groupId>org.mybatis.spring.boot</groupId>
33             <artifactId>mybatis-spring-boot-starter</artifactId>
34             <version>2.0.1</version>
35         </dependency>
36 
37         <!-- mysql -->
38         <dependency>
39             <groupId>mysql</groupId>
40             <artifactId>mysql-connector-java</artifactId>
41             <version>8.0.12</version>
42         </dependency>
43 
44         <dependency>
45             <groupId>org.springframework.boot</groupId>
46             <artifactId>spring-boot-starter-test</artifactId>
47             <scope>test</scope>
48         </dependency>
49 
50     </dependencies>
51 
52 
53     <!-- SpringBoot打包插件，可以将代码打包成一个可执行的jar包 -->
54     <build>
55         <plugins>
56             <plugin>
57                 <groupId>org.springframework.boot</groupId>
58                 <artifactId>spring-boot-maven-plugin</artifactId>
59             </plugin>
60         </plugins>
61     </build>
62 
63 </project>

pom.xml

　　　　application.yml文件如下：

spring:
  datasource:
    username: admin
    password: 123456
    url: jdbc:mysql://127.0.0.1:3306/test_mybatis
    driver-class-name: com.mysql.jdbc.Driver


mybatis:
  configuration:
    # 下划线转大写映射
    mapUnderscoreToCamelCase: true

logging:
  level:
    com:
      test:
        springboot:
          cache:
            mapper: debug

debug: true

application.yml

　　　　目录结构

　　2、编写实体类Employee.java和Department.java

 1 package com.test.springboot.cache.bean;
 2 
 3 import java.io.Serializable;
 4 
 5 public class Employee implements Serializable {
 6 
 7     private Integer id;
 8     private String lastName;
 9     private String gender;
10     private String email;
11     private Integer deptId;
12 
13     public Integer getDeptId() {
14         return deptId;
15     }
16 
17     public void setDeptId(Integer deptId) {
18         this.deptId = deptId;
19     }
20 
21     public Integer getId() {
22         return id;
23     }
24 
25     public void setId(Integer id) {
26         this.id = id;
27     }
28 
29     public String getLastName() {
30         return lastName;
31     }
32 
33     public void setLastName(String lastName) {
34         this.lastName = lastName;
35     }
36 
37     public String getGender() {
38         return gender;
39     }
40 
41     public void setGender(String gender) {
42         this.gender = gender;
43     }
44 
45     public String getEmail() {
46         return email;
47     }
48 
49     public void setEmail(String email) {
50         this.email = email;
51     }
52 
53     @Override
54     public String toString() {
55         return "Employee{" +
56                 "id=" + id +
57                 ", lastName=\'" + lastName + \'\\\'\' +
58                 ", gender=\'" + gender + \'\\\'\' +
59                 ", email=\'" + email + \'\\\'\' +
60                 ", deptId=" + deptId +
61                 \'}\';
62     }
63 }

Employee.java

 1 package com.test.springboot.cache.bean;
 2 
 3 import java.io.Serializable;
 4 
 5 public class Department implements Serializable {
 6 
 7     private Integer id;
 8     private String depName;
 9 
10     public Integer getId() {
11         return id;
12     }
13 
14     public void setId(Integer id) {
15         this.id = id;
16     }
17 
18     public String getDepName() {
19         return depName;
20     }
21 
22     public void setDepName(String depName) {
23         this.depName = depName;
24     }
25 }

Department.java

　　3、编写EmployeeMapper.java

 1 package com.test.springboot.cache.mapper;
 2 
 3 import com.test.springboot.cache.bean.Employee;
 4 import org.apache.ibatis.annotations.*;
 5 
 6 @Mapper
 7 public interface EmployeeMapper {
 8 
 9     @Select("SELECT * FROM employee WHERE id = #{id}")
10     public Employee getEmpById(Integer id);
11 
12     @Update("UPDATE employee SET last_name = #{lastName}, email=#{email},gender=#{gender},dept_id=#{deptId} WHERE id = #{id}")
13     public void updateEmp(Employee employee);
14 
15     @Delete("DELETE FROM employee WHERE id = #{id}")
16     public void deleteEmpById(Integer id);
17 
18     @Insert("INSERT INTO employee(last_name, email, gender, dept_id) VALUES(#{lastName},#{email},#{gender},#{deptId})")
19     public void insertEmp(Employee emp);
20 }

EmployeeMapper.java

　　4、编写EmployeeService.java

 1 package com.test.springboot.cache.service;
 2 
 3 import com.test.springboot.cache.bean.Employee;
 4 import com.test.springboot.cache.mapper.EmployeeMapper;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.stereotype.Service;
 7 
 8 @Service
 9 public class EmployeeService {
10 
11     @Autowired
12     EmployeeMapper employeeMapper;
13 
14     public Employee getEmp(Integer id){
15         System.out.println("===查询" + id + "号员工");
16         return employeeMapper.getEmpById(id);
17     }
18 }

EmployeeService.java

　　5、编写EmployeeController.java

 1 package com.test.springboot.cache.controller;
 2 
 3 import com.test.springboot.cache.bean.Employee;
 4 import com.test.springboot.cache.service.EmployeeService;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.web.bind.annotation.GetMapping;
 7 import org.springframework.web.bind.annotation.PathVariable;
 8 import org.springframework.web.bind.annotation.RestController;
 9 
10 @RestController
11 public class EmployeeController {
12 
13     @Autowired
14     EmployeeService employeeService;
15 
16     @GetMapping("emp/{id}")
17     public Employee getEmployee(@PathVariable("id") Integer id) {
18 
19         return employeeService.getEmp(id);
20     }
21 }

EmployeeController.java

　　7、编写启动类Application.java

 1 package com.test.springboot.cache;
 2 
 3 
 4 import org.mybatis.spring.annotation.MapperScan;
 5 import org.springframework.boot.SpringApplication;
 6 import org.springframework.boot.autoconfigure.SpringBootApplication;
 7 
 8 /**
 9  * 一、搭建基本环境
10  * 1、创建数据库，创建department和employee表
11  * 2、创建JavaBean封装数据
12  * 3、整合MyBatis操作数据库
13  *      a、配置数据源信息
14  *      b、使用注解版的MyBatis：
15  *          1）、@MapperScan指定需要扫描的mapper接口所在的包
16  * 二、快速体验缓存
17  *  步骤：
18  *      1、开启基于注解的缓存 @EnableCaching
19  *      2、标注缓存注解即可 @Cacheable、@CacheEvict、@CachePut
20  */
21 
22 @MapperScan("com.test.springboot.cache.mapper")
23 @SpringBootApplication
24 public class Application {
25 
26     public static void main(String[] args) {
27         SpringApplication.run(Application.class, args);
28     }
29 
30 }

Application.java

　　8、启动项目，浏览器访问地址：http://localhost:8080/emp/1，测试能否正常获取数据

　　使用缓存

　　1、开启基于注解的缓存 @EnableCaching

 1 @EnableCaching
 2 @MapperScan("com.test.springboot.cache.mapper")
 3 @SpringBootApplication
 4 public class Application {
 5 
 6     public static void main(String[] args) {
 7         SpringApplication.run(Application.class, args);
 8     }
 9 
10 }

　　2、标注缓存注解即可 @Cacheable、@CacheEvict、@CachePut，在EmployeeService的getEmp方法上注解

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

　　3、启动项目，浏览器访问地址：http://localhost:8080/emp/1，连续2个请求，看第二次是否有查数据库（通过日志可以体现）

缓存原理

　　缓存自动配置原理

　　　　1、分析自动配置类：CacheAutoConfiguration　　

　　　　2、在CacheAutoConfiguration类中，自动导入了类CacheConfigurationImportSelector.class

1 @Import(CacheConfigurationImportSelector.class)
2 public class CacheAutoConfiguration {

　　　　　　CacheConfigurationImportSelector.class　

 1 static class CacheConfigurationImportSelector implements ImportSelector {
 2 
 3     @Override
 4     public String[] selectImports(AnnotationMetadata importingClassMetadata) {
 5         CacheType[] types = CacheType.values();
 6         String[] imports = new String[types.length];
 7         for (int i = 0; i < types.length; i++) {
 8             imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
 9         }
10         return imports;
11     }
12 
13

　　　　而CacheConfigurationImportSelector会根据条件自动导入以下缓存的配置类，以下配置类不完全生效，要在一定条件下配置类才会生效

GenericCacheConfiguration.class
EhCacheCacheConfiguration.class
HazelcastCacheConfiguration.class
InfinispanCacheConfiguration.class
JCacheCacheConfiguration.class
CouchbaseCacheConfiguration.class
RedisCacheConfiguration.class
CaffeineCacheConfiguration.class
SimpleCacheConfiguration.class
NoOpCacheConfiguration.class

　　　　3、测试项目，在项目配置文件中配置（debug: true），配置调试模式，然后启动项目通过在控制查看输出日志，可以看到SimpleCacheConfiguration配置上了

　　　　　　而SimpleCacheConfiguration，的内容如下；它在容器中注入了一个ConcurrentMapCacheManager，用来管理缓存

 1 @Configuration
 2 @ConditionalOnMissingBean(CacheManager.class)
 3 @Conditional(CacheCondition.class)
 4 class SimpleCacheConfiguration {
 5 
 6     private final CacheProperties cacheProperties;
 7 
 8     private final CacheManagerCustomizers customizerInvoker;
 9 
10     SimpleCacheConfiguration(CacheProperties cacheProperties, CacheManagerCustomizers customizerInvoker) {
11         this.cacheProperties = cacheProperties;
12         this.customizerInvoker = customizerInvoker;
13     }
14 
15     @Bean
16     public ConcurrentMapCacheManager cacheManager() {
17         ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
18         List<String> cacheNames = this.cacheProperties.getCacheNames();
19         if (!cacheNames.isEmpty()) {
20             cacheManager.setCacheNames(cacheNames);
21         }
22         return this.customizerInvoker.customize(cacheManager);
23     }
24 
25 }

　　　　4、分析ConcurrentMapCacheManager类，它是实现了CacheManager接口

 1 public class Concu以上是关于SpringBootSpringBoot 缓存（十八）的主要内容，如果未能解决你的问题，请参考以下文章 
 Java基础十Spring Boot /Spring Cloud
 十Mybatis 缓存系统解析
 ABP源码分析十三：缓存Cache实现
 springbootSpringBoot任务
 ㊫SpringBootSpringBoot的扩展实现方式
 SpringBootSpringBoot 自动配置原理