工作原理:
- 自动配置类(CacheAutoConfiguration) 会根据这个注解导入缓存的组件默认使用的配置类是
SimpleCacheConfiguration
- 打开SimpleCacheConfiguration会发现这个默认配置类会先判断spring容器中是否存在CacheManager,通过这个类的实现类(ConcurrentMapCacheManager)获取或者创建缓存(ConcurrentMapCache)类,然后把数据放入到ConcurrentMap中
通过上面所示的是springboot默认的配置我们可以来配置redis缓存,我们可以仿照RedisCacheConfiguration配置我们自己的RedsiCache
- 引入redis的start,容器保存的是RedisCacheManager,这时候默认的SimpleCacheManager就会失效
- RedisCacheManager会帮我们创建RedsiCache作为缓存组件,RedsiCache操作redis来保存数据(这些都是默认配置的但是保存的时候都是使用JdkSerializationRedisSerializer序列化以后的 所以我们如果要保存JSON格式的数据就需要自己配置)
缓存注解参数:
代码演示:
项目结构:
1.引入pom文件
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
2.在主程序类开启支持缓存的注解
@MapperScan("com.zjh.cache.mapper") @SpringBootApplication @EnableCaching public class SpringbootCacheDemo01Application { public static void main(String[] args) { SpringApplication.run(SpringbootCacheDemo01Application.class, args); } }
3.编写业务代码
package com.zjh.cache.entiy; import java.io.Serializable;
/** * 实体类 */ public class Employee implements Serializable { private Integer id; private String lastName; private Integer gender; private String email; private Integer dId; public void setId(Integer id) { this.id = id; } public void setLastName(String lastName) { this.lastName = lastName; } public void setGender(Integer gender) { this.gender = gender; } public void setEmail(String email) { this.email = email; } public void setdId(Integer dId) { this.dId = dId; } public Integer getId() { return id; } public String getLastName() { return lastName; } public Integer getGender() { return gender; } public String getEmail() { return email; } public Integer getdId() { return dId; } }
package com.zjh.cache.mapper; import com.zjh.cache.entiy.Employee; import org.apache.ibatis.annotations.*; @Mapper public interface EmployeeMapper { @Select("select * from employee where id=#{id}") public Employee getEmpById(Integer id); @Insert("insert into employee(lastName,email,gender,dId) values(#{lastName},#{email},#{gender},#{dId})") public void insertEmp(Employee employee); @Update("update employee set lastName=#{lastName},email=#{email},gender=#{gender},dId=#{dId} where id=#{id}") public void updateEmp(Employee employee); @Delete("delete from employee where id=#{id}") void deleteEmpById(Integer id); @Select("select * from employee where lastName=#{lastName}") Employee getEmpByName(String lastNmae); }
package com.zjh.cache.service; import com.zjh.cache.entiy.Employee; import com.zjh.cache.mapper.EmployeeMapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.cache.Cache; import org.springframework.cache.annotation.*; import org.springframework.data.redis.cache.RedisCacheManager; import org.springframework.stereotype.Service; /** * CacheConfig: 抽取缓存 的公共配置设置key值的前缀 * * cacheManager:指定缓存管理器 */ @CacheConfig(cacheNames = "emp",cacheManager = "empRedisCacheManager") @Service public class EmployeeService { @Autowired EmployeeMapper employeeMapper; //使用缓存管理器得到缓存操作数据 @Qualifier("empRedisCacheManager") @Autowired RedisCacheManager empRedisCacheManager; /** * ctrl +n * Cacheable 将方法运行的结果进行缓存,以后要用相同的数据直接从缓存中获取,不用在调用方法 * 属性: * 1.cacheNames/value 指定缓存组件(数据库)的名字;将方法的返回值放在那个缓存中 以数组的方式可以写多个名字 * 2.condition 满足该条件的才缓存 * 3.unless 满足该条件下的不缓存 * 4.sync 是否异步 * condition = "#id==1" * @param id * @return */ /** * 将方法的运行结果进行缓存;以后再要相同的数据,直接从缓存中获取,不用调用方法; * CacheManager管理多个Cache组件的,对缓存的真正CRUD操作在Cache组件中,每一个缓存组件有自己唯一一个名字; * * * 原理: * 1、自动配置类;CacheAutoConfiguration * 2、缓存的配置类 * org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration * org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration * org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration * org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration * org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration * org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration * org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration * org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration * org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration * org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration【默认】 * org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration * 3、哪个配置类默认生效:SimpleCacheConfiguration; * * 4、给容器中注册了一个CacheManager:ConcurrentMapCacheManager * 5、可以获取和创建ConcurrentMapCache类型的缓存组件;他的作用将数据保存在ConcurrentMap中; * * 运行流程: * @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 * * * 几个属性: * cacheNames/value:指定缓存组件的名字;将方法的返回结果放在哪个缓存中,是数组的方式,可以指定多个缓存; * * key:缓存数据使用的key;可以用它来指定。默认是使用方法参数的值 1-方法的返回值 * 编写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:是否使用异步模式 * @param id * @return * */ @Cacheable(cacheNames = "emp",key = "#id") public Employee getEmpById(Integer id){ System.out.println("jinlaile"); Employee employee=employeeMapper.getEmpById(id); return employee; } //不使用注解把数据存储到缓存中 public Employee getEmpByIds(Integer id){ System.out.println("jinlaile"); Employee employee=employeeMapper.getEmpById(id); Cache cache=empRedisCacheManager.getCache("emp"); cache.put("emp:1",employee); return employee; } /** * @Cacheput:既调用方法,又更新缓存数据(修改了数据库某个数据,同时跟新缓存) * 要保证更新前后存储的key值是一个值,默认是传入的参数 * 1.调用目标方法 * 2.将结果更新到缓存 * #employee.id也可以用#result.id (Cacheable不能用#result.id) * */ /** * @CachePut:既调用方法,又更新缓存数据;同步更新缓存 * 修改了数据库的某个数据,同时更新缓存; * 运行时机: * 1、先调用目标方法 * 2、将目标方法的结果缓存起来 * * 测试步骤: * 1、查询1号员工;查到的结果会放在缓存中; * key:1 value:lastName:张三 * 2、以后查询还是之前的结果 * 3、更新1号员工;【lastName:zhangsan;gender:0】 * 将方法的返回值也放进缓存了; * key:传入的employee对象 值:返回的employee对象; * 4、查询1号员工? * 应该是更新后的员工; * key = "#employee.id":使用传入的参数的员工id; * key = "#result.id":使用返回后的id * @Cacheable的key是不能用#result * 为什么是没更新前的?【1号员工没有在缓存中更新】 * */ @CachePut(value = "emp",key = "#employee.id") public Employee updateEmp(Employee employee){ employeeMapper.updateEmp(employee); return employee; } /** * @CacheEvict:缓存清除(删除数据) * allEntries=true 指定清楚这个缓存中的所有数据 * beforeInvocation =fales 缓存的清除是否在方法之前执行 默认是方法之后执行(方法执行异常就不会被清楚) */ @CacheEvict(value = "emp",key = "#id") public void deleteEmp(Integer id) { System.out.println("shanchu"); employeeMapper.deleteEmpById(id); } /** * Caching:前面那个注解会查询数据库,后面那个会查缓存 * @param lastName * @return */ @Caching(cacheable = { @Cacheable(key="#lastName") },put = { @CachePut(key = "#result.id"), @CachePut(key = "#result.email") }) public Employee getEmpByName(String lastName){ System.out.println("进缓存了"); Employee employee=employeeMapper.getEmpByName(lastName); return employee; } }
package com.zjh.cache.controller; import com.zjh.cache.entiy.Employee; import com.zjh.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 getEmp(@PathVariable Integer id){ Employee employee=employeeService.getEmpById(id); return employee; } @GetMapping("/emp") public Employee updateEmp(Employee employee){ Employee employee1=employeeService.updateEmp(employee); return employee; } @GetMapping("/delete/{id}") public String deleteEmp(@PathVariable Integer id){ employeeService.deleteEmp(id); return "success"; } @GetMapping("/getemp/{lastName}") public Employee getEmpByName(@PathVariable("lastName") String lastName){ return employeeService.getEmpByName(lastName); } }
package com.zjh.cache.config; import com.zjh.cache.entiy.Department; import com.zjh.cache.entiy.Employee; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.data.redis.cache.RedisCacheManager; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer; import java.net.UnknownHostException; @Configuration public class MyRedisConfig { //自己定义一个序列化器 @Bean public RedisTemplate<Object,Employee> empRedisTemplate( RedisConnectionFactory redisConnectionFactory) throws UnknownHostException{ RedisTemplate<Object,Employee> template=new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); //创建json序列化器 Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class); template.setDefaultSerializer(serializer); return template; } @Bean public RedisTemplate<Object,Department> deptRedisTemplate( RedisConnectionFactory redisConnectionFactory) throws UnknownHostException{ RedisTemplate<Object,Department> template=new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); //创建json序列化器 Jackson2JsonRedisSerializer<Department> serializer = new Jackson2JsonRedisSerializer<Department>(Department.class); template.setDefaultSerializer(serializer); return template; } //自定义编写Redis缓存管理器 @Primary //默认这个为首选 @Bean public RedisCacheManager empRedisCacheManager(RedisTemplate<Object,Employee> empRedisTemplate){ RedisCacheManager cacheManager=new RedisCacheManager(empRedisTemplate); cacheManager.setUsePrefix(true); return cacheManager; } @Bean public RedisCacheManager deptRedisCacheManager(RedisTemplate<Object,Department> deptRedisTemplate){ RedisCacheManager cacheManager=new RedisCacheManager(deptRedisTemplate); cacheManager.setUsePrefix(true); return cacheManager; } }
测试:
查询id为1的数据@Cacheable(第一次查询要进入数据库中查询 并且会把结果缓存到redis中,后面的查询就会只查询缓存的数据并不会进入数据库)
更新id为1的数据@Cacheput(先更新数据库,然后把更新的数据放入到缓存中)
删除id为1的数据@CacheEvict (数据库和缓存都会删除)
第一次写博客有很多不足的地方还望大家谅解,后面还会更新springboot整合rabbitmq