肝完了，总结了SpringBoot与缓存的知识点，快速掌握

@Configuration
public class RedisConfig {
    //过期时间
    private Duration timeToLive = Duration.ofDays(1);
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory){
        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig().entryTtl(timeToLive)
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
                .disableCachingNullValues();
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(configuration).transactionAware().build();
        return redisCacheManager;
    }
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(keySerializer());
        template.setHashKeySerializer(keySerializer());
        template.setValueSerializer(valueSerializer());
        template.setHashValueSerializer(valueSerializer());
        return template;
    }
    private RedisSerializer<String> keySerializer(){
        return new StringRedisSerializer();
    }
    private RedisSerializer<Object> valueSerializer(){
        return new GenericJackson2JsonRedisSerializer();
    }
}

spring.datasource.username=spring
spring.datasource.password=spring
#开启驼峰命名匹配规则
mybatis.configuration.map-underscore-to-camel-case=true
logging.level.com.dahaiwuliang.cache.mapper=debug
#redis连接
spring.redis.host=192.168.0.108

* Cacheable的运行流程
 * 1、在方法运行之前，先去缓存按value查找Cache，第一次获取不到就会创建
 * 2、去Cache中查找Entry，使用一个key，默认用方法的参数
 *      key是按某种规则创建的，默认是使用的SimpleKeyGenerator生成
 *      SimpleKeyGenerator的生成策略：
 *          如果没有参数，key=new SimpleKey()；
 *          如果有一个参数，key=参数的值
 *          如果有多个参数：key=new SimpleKey(params);
 *
 * 3、如果查到，直接返回；没有查到就调用目标方法
 * 4、将目标方法返回的结果放到缓存里面
 *
 *  cacheNames/value:
 *      指定缓存组件（Cache）的名字，将方法的返回结果放到哪个缓存中，是数组的方式，可以指定多个缓存
 *
 *  key:
 *      Entry里面的key，默认是使用的SimpleKeyGenerator生成；
 *      也可以写SpEL表达式来生成 #a0   #p0  #root.args[0]  #id
 *  keyGenerator:key的生成器，可以自定义一个
 *
 *  cacheManager:指定缓存管理器
 *
 *  condition:指定符合条件的情况下才缓存
 *
 *  unless:否定缓存，和condition正好相反
 *
 *  sync:是否使用异步模式

@RestController
public class EmployeeController {
    @Autowired
    EmployeeService employeeService;
    @GetMapping("/getEmployee")
    public Employee getEmployee(Integer id){
        Employee employee = employeeService.getEmp(id);
        return employee;
    }
    @GetMapping("/updateEmployee")
    public Employee update(Employee employee){
        Employee emp = employeeService.updateEmp(employee);
        return emp;
    }
    @GetMapping("/deleteEmployee")
    public String deleteEmp(Integer id){
        employeeService.deleteEmp(id);
        return "success";
    }
    @GetMapping("/emp/{lastName}")
    public Employee getEmployeeByLastName(@PathVariable("lastName") String lastName){
        return employeeService.getEmployeeByLastName(lastName);
    }
}

public Employee getEmp(Integer id){
        System.out.println("查询"+id+"员工");
        Employee employee = employeeMapper.getEmpById(id);
        Cache cache = cacheManager.getCache("emp");
        cache.put("emp:"+id,employee);
        return employee;
    }
    /**
     * @CachePut:既调用方法，又更新缓存
     * 修改了数据库的数据，并同时更新缓存
     *  运行机制：
     *      1、先调用目标方法；
     *      2、将目标方法的结果缓存起来
     */
    @CachePut(/*value = "emp",*/key="#result.id")
    public Employee updateEmp(Employee employee){
        System.out.println("update:"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }
    /**
     * @CacheEvict:清除缓存
     *  allEntries=true清空这个缓存中的所有数据
     *  beforeInvocation=true代表清空缓存操作是在方法执行前就执行了，无论方法是否出现异常，缓存都会被清除
     */
    @CacheEvict(/*value = "emp",*/key = "#id"/*,allEntries = true*/,beforeInvocation = true)
    public void deleteEmp(Integer id){
        System.out.println("deletEmp:"+id);
        //employeeMapper.deleteEmpById(id);
        int a = 10/0;
    }
    /**
     * @Caching 定义复杂的缓存规则
     */
    @Caching(
            cacheable = {
                    @Cacheable(/*value = "emp",*/key = "#lastName")
            },
            put = {
                    @CachePut(/*value = "emp",*/key = "#result.id")
            }
    )
    public Employee getEmployeeByLastName(String lastName){
        System.out.println("getEmployeeByLastName:"+lastName);
        return employeeMapper.getEmpByLastName(lastName);
    }
}