SpringBoot高级: (一)缓存
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设置。
图一:
/**
*导入maven
*/
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>javax.cache</groupId>
<artifactId>cache-api</artifactId>
<version>1.1.1</version>
</dependency>
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、从缓存中读取之前缓存存储的数据
缓存注解
@Cacheable 和 @CachePut区别
@Cacheable: 只会被调用一次，再次调用缓存中有就读缓存中的。
@CachePut: 方法总会被调用，调用结果会被更新到缓存中。
基本环境搭建
/**
* sql脚本
*/
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for department
-- ----------------------------
DROP TABLE IF EXISTS `department`;
CREATE TABLE `department` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`departmentName` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for 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,
`d_id` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/**
* pom.xml
*/
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<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.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
/**
* application.yml
*/
spring:
datasource:
url: jdbc:mysql://XX.XXX.XX.XX:3306/any?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2b8
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver
# 开启驼峰识别开关
mybatis:
configuration:
map-underscore-to-camel-case: true
# 开启数据库sql打印
logging:
level:
com:
springboot01cache:
cache:
mapper: debug
/**
* Department实体类
*/
package com.springboot01cache.cache.pojo;
public class Department {
private Integer id;
private String departmentName;
public Department() {
super();
}
public Department(Integer id, String departmentName) {
super();
this.id = id;
this.departmentName = departmentName;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getDepartmentName() {
return departmentName;
}
public void setDepartmentName(String departmentName) {
this.departmentName = departmentName;
}
@Override
public String toString() {
return "Department [id=" + id + ", departmentName=" + departmentName + "]";
}
}
/**
* Employee实体类
*/
package com.springboot01cache.cache.pojo;
public class Employee {
private Integer id;
private String lastName;
private String email;
private Integer gender; //性别 1男 0女
private Integer dId;
public Employee() {
super();
}
public Employee(Integer id, String lastName, String email, Integer gender, Integer dId) {
super();
this.id = id;
this.lastName = lastName;
this.email = email;
this.gender = gender;
this.dId = dId;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Integer getGender() {
return gender;
}
public void setGender(Integer gender) {
this.gender = gender;
}
public Integer getdId() {
return dId;
}
public void setdId(Integer dId) {
this.dId = dId;
}
@Override
public String toString() {
return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + ", dId="
+ dId + "]";
}
}
/**
* DepartmentMapper类
*/
package com.springboot01cache.cache.mapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface DepartmentMapper {
}
/**
* EmployeeMapper类
*/
package com.springboot01cache.cache.mapper;
import com.springboot01cache.cache.pojo.Employee;
import org.apache.ibatis.annotations.*;
@Mapper
public interface EmployeeMapper {
@Select("select * from employee where id = #{id}")
public Employee employee(Integer id);
@Update("update employee set email = #{email} where id = #{id}")
public void updateEmployee(Employee employee);
@Delete("delete from employee where id = #{id}")
public void deleteEmployee(Integer id);
@Insert("insert into employee(lastName,email,gender,d_id) values(#{lastName},#{email},#{gender},#{dId})")
public void insertEmployee(Employee employee);
@Select("select * from employee where lastName = #{lastName}")
public Employee getEmployeeByLastName(String lastName);
}
/**
* EmployeeService
*/
package com.springboot01cache.cache.service;
import com.springboot01cache.cache.mapper.EmployeeMapper;
import com.springboot01cache.cache.pojo.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.*;
import org.springframework.stereotype.Service;
/**
* 抽取缓存的公共配置
*/
@CacheConfig(cacheNames = {"emp", "temp"})
@Service
public class EmployeeService {
@Autowired
EmployeeMapper employeeMapper;
/**
* 将方法的运行结果进行缓存，以后再要查询相同的数据，直接从缓存中获取，不用调用方法
* CacheManager管理多个Cache组件的,对缓存真正的CRUD操作是在Cache组件中,每一个缓存组件都有自己唯一的名字
* cacheNames/value: 指定缓存组件的名字,将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存
* key: 缓存数据使用的key,可以使用它来指定,默认使用方法的参数值
* 支持spel表达式
* keyGenerator: key的生成器 和key二选一
* cacheManager: 指定缓存管理器
* cacheResolver: 指定缓存解析器 和缓存管理器二选一
* condition: 符合条件的情况下才缓存
* unless: 否定缓存,当true时方法的返回值就不会被缓存
* sync: 是否使用异步模式
*/
@Cacheable(cacheNames = {"emp", "temp"},
key = "#id",
condition = "#id>0",
unless = "#result == null")
public Employee employee(Integer id) {
System.out.println("查询" + id + "号员工");
return employeeMapper.employee(id);
}
/**
* @param employee
* @return
* @CachePut 即调用方法, 又更新缓存
* 修改数据库中某个数据,同时更新缓存
* 运行时机:
* 1. 先调用目标方法
* 2. 将目标方法的结果缓存起来
*/
@CachePut(value = {"emp", "temp"}, key = "#employee.id"/**,key = "#result.id"*/)
public Employee updateEmployee(Employee employee) {
employeeMapper.updateEmployee(employee);
return employee;
}
/**
* 清除缓存
* allEntries: 删除这个缓存中所有的key缓存
* beforeInvocation: 缓存的清除是否在方法之前执行
*
* @param id
*/
@CacheEvict(value = {"emp", "temp"}, allEntries = true, beforeInvocation = true)
public void updateEmployee(Integer id) {
employeeMapper.deleteEmployee(id);
}
/**
* @param lastName
* @return
* @Caching 定义复杂的缓存规则
*/
@Caching(cacheable = {
@Cacheable(cacheNames = {"emp", "temp"},
key = "#id",
condition = "#id>0",
unless = "#result == null")
},
put = {@CachePut(value = {"emp", "temp"}, key = "#employee.id"),
@CachePut(value = {"emp", "temp"}, key = "#employee.email")})
public Employee getEmployeeByLastName(String lastName) {
return employeeMapper.getEmployeeByLastName(lastName);
}
}
/**
* EmployeeController
*/
package com.springboot01cache.cache.controller;
import com.springboot01cache.cache.pojo.Employee;
import com.springboot01cache.cache.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class EmployeeController {
@Autowired
EmployeeService employeeService;
@RequestMapping("/emp/{id}")
public Employee employee(@PathVariable("id") Integer id) {
return employeeService.employee(id);
}
}
/**
* 启动类 扫描mapper 开始注解缓存
*/
package com.springboot01cache.cache;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@MapperScan({"com.springboot01cache.cache.mapper"})
@EnableCaching // 标注开启注解缓存
public class CacheApplication {
public static void main(String[] args) {
SpringApplication.run(CacheApplication.class, args);
}
}
@Cacheable/@CachePut/@CacheEvict 主要的参数
Cache SpEL available metadata
原理
(1). 自动配置类: CacheAutoConfiguration
(2). 缓存配置类
(3). 默认生效的配置类:org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration
(4). 给容器中注册了一个CacheManager: ConcurrentMapCacheManager 
(5). 可以获取和创建ConcurrentMapCache类型的缓存组件,作用将数据保存在ConcurrentMap中。
ConcurrentMapCache类:
运行流程
@Cacheable
1、方法运行之前, 先去查询Cache缓存组件,按照cacheNams指定的名称获取，(CacheManager先获取相应的缓存)，第一次获取缓存如果没有Cache组件会自动创建。
2、去Cache中查找缓存的内容，使用一个key，默认就是方法的参数。
key是按照某种策略生成的，默认使用keyGenerator生成的，默认是SimpleKeyGenerator生成key。
SimpleKeyGenerator生成key的默认策略:
1) 如果没有参数，key=new SimpleKey();
2) 如果有一个参数，key=参数的值
3）如果有多个参数，key=new SimpleKey(params);
3、没有查到缓存就调用目标方法。
4、将目标方法返回的结果放进缓存中。
@Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，如果没有就运行方法并将结果放入缓存中，以后再来调用就可以直接使用缓存中的数据。
核心：
1、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】
2、key使用keyGenerator生成的，默认是SimpleKeyGenerator