频道栏目
首页 > 程序开发 > 综合编程 > 其他综合 > 正文
SpringBoot使用缓存及原理解析
2018-09-28 14:33:55           
收藏   我要投稿

一.JSR107

Java Caching 定义了五个核心接口,分别是CachingProvider,CacheManager,Cache,Entry和Expiry。

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

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

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

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

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

如下图所示:

二 Spring缓存抽象(下面会有具体Springboot代码演示)

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

1 Cache接口为缓存的组件规范定义,包含缓存的各种操作集合;

2 Cache接口下Spring提供了各种xxxCache的实现,如RedisCache,EhCacheCache , ConcurrentMapCache等;每次调用需要缓存功能的方法时,Spring会检查检查指定参数的指定的目标方法是否已经被调用过;如果有就直接从缓存中获取方法调用后的结果,如果没有就调用方法并缓存结果返回给用户。下次直接从缓存中获取。

3 使用Spring缓存抽象时我们需要关注以下两点;

第一点就是确定方法需要被缓存以及他们的缓存策略 ,第二点就是从缓存中读取之前缓存存储的数据,

了解jdbc的朋友就会很清楚,这就跟面向jdbc编程是一个道理,统一一个规范,统一面向jdbc编程。

如下图所示:

三 缓存注解

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=”#userName.length()>2”)

allEntries

(@CacheEvict)

是否清空所有缓存内容,缺省为false,如果指定为true,则方法调用后将立即清空所有缓存

例如:

@CachEvict(value=”testcache”,allEntries=true)

beforeInvocation

(@CacheEvict)

是否在方法执行前就清空,缺省为false,如果指定为true,则在方法还没有执行的时候就清空缓存,缺省清空下,如果方法执行抛出异常,则不会清空缓存

例如:

@CachEvict(value=”testcache”,beforeInvocation=true)

unless

(@CachPut)

(@Cacheable)

用于否决缓存,不行codition,该表达式只在方法执行之后判断,此时可以拿到返回值result进行判断。条件为true不会缓存,false才缓存

例如:

@Cacheable(value=”testcache”,unless=”#result == null”)

同样支持spel表达式

四 缓存使用(下面会有具体Springboot代码演示)

要在Springboot中使用缓存需要以下几步:

第一步: 导入spring-boot-starter-cache模块

第二步: @EnableCaching开启缓存

第三步: 使用缓存注解

1.在pom文件中引入坐标地址

org.springframework.boot

spring-boot-starter-cache

2 在主程序中开启缓存注解

@SpringBootApplication

@EnableCaching

public class Springboot01CacheApplication {

public static void main(String[] args) {

SpringApplication.run(Springboot01CacheApplication.class, args);

}

}

3 开始测试代码,首先做好准备

javaBean:

public class Employee implements Serializable {

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 + "]";

}

}

controller层如下:

@RestController

public class EmployeeController {

@Autowired

EmployeeService employeeService;

@GetMapping("/emp/{id}")

public Employee getEmployee(@PathVariable("id") Integer id){

Employee employee = employeeService.getEmp(id);

return employee;

}

@GetMapping("/emp")

public Employee update(Employee employee){

Employee emp = employeeService.updateEmp(employee);

return emp;

}

@GetMapping("/delemp")

public String deleteEmp(Integer id){

employeeService.deleteEmp(id);

return "success";

}

@GetMapping("/emp/lastname/{lastName}")

public Employee getEmpByLastName(@PathVariable("lastName") String lastName){

return employeeService.getEmpByLastName(lastName);

}

}

service层如下:

package com.atguigu.cache.service;

import com.atguigu.cache.bean.Employee;

import com.atguigu.cache.mapper.EmployeeMapper;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.annotation.*;

import org.springframework.stereotype.Service;

@CacheConfig(cacheNames="emp"/*,cacheManager = "employeeCacheManager"*/) //抽取缓存的公共配置

@Service

public class EmployeeService {

@Autowired

EmployeeMapper employeeMapper;

@Cacheable(value = {"emp"}/*,keyGenerator = "myKeyGenerator",condition = "#a0>1",unless = "#a0==2"*/)

public Employee getEmp(Integer id){

System.out.println("查询"+id+"号员工");

Employee emp = employeeMapper.getEmpById(id);

return emp;

}

@CachePut(/*value = "emp",*/key = "#result.id")

public Employee updateEmp(Employee employee){

System.out.println("updateEmp:"+employee);

employeeMapper.updateEmp(employee);

return employee;

}

@CacheEvict(value="emp",beforeInvocation = true/*key = "#id",*/)

public void deleteEmp(Integer id){

System.out.println("deleteEmp:"+id);

//employeeMapper.deleteEmpById(id);

int i = 10/0;

}

// @Caching 定义复杂的缓存规则

@Caching(

cacheable = {

@Cacheable(/*value="emp",*/key = "#lastName")

},

put = {

@CachePut(/*value="emp",*/key = "#result.id"),

@CachePut(/*value="emp",*/key = "#result.email")

}

)

public Employee getEmpByLastName(String lastName){

return employeeMapper.getEmpByLastName(lastName);

}

}

mapper接口如下:

@Mapper

public interface EmployeeMapper {

@Select("SELECT * FROM employee WHERE id = #{id}")

public Employee getEmpById(Integer id);

@Update("UPDATE employee SET lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} WHERE id=#{id}")

public void updateEmp(Employee employee);

@Delete("DELETE FROM employee WHERE id=#{id}")

public void deleteEmpById(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}")

Employee getEmpByLastName(String lastName);

}

application.properties如下:

spring.datasource.username=root

spring.datasource.password=admin

spring.datasource.url=jdbc:mysql://localhost:3306/springCache

spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#开启驼峰命名法

mybatis.configuration.map-underscore-to-camel-case=true

#打印sql语句日志

logging.level.com.lsz.cache.mapper=debug

#控制台打印配置信息

debug=true

4 测试

运行项目,打开浏览器输入https://localhost:8080/emp/1 ,可以看到浏览器返回的值

控制台打印情况:

可以看到第一次获取数据是从数据库中获取的,再次输入https://localhost:8080/emp/1

可以看到并没有查询数据库,而是从缓存中获取的数据,这说明缓存起作用了.

标记缓存的方法

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

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

几个属性:

cacheNames/value:指定缓存组件的名字;将方法的返回结果放在哪个缓存中,是数组的方式,可以指定多个缓存; key:缓存数据使用的key;可以用它来指定。默认是使用方法参数的值 编写SpEL; #i d;参数id的值 #a0 #p0 #root.args[0] getEmp[2] keyGenerator:key的生成器;可以自己指定key的生成器的组件id key/keyGenerator:二选一使用; cacheManager:指定缓存管理器;或者cacheResolver指定获取解析器 condition:指定符合条件的情况下才缓存; condition = "#id>0" condition = "#a0>1":第一个参数的值>1的时候才进行缓存 unless:否定缓存;当unless指定的条件为true,方法的返回值就不会被缓存;可以获取到结果进行判断 unless = "#result == null" unless = "#a0==2":如果第一个参数的值是2,结果不缓存; sync:是否使用异步模式

@CachePut 既调用目标方法,又更新缓存

先调用目标方法 将目标方法的结果缓存起来

@CacheEvict

/**

* @CacheEvict:缓存清除

* key:指定要清除的数据

* allEntries = true:指定清除这个缓存中所有的数据

* beforeInvocation = false:缓存的清除是否在方法之前执行

* 默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除

*

* beforeInvocation = true:

* 代表清除缓存操作是在方法运行之前执行,无论方法是否出现异常,缓存都清除

*

*

*/

@CacheEvict(value="emp",beforeInvocation = true,key = "#id")

public void deleteEmp(Integer id){

System.out.println("deleteEmp:"+id);

//employeeMapper.deleteEmpById(id);

int i = 10/0;

}

@Caching

// @Caching 定义复杂的缓存规则

@Caching(

cacheable = {

@Cacheable(value="emp",key = "#lastName")

},

put = {

@CachePut(value="emp",key = "#result.id"),

@CachePut(value="emp",key = "#result.email")

}

)

public Employee getEmpByLastName(String lastName){

return employeeMapper.getEmpByLastName(lastName);

}

点击复制链接 与好友分享!回本站首页
上一篇:计算机网络基本知识解析
下一篇:centos 7 安装jdk1.8解析
相关文章
图文推荐
点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站