尚硅谷SpringBoot整合教程(springboot框架实战)--缓存@Cacheable

落日映苍穹つ 2022-12-11 03:18 179阅读 0赞

[尚硅谷SpringBoot整合教程(springboot框架实战)][SpringBoot_springboot]

# 缓存 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 1]

## SpEL语言 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 2]

## 缓存原理 ##

*
         * 将方法的运行结果进行缓存；以后再要相同的数据，直接从缓存中获取，不用调用方法；
         * 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、ConcurrentMapCacheManager可以获取和创建ConcurrentMapCache类型的缓存组件，将数据保存在ConcurrentMap中；

# 1.@Cacheable #

**被@Cacheable注解的方法运行之前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取，  
如果没有查到缓存再调用目标方法，并将目标方法返回的结果，放进缓存中，  
如果再缓存中找到，就直接返回缓存中的结果，不再调用方法。**

## 运行流程： ##

运行流程：
         *   @Cacheable：
         *   1、被@Cacheable注解的方法运行之前，先去查询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指定获取解析器，CacheManager与cacheResolver的作用相同
         *
         *      condition：指定符合条件的情况下才缓存；
         *              ,condition = "#id>0"
         *          condition = "#a0>1"：第一个参数的值》1的时候才进行缓存
         *
         *      unless:否定缓存；当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断
         *              unless = "#result == null"
         *              unless = "#a0==2":如果第一个参数的值是2，结果不缓存；
         *      sync：是否使用异步模式

## 核心： ##

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

### 1. cacheNames/value： ###

**指定缓存组件的名字;将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存；**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][20200928204348633.png_pic_center]

@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;
        }

### 2. key： ###

**不指定key 默认是使用方法参数的值**

\*\*缓存数据使用的key；可以用它来指定。默认是使用方法参数的值 \*\*  
编写SpEL； \#i d;参数id的值 \#a0 \#p0 \#root.args\[0\]  
getEmp\[2\]  
![在这里插入图片描述][20200928204820922.png_pic_center]  
![在这里插入图片描述][20200928204854176.png_pic_center]

### 3. keyGenerator： ###

**key的生成器；可以自己指定key的生成器的组件id**  
key/keyGenerator：二选一使用;

*  自定一个KeyGenerator
 *

package com.atguigu.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()+"]";
                }
            };
        }
    }

![在这里插入图片描述][20200928205113821.png_pic_center]

![在这里插入图片描述][20200928205148825.png_pic_center]

### 4. condition:缓存查询 ###

**指定符合条件的情况下才缓存；**  
,condition = “\#id>0”  
condition = “\#a0>1”：第一个参数的值》1的时候才进行缓存

![在这里插入图片描述][20200928205429388.png_pic_center]

![在这里插入图片描述][20200928205331239.png_pic_center]

### 5. unless:否定缓存； ###

**当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断**  
unless = “\#result == null”  
unless = “\#a0==2”:如果第一个参数的值是2，结果不缓存；  
![在这里插入图片描述][20200928205646252.png_pic_center]

### 6. sync：是否使用异步模式 ###

缓存方式默认为同步  
如果开启异步sync=true, unless参数就不起作用了

# 2. @CachePut:缓存更新 #

**@CachePut与@Cacheable不同的是，@CachePut先调用方法，再将方法的返回值放入缓存中；同步更新缓存**

修改了数据库的某个数据，同时更新缓存；
     运行时机：
      1、先调用目标方法
      2、将目标方法的结果缓存起来

* @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号员工没有在缓存中更新】

![在这里插入图片描述][20200928211903260.png_pic_center]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 4]

# 3.@CacheEvict:缓存清除 #

@CacheEvict：缓存清除
         *  key：指定要清除的数据
         *  allEntries = true：指定清除这个缓存中所有的数据
         *  beforeInvocation = false：缓存的清除是否在方法之前执行
         *      默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除
         *
         *  beforeInvocation = true：
         *      代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除
         *

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 7]

## beforeInvocation = true ##

**@CacheEvict默认在方法执行之后才执行删除缓存；  
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;
        }

# 4.@Caching 定义复杂的缓存规则 #

**@Caching相当于 @Cacheable、 @CachePut、@CacheEvict的组合注解**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 8]

// @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);
        }

# 5.@CacheConfig:抽取缓存的公共配置 #

@CacheConfig(cacheNames="emp") //抽取缓存的公共配置
    @Service
    public class EmployeeService { 
    
     @Cacheable(key = "#id")
        public Employee getEmp(Integer id){ 
            System.out.println("查询"+id+"号员工");
            Employee emp = employeeMapper.getEmpById(id);
            return emp;
        }
       @CachePut(key = "#result.id")
        public Employee updateEmp(Employee employee){ 
            System.out.println("updateEmp:"+employee);
            employeeMapper.updateEmp(employee);
            return employee;
        }
         @CacheEvict(beforeInvocation = true/*key = "#id",*/)
        public void deleteEmp(Integer id){ 
            System.out.println("deleteEmp:"+id);
            //employeeMapper.deleteEmpById(id);
            int i = 10/0;
        }
    ......
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 9]

# 6.调用缓存方法 #

import com.atguigu.cache.bean.Employee;
    import com.atguigu.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.PostMapping;
    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 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);
        }
    
    }

缓存（整合Redis），消息中间件（整合RabbitMQ），检索（整合ElasticSearch），任务（异步任务，定时任务，邮件任务），安全（整合SpringSecurity），分布式（Zookeeper/dubbo，整合SpringCloud），SpringBoot应用监管；

[SpringBoot_springboot]: https://www.bilibili.com/video/BV1KW411F7oX?p=3
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/02d955f8d11e4a32ae19713d2a3e0ab7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/9c0d97ccd1794ab1b0e109daaf866af4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/c9a037f3764e4fd5a372b75d5e023e3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/2754bf31ea19471aafccfcc20ddb3c6c.png
[20200928204348633.png_pic_center]: /images/20221123/1c458155f920456cb7fc58de405270bf.png
[20200928204820922.png_pic_center]: /images/20221123/21452344b25748a0809dd64a38d85521.png
[20200928204854176.png_pic_center]: /images/20221123/c29f7af804af48cbbbae13f96abbb7eb.png
[20200928205113821.png_pic_center]: /images/20221123/9a1f3fa9985641ec81ec67ec31080902.png
[20200928205148825.png_pic_center]: /images/20221123/cc4064d5e3654cfdbed0ec2249c2bc18.png
[20200928205429388.png_pic_center]: /images/20221123/bfcc239ddaea41a59adfbc2175bfdee1.png
[20200928205331239.png_pic_center]: /images/20221123/f16da03817ce4cff9739b9fd0daa0a72.png
[20200928205646252.png_pic_center]: /images/20221123/42e5c834132c4ac0b38241d8339fc882.png
[20200928211903260.png_pic_center]: /images/20221123/87a14bd978bb41afa55a06359a2558ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/eef3f51e8d8640be9e3999285c523f11.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/6da8a3a5f8cd4a58a056e3d83ab21da9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/9010b6df37a94ad0848a1b061e7c7198.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/0a37161c76ec4aed817bbfb71c9db60f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/b9897337b3b347299f1847a1a3673edb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/32cb4103ad2b4595b63c0c5b8e9dd935.png