SpringBoot使用缓存及原理

最新推荐文章于 2024-05-22 14:51:59 发布

lsz1993

最新推荐文章于 2024-05-22 14:51:59 发布

阅读量386

点赞数 1

分类专栏： springboot 文章标签： springboot

本文链接：https://blog.csdn.net/lsz1993/article/details/82850520

版权

springboot 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一.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文件中引入坐标地址


		<dependency>

			<groupId>org.springframework.boot</groupId>

			<artifactId>spring-boot-starter-cache</artifactId>

		</dependency>

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 测试

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

控制台打印情况:

可以看到第一次获取数据是从数据库中获取的，再次输入 http://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);
    }

lsz1993

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot使用缓存及原理

一.JSR107Java Caching 定义了五个核心接口，分别是CachingProvider，CacheManager，Cache，Entry和Expiry。 CachingProvider 定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CacheProvider。 CacheManager 定义了创建、配置、获取、管理和...
复制链接

扫一扫