SpringBoot和缓存

最新推荐文章于 2024-06-09 20:07:15 发布
原创 最新推荐文章于 2024-06-09 20:07:15 发布 · 5.8k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨SpringBoot中的缓存机制，包括JSR107规范下的JCache API介绍，Spring Boot如何整合Mybatis实现数据缓存，以及@Cacheable、@CachePut和@CacheEvict注解的具体应用。
Spring Boot的初体验和自动配置的探究 ：

简介

JSR是Java Specification Requests的缩写，意思是Java 规范提案。是指向JCP(Java Community Process)提出新增一个标准化技术规范的正式请求。任何人都可以提交JSR，以向Java平台增添新的API和服务。JSR已成为Java界的一个重要标准。

2012年10月26日JSR规范委员会发布了JSR 107（JCache API）的首个早期草案。自该JSR启动以来，已经过去近12年时间，因此该规范颇为Java社区所诟病，但由于目前对缓存需求越来越多，因此专家组加快了这一进度。

JCache规范定义了一种对Java对象临时在内存中进行缓存的方法，包括对象的创建、共享访问、假脱机（spooling）、失效、各JVM的一致性等，可被用于缓存JSP内最经常读取的数据，如产品目录和价格列表。利用JCACHE，多数查询的反应时间会因为有缓存的数据而加快（内部测试表明反应时间大约快15倍）。

内容

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设置。

AIpCqA.png

重要概念

AIpUsJ.png

AIpRLd.png

环境搭建

AIpLLj.png

AI9MlD.png

SQL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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;

Bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.hph.cache.bean;

public class Department {
	
	private Integer id;
	private String departmentName;
	
	
	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}
	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 + "]";
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package com.hph.cache.bean;

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

整合Mybatis

配置数据源
1
2
3
4
spring.datasource.url=jdbc:mysql://192.168.1.110:3306/spring_cache
spring.datasource.data-username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
数据准备

AIiSYt.png

注解版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.hph.cache.mapper;

import com.hph.cache.bean.Employee;
import org.apache.ibatis.annotations.*;

@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 deleteEmp(Integer id);

    @Insert("INSERT INTO employee(lastName,email,gender,d_id) VALUESE(#{lastName},#{email},#{gender},#{dId}) ")
    public void insertEmployee(Employee employee);
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.hph.cache;

import com.hph.cache.bean.Employee;
import com.hph.cache.mapper.EmployeeMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootCacheApplicationTests {
    @Autowired
    EmployeeMapper employeeMapper;

    @Test
    public void getEmpById() {
        Employee emp = employeeMapper.getEmpById(1);
        System.out.println(emp);
    }

}

AIinf0.png

AIifc8.png

AIihjS.png

因为没有开启驼峰命名法，数据库中的字段和JavaBean中的字段未完全对应，在application.properties中配置驼峰命名。

1
2
3
4
5
spring.datasource.url=jdbc:mysql://192.168.1.110:3306/spring_cache
spring.datasource.username=root
spring.datasource.password=123456
#驼峰命名开启
mybatis.configuration.map-underscore-to-camel-case=true

AIiXcT.png

使用缓存

添加@EnableCaching的注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.hph.cache;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@MapperScan("com.hph.cache.mapper")
@SpringBootApplication
@EnableCaching  //开启基于注解的缓存
public class SpringbootCacheApplication {

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

}

开启DEBUG

1
2
3
4
5
6
7
spring.datasource.url=jdbc:mysql://192.168.1.110:3306/spring_cache
spring.datasource.username=root
spring.datasource.password=123456
#驼峰命名开启
mybatis.configuration.map-underscore-to-camel-case=true  
#开启debug
logging.level.com.hph.cache.mapper=debug

AIFyKU.png

AIpQZn.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


package org.springframework.cache.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.Callable;

import org.springframework.core.annotation.AliasFor;

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {

	@AliasFor("cacheNames")
	String[] value() default {};

    //指定缓存的名字  
    //CacheManager管理多个组件，对缓存的真正的CRUD操作在Cache组件中，每一个缓存操作有自己唯一的名字
	@AliasFor("value")
	String[] cacheNames() default {};
	//缓存数据使用的key可以用它来指定，默认是方法的参数值。
	String key() default "";

	//主键key的生成器：可以自己指定key的生成器组件ID 
    //  key/keyGenerator  二者选一者使用
	String keyGenerator  () default "";

	//指定缓存管理器
	String cacheManager() default "";


	String cacheResolver() default "";

	//指定符合条件下才缓存
	String condition() default "";
	
	//否定缓存,当unless指定的条件为true,方法的返回值就不会被缓存,可以取到结果进行判断
	String unless() default "";


	boolean sync() default false;

}
名字位置描述示例
methodNameroot object当前被调用的方法名#root.methodName
methodroot object当前被调用的方法#root.method.name
targetroot object当前被调用的目标对象#root.target
targetClassroot object当前被调用的目标对象类#root.targetClass
argsroot object当前被调用的方法的参数列表#root.args[0]
cachesroot object当前方法调用使用的缓存列表（如@Cacheable(value={“cache1”, “cache2”})），则有两个cache#root.caches[0].name
argument nameevaluation context方法参数的名字. 可以直接 #参数名 ，也可以使用 #p0或#a0 的形式，0代表参数的索引；#iban 、 #a0 、 #p0
resultevaluation context方法执行后的返回值（仅当方法执行之后的判断有效，如‘unless’，’cache put’的表达式 ’cache evict’的表达式beforeInvocation=false）#result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.hph.cache.service;

import com.hph.cache.bean.Employee;
import com.hph.cache.mapper.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    //将方法的运行结果进行缓存,如果有相同的数据直接从缓存中获取不用调用方法
    @Cacheable(cacheNames = {"emp"})
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.hph.cache;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@MapperScan("com.hph.cache.mapper")
@SpringBootApplication
@EnableCaching  //开启基于注解的缓存
public class SpringbootCacheApplication {

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

}

Aokec6.png

AokdHg.png

缓存生效了。

流程

在CacheAutoConfiguration中

1
2
3
4
5
6
7
8
9
10
11
12
13
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;
	}

}
1
2
3
4
5
public interface ImportSelector {

	String[] selectImports(AnnotationMetadata importingClassMetadata);

}

我们试着在CacheAutoConfiguration中打断点。看其加载的配置类。

AoEakQ.png

AoZwMq.png

AoeKkF.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//给容器中注册了一个CacheManager;ConcurrentMapCacheManager
//可以获取和创建ConcurrentMapCache类型的缓存的缓存组件
class SimpleCacheConfiguration {
	
	private final CacheProperties cacheProperties;

	private final CacheManagerCustomizers customizerInvoker;

	SimpleCacheConfiguration(CacheProperties cacheProperties,
			CacheManagerCustomizers customizerInvoker) {
		this.cacheProperties = cacheProperties;
		this.customizerInvoker = customizerInvoker;
	}

	@Bean
    //查看ConcurrentMapCacheManager
	public ConcurrentMapCacheManager cacheManager() {
		ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
		List<String> cacheNames = this.cacheProperties.getCacheNames();
		if (!cacheNames.isEmpty()) {
			cacheManager.setCacheNames(cacheNames);
		}
		return this.customizerInvoker.customize(cacheManager);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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);
				this.cacheMap.put(name, cache);
			}
		}
	}
	return cache;
}

//创建一个缓存对象
protected Cache createConcurrentMapCache(String name) {
	SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
	return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256),
			isAllowNullValues(), actualSerialization);

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

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

    核心：
       1）、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
       2）、key使用keyGenerator生成的，默认是SimpleKeyGenerator

1
2
3
4
5
6
7
8
9
10
11
12
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    //将方法的运行结果进行缓存,如果有相同的数据直接从缓存中获取不用调用方法
    @Cacheable(cacheNames = {"emp"},key = "#root.methodName+'['+#id+']'")
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }
}

AolZ8S.png

自定义myKeyGenerator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.hph.cache.config;

import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;
import java.util.Arrays;

@Configuration
public class MyCacheConfig {

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator(){

            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName()+"["+ Arrays.asList(params).toString()+"]";
            }
        };
    }
}

Ao1pGT.png

注意要关闭debug=true

Ao3E6g.png

1
2
3
4
5
6
7
8
9
10
11
12
13
@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    //condition = "#a0>1 第一个参数的值>>1的时候可以进行缓存 除非a0参数是2
    @Cacheable(cacheNames = {"emp"},keyGenerator = "myKeyGenerator",condition = "#a0>0",unless = "#a0==2")
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }
}

Ao8CDJ.png

CachePut

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CachePut {
//和Cacheable基本相似
	@AliasFor("cacheNames")
	String[] value() default {};

	@AliasFor("value")
	String[] cacheNames() default {};

	String key() default "";

	String keyGenerator() default "";

	String cacheManager() default "";

	String cacheResolver() default "";

	String condition() default "";

	String unless() default "";

}
实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.hph.cache.service;

import com.hph.cache.bean.Employee;
import com.hph.cache.mapper.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    //condition = "#a0>1 第一个参数的值>>1的时候可以进行缓存 除非a0参数是2
    @Cacheable(cacheNames = {"emp"}/*, keyGenerator = "myKeyGenerator", condition = "#a0>0", unless = "#a0==2"*/)
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }

    /**
     * @CachePut即调用方法,又更新缓存数据 修改了数据库的某个数据, 同时更新缓存
     *运行时机:先调用目标方法,现将目标方法的结果缓存起来
     */
    @CachePut(value = "emp")
    public Employee updateEmp(Employee employee) {
        System.out.println("updateEmp"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.hph.cache.service;

import com.hph.cache.bean.Employee;
import com.hph.cache.mapper.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    //condition = "#a0>1 第一个参数的值>>1的时候可以进行缓存 除非a0参数是2
    @Cacheable(cacheNames = {"emp"}/*, keyGenerator = "myKeyGenerator", condition = "#a0>0", unless = "#a0==2"*/)
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }

    /**
     * @CachePut即调用方法,又更新缓存数据 修改了数据库的某个数据, 同时更新缓存
     *运行时机:先调用目标方法,现将目标方法的结果缓存起来
     */
    @CachePut(value = "emp")
    public Employee updateEmp(Employee employee) {
        System.out.println("updateEmp"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.hph.cache.controller;

import com.hph.cache.bean.Employee;
import com.hph.cache.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EmployeeController {
    @Autowired
    EmployeeService employeeService;

    @GetMapping("/emp/{id}")
    public Employee getEmployee(@PathVariable("id") Integer id) {
        Employee emp = employeeService.getEmp(id);
        return emp;
    }

    @GetMapping("/emp")
    public Employee update(Employee employee) {
        Employee emp = employeeService.updateEmp(employee);
        return emp;

    }
}
测试步骤

  1. 查询1号员工查到的j结果会放在缓存中。

    key:1 value:LastName=清风丶

AotWSx.png

2.以后查询还是之前的结果

3.更新员工信息1号员工信息【LastName=清风丶；email=qingfeng@gmail.com】

将方法的返回值也放进了缓存

key:传入的employee对象 value:返回的employee对象

AoUSv6.png

4.查询员工

AoaZo4.png1号员工没有在缓存中更新。

key=“#employee。id”使用传入参数员工的id；

key=“result.id”使用返回后的id

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.hph.cache.service;

import com.hph.cache.bean.Employee;
import com.hph.cache.mapper.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    //condition = "#a0>1 第一个参数的值>>1的时候可以进行缓存 除非a0参数是2
    @Cacheable(cacheNames = {"emp"}/*, keyGenerator = "myKeyGenerator", condition = "#a0>0", unless = "#a0==2"*/)
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }

    /**
     * @CachePut即调用方法,又更新缓存数据 修改了数据库的某个数据, 同时更新缓存
     *运行时机:先调用目标方法,现将目标方法的结果缓存起来
     */
    @CachePut(value = "emp",key = "#result.id ")
    public Employee updateEmp(Employee employee) {
        System.out.println("updateEmp"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }
}

Aow9K0.png

AowFVU.png

AowlVO.png

查找

AowYRA.png

已经更新过来了

CacheEvict

EmployeeService

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package com.hph.cache.service;

import com.hph.cache.bean.Employee;
import com.hph.cache.mapper.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    //condition = "#a0>1 第一个参数的值>>1的时候可以进行缓存 除非a0参数是2
    @Cacheable(cacheNames = {"emp"}/*, keyGenerator = "myKeyGenerator", condition = "#a0>0", unless = "#a0==2"*/)
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id + "号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }

    /**
     * @CachePut即调用方法,又更新缓存数据 修改了数据库的某个数据, 同时更新缓存
     *运行时机:先调用目标方法,现将目标方法的结果缓存起来
     */
    @CachePut(value = "emp",key = "#result.id ")
    public Employee updateEmp(Employee employee) {
        System.out.println("updateEmp"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }

    /**
     * @Cachevict :缓存清除
     * key: 指定要清除的数据
     */
    @CacheEvict(value = "emp",key = "#id")
    public void deleteEmp(Integer id){
        System.out.println("deletEmp"+id);
        employeeMapper.deleteEmpById(id);
    }

}

EmployeeController

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.hph.cache.controller;

import com.hph.cache.bean.Employee;
import com.hph.cache.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EmployeeController {
    @Autowired
    EmployeeService employeeService;

    @GetMapping("/emp/{id}")
    public Employee getEmployee(@PathVariable("id") Integer id) {
        Employee emp = employeeService.getEmp(id);
        return emp;
    }

    @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 "删除成功";
    }
}

Ao0lyq.png

(⊙﹏⊙)出现乱码了 先忽略吧

Ao08mV.png

Ao0yTO.png

1
2
3
4
5
6
//删除缓存中的所有数据
@CacheEvict(value = "emp",key = "#id",allEntries = true)
public void deleteEmp(Integer id){
    System.out.println("deletEmp"+id);
    employeeMapper.deleteEmpById(id);
}

AoBSBV.png

数据被全部清空

AoBGjI.png

1
2
3
4
5
6
7
//缓存默认清除才足在方法执行之后执行;如果出现异常缓存不会被清除
@CacheEvict(value = "emp")
public void deleteEmp(Integer id){
    System.out.println("deletEmp"+id);
  //  employeeMapper.deleteEmpById(id);
    int i = 10/0;
}

AoBRET.png

AoBbb6.png

2号数据库缓存也被清除掉了

AoBvPe.png

清风笑丶
关注
Springboot 注解缓存使用教程
yh4494的博客
01-15 630
Spring Boot 提供了强大的缓存抽象，开发者可以通过注解快速实现缓存功能，从而提高系统性能。本教程将全面介绍 Spring Boot 提供的缓存相关注解及其作用，并结合示例讲解实际应用。
SpringBoot：缓存 + 搭建Redis缓存环境
ChinaDragon10的博客
05-14 1432
SpringBoot搭建Redis缓存 注解版的 mybatis @CacheConfig @Cacheable @CachePut：既调用方法，又更新缓存数据；同步更新缓存 @CacheEvict：缓存清除 @Caching：定义复杂的缓存规则 CacheManager管理多个Cache组件的，对缓存的真正CRUD操作在Cache组件中，每一个缓存组件有自己唯一一个名字； 搭建Redis缓存环境及测试 RedisTemplate 自定义CacheManager
springBoot--web--http缓存机制测试
m0_50207524的博客
10-21 688
一套系统适配多端数据返回import com/*** @date 2023年10月21日 12:50// 支持哪种媒体类型 super(new MediaType("text" , "yaml" , Charset . forName("UTF-8")));> clazz) {// 只要对象类型，不要基本类型 return true;
在Spring Boot中实现HTTP缓存的方法
10-17
缓存是HTTP协议的一个强大功能，但由于某些原因，它主要用于静态资源，如图像，CSS样式表或JavaScript文件。本文重点给大家介绍在Spring Boot中实现HTTP缓存的方法，感兴趣的朋友跟随小编一起看看吧
SpringBoot 集成Ehcache实现缓存
11-02
使用springboot 集成ehcache，里面附带数据库建库脚本，controller，service以及对ehcache集成，操作的详细样例，使用spring注解形式。
HTTP缓存介绍及在spring boot中设置HTTP缓存
Hello World ^—^
06-20 1万+
介绍 在工作之余阅读缓存相关的书籍时，看到了http缓存相关的知识，HTTP 缓存机制是一个 web 性能优化的重要手段，无论是做前端还是做web后台，都可能会用得到它，应该是知识体系库中的一个基础环节，以前这一块学的不是很扎实，现在巩固巩固。 HTTP缓存可以说是浏览器缓存的其中一种，浏览器缓存也包含很多内容： HTTP 缓存、indexDB、cookie、localstorage 等等。这里我...
Spring Boot 控制 HTTP API 缓存
小魏的奇妙世界
05-24 4151
Spring Boot控制 HTTP API 缓存，减少 网关传输压力和服务压力
springboot缓存一致性解决
09-03
本文将深入探讨Spring Boot中如何处理和解决缓存一致性问题。 首先，我们需要理解缓存的一致性模型。常见的有三种：强一致性、最终一致性和读已写一致性（Read-Your-Writes Consistency）。在分布式系统中，强一致...
SpringBoot集成缓存功能
最新发布
天天向上
06-09 1619
Java Caching定义了五个核心接口，分别是：CachingProvider、CacheManager、Cache、Entry和Expiry。
SpringBoot Redis缓存数据实现解析
08-25
SpringBoot 中提供了两种方式来支持缓存：注解驱动的缓存和 XML 声明的缓存。这里我们主要介绍纯 Java 配置的缓存，需要在配置类上添加 `@EnableCaching` 注解，以启用注解驱动的缓存。 在 Redis 缓存中，缓存的...
SpringBoot 缓存
dickysun1987的专栏
06-23 666
SpringBoot 缓存简单实用
Springboot Vue2 开启HTTP缓存、304缓存（协商缓存）、Cache-Control 不生效
weixin_46064703的博客
08-11 870
http缓存（304协商缓存、Cache-Control）不生效
还不会在 SpringBoot 中设置 HTTP 缓存？来造个轮子~
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
09-03 331
????????关注后回复“进群”，拉你进程序员交流群????????作者丨小魏来源丨Java知音（ID：Java_friends）Spring Boot 控制 HTTP缓存HTTP协议的缓存策略可以缩短网页请求资源的距离，减少延迟，节省网络流量，并且由于缓存文件可以重复利用，降低网络负荷，加快客户端响应。如何利用 HTTP缓存 进行一些骚操作呐，是我最近思考的问题。查看了Spring Boot对HTTP缓存的支持也...
如何在SpringBoot中设置HTTP缓存，你知道么？
weixin_44421461的博客
10-03 1557
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 Elast...
SpringBoot 缓存&资源优化
_hello_world_的博客
08-15 1495
页面缓存 1. freemarker 的页面静态化 application.properties 配置实现浏览器缓存 # SPRING RESOURCES HANDLING ([ResourceProperties](https://github.com/spring-projects/spring-boot/tree/v1.5.4.RELEASE/spring-boot-autoc...
第四篇：SpringBoot中Cache缓存的使用
热门推荐
凯耐的博客
09-23 5万+
一、Cache缓存的作用 随着时间的积累，应用的使用用户不断增加，数据规模也越来越大，往往数据库查询操作会成为影响用户使用体验的瓶颈，此时使用缓存往往是解决这一问题非常好的手段之一。Spring 3开始提供了强大的基于注解的缓存支持，可以通过注解配置方式低侵入的给原有Spring应用增加缓存功能，提高数据访问性能。在Spring Boot中对于缓存的支持，提供了一系列的自动化配置，使我们可以非常...
浏览器缓存机制
RaeZhang的博客
09-27 539
前言 一个优秀的缓存策略可以缩短网页请求资源的距离，减少延迟，并且由于缓存文件可以重复利用，还可以减少带宽，降低网络负荷。 对于一个数据请求来说，可以分为发起网络请求、后端处理、浏览器响应三个步骤。 浏览器缓存可以帮助我们在第一和第三步骤中优化性能:比如说直接使用缓存而不发起请求，或者发起了请求但后端存储的数据和前端一致，那么就没有必要再将数据回传回来，这样就减少了响应数据。 缓存位置 浏览器缓存共有四种，且有一定的优先级，当所有缓存都没有命中时才回去进行网络请求。 Service Worker Me
在SpringBoot中缓存HTTP请求响应体(实现请求响应日志的记录)
csdn_0xFFFF的博客
05-07 1265
缓存请求响应体的目的 把一个HTTP的请求，响应信息完整的纪录到日志。是一种常见有效的问题排查，BUG重现的手段。 但是流这种东西，有一个特点就是只能读取/写入一次，不能重复。下一次读写，就是一个空的流，为了实现流的重用，就很有必要，把读取和写入的数据缓存起来， 可以在某个地方，再一次的读取。 实现的思路 HttpServletRequestWrapper HttpServletResponseWrapper 上面2个类，熟悉Servlet的都知道，这俩就是Request和Response的装饰模式实
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值