SpringBoot08-缓存

JSR107缓存规范

1. Java Caching定义了5个核心接口, 分别是CachingProvider, CacheManager, Cache, Entry, Expiry.
2. CachingProvider定义了创建, 配置, 获取, 管理和控制多个CacheManager. 一个应用可以在运行期访问多个CachingProvider.
3. CacheManager定义了创建, 配置, 获取, 管理和控制多个唯一命名的Cache, 这些Cache存在于CacheManager的上下文中. 一个CacheManager仅被一个CachingProvider所拥有.
4. Cache是一个类似Map的数据结构并临时存储以Key为索引的值, 一个Cache仅被一个CacheManager所拥有.
5. Entry是一个存储在Cache中的key-value对.
6. Expiry每一个存储在Cache中的条目有一个定义的有效期. 一旦超过这个时间, 条目为过期的状态. 一旦过期, 条目将不可访问, 更新和删除. 缓存有效期可以通过ExpiryPolicy设置.
   • 
7. 如果要使用JSR107, 需要导入如下依赖

           <dependency>
               <groupId>javax.cache</groupId>
               <artifactId>cache-api</artifactId>
               <version>1.1.1</version>
           </dependency>

Spring缓存抽象

• 简介

1. JSR107规范的技术复杂性较高, Spring3.1定义了Cache和CacheManager接口来统一不同的缓存技术.
   • 当然, 支持使用JSR107注解来简化我们的开发.
2. Cache接口为缓存的组件规范定义, 包含缓存的各种操作集合.
   • Cache接口下Spring提供了各种xxxCache的实现, 如RedisCache.
3. 每次调用需要缓存功能的方法时, Spring会检查检查指定参数的指定的目标方法是否已经被调用过. 如果有就直接从缓存中获取方法调用后的结果, 如果没有就调用方法并缓存结果后返回给用户. 下次调用直接从缓存中获取.
4. 使用Spring缓存抽象时需要关注两点
   • 确定方法需要被缓存以及他们的缓存策略.
   • 从缓存中读取之前缓存存储的数据.

• 几个重要概念

1. Cache: 缓存接口, 定义缓存操作, 实现有RedisCache, EhCacheCache等.
2. CacheManager: 缓存管理器, 管理各种Cache.
3. @Cacheable: 主要针对方法配置, 能根据方法的请求参数对其结果进行缓存.
4. @CacheEvict: 清空缓存, 如给删除方法上加该注解.
5. @CachePut: 保证方法被调用, 又希望结果被缓存, 经常用于更新缓存.
   • 和@Cacheable的区别
     • @Cacheable是注解中有就不调用方法了.
     • 而@CachePut无论如何都会调用方法, 然后把新结果存入缓存.
6. @EnableCaching: 开启基于注解的缓存.
7. keyGenerator: 缓存数据时key生成策略.
8. serialize: 缓存数据时value序列化策略.

• 搭建缓存的基本环境

1. 引入spring-boot-starter-cache模块

           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-cache</artifactId>
           </dependency>

2. 主启动类

   /**
    * 搭建基本环境
    * 1. 创建数据库spring_cache, 并创建department和employee表
    * 2. 创建javaBean封装数据
    * 3. 整合Mybatis操作数据库
    *      1. 配置数据源信息
    *      2. 使用注解版Mybatis
    *          1) @MapperScan指定需要扫描的mapper接口所在的包
    *          2) 对应的mapper接口要带@Mapper主机
    *
    * 快速体验缓存
    * 1. 开启基于注解的缓存.
    * 2. 标注缓存注解
    */
   
   @EnableCaching
   @MapperScan("top.binwenhome.cache.mapper")
   @SpringBootApplication
   public class SpringBootCache2Application {
   
       public static void main(String[] args) {
           SpringApplication.run(SpringBootCache2Application.class, args);
       }
   
   }

3. 如EmployeeMapper

   @Mapper
   public interface EmployeeMapper {
   
       @Select("SELECT * FROM employee WHERE id = #{id}")
       public Employee getEmpById(Integer id);
   }

4. 搭建service, controller层

   @Service
   public class EmployeeService {
   
       @Autowired
       private EmployeeMapper employeeMapper;
   
       public Employee getEmp(Integer id) {
           System.out.println("查询" + id + "号员工");
   
           Employee emp = employeeMapper.getEmpById(id);
   
           return emp;
       }
   }
   
   
   @RestController
   public class EmployeeController {
   
       @Autowired
       private EmployeeService employeeService;
   
       @GetMapping("/emp/{id}")
       public Employee getEmployee(@PathVariable("id")Integer id) {
           Employee emp = employeeService.getEmp(id);
           return emp;
       }
   }

• 缓存中的SpEL用法
  • 
• @Cacheable注解

1. 将方法的结果进行缓存, 以后再要相同的数据, 就不用从数据库查了.
2. CacheManager: 管理多个Cache组件, 对缓存的真正CRUD操作在Cache组件中, 每个缓存组件都有一个唯一的名字.
3. 几个属性
   • cacheNames/value: 指定缓存的名字, 将方法的返回结果放在哪个缓存中, 是数组的方式.
   • key/keyGenerator
     • key: 缓存数据使用的key. 可以用它来指定. 默认是使用方法参数的值.
     • keyGenerator: key的生成器: 可以自己指定key的生成器的组件id.
     • 两者二选一.
   • condition: 指定符合条件的情况下, 才缓存.
   • cacheManager: 指定缓存管理器, 或cacheResolver指定缓存解析器.
   • unless: 否定缓存, 当unless指定的条件为true, 方法的返回值就不会被缓存. 可以获取到结果进行排查.
   • sync: 是否使用异步模式, 默认为false, 若使用, 则unless属性不支持.
4. 举例(service方法中)
   • 使用key

     //condition = "#a0<2": 第一个参数的值<2时才进行缓存.
         //unless = "#a0==2" 如果第一个参数的值为2, 其结果不缓存
         @Cacheable(cacheNames = {"emp"}, key = "#root.methodName + '[' + #id + ']'",
                 condition = "#a0<2 and #root.methodName eq 'getEmp'", unless = "#a0==2")
         public Employee getEmp(Integer id) {
             System.out.println("查询" + id + "号员工");
             Employee emp = employeeMapper.getEmpById(id);
             return emp;
         }

   • 使用keyGenerator

         @Cacheable(cacheNames = {"emp"}, keyGenerator = "myKeyGenerator")
         public Employee getEmp(Integer id) {
             System.out.println("查询" + id + "号员工");
             Employee emp = employeeMapper.getEmpById(id);
             return emp;
         }

     • 需要自己手写KeyGenerator的实现加入容器中

       @Configuration
       public class MyCacheConfig {
       
           @Bean("myKeyGenerator")
           public KeyGenerator keyGenerator() {
               return new KeyGenerator() {
                   @Override
                   public Object generate(Object o, Method method, Object... objects) {
                       return method.getName() + "[" + Arrays.asList(objects).toString() + "]";
                   }
               };
           }
       }

• @CachePut

      /**
       * @CachePut: 既调用方法, 又更新缓存数据
       * 1. 修改了数据库的某个数据, 同时更新缓存
       * 2. 运行时机
       *      1. 先调用目标方法
       *      2. 再把目标方法的结果缓存起来
       * 3.测试步骤
       *      1. 查询1号员工, 查到的结果会放到缓存中
       *          key: 1; value: 张三/1
       *      2. 以后查询还是之前的结果
       *      3. 更新1号员工 [lastName=zhangsan; gender=0]
       *          将方法的返回值也放进缓存了, 但它的key是传入的employee对象, 而值是返回的employee对象
       *      4. 查询1号员工
       *          是更新前的员工, 为什么是没更新前的? [1号员工没在缓存中更新]
       *      5. 所以应手动设置key
       *          key="#employee.id"; 或 key="#result.id"
       */
      @CachePut(cacheNames = {"emp"})
      public Employee updateEmp(Employee employee) {
          System.out.println("员工更新: " + employee);
          employeeMapper.updateEmp(employee);
          return employee;
      }
  
  只需要在@CachePut中添加属性key, 设置相应的值即可. (查询的key和更新的key必须一致)

• @CacheEvict

      /**
       * @CacheEvict: 清除缓存
       *  1. 属性
       *      key: 指定要清楚的数据
       *      allEntries: 是否删除所有缓存. 默认为false. (只清空value/cacheNames中设置的缓存.)
       *      beforeInvocation: 缓存的清除是否在方法之前执行, 默认是false.
       *          举个例子: 如果当前方法出错, 若设false, 则不会清空缓存, 若true, 则会.
       */
      @CacheEvict(value = "emp", allEntries = true, beforeInvocation = true)
      public void deleteEmp(Integer id) {
          System.out.println("删除员工" + id);
          employeeMapper.deleteEmpById(id);
      }

• @Caching&CacheConfig
  • @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) {
            System.out.println("根据名字查询" + lastName);
            Employee emp = employeeMapper.getEmpByLastName(lastName);
            return emp;
        }

  • @CacheConfig

    /**
     * 在类上加@CachConfig, 指定cacheNames, 则该类所有的缓存名均为此值.
     */
    @CacheConfig(cacheNames = "emp")
    @Service
    public class EmployeeService {
      
        //...
    }

 整合Redis

1.  默认给容器中注册的CacheManager是: ConcurrentMapCacheManager
   • 可以获取和创建ConcurrentMapCache类型的缓存组件, 其作用是将数据缓存在ConcurrentMap中.
2. 而在开发中, 常用缓存中间件, 如Redis, EhCache等.

• 整合Redis作为缓存

1. 先安装Redis, 使用Docker方法.

   拉取Redis
   docker pull redis:latest
   
   运行Redis
   docker run -d -p 6379:6379 --name myredis docker.io/redis

2. 引入Redis的starter

           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-redis</artifactId>
           </dependency>

3. 配置redis
   • application.properties中配置

     spring.redis.host=192.168.13.129

   • 测试字符串

         //操作k-v都是String的
         @Autowired
         private StringRedisTemplate stringRedisTemplate;
     
         /**
          * Redis五大数据类型
          *  String: stringRedisTemplate.opsForValue() 操作字符串
          *  List:  stringRedisTemplate.opsForList() 操作列表
          *  Set: stringRedisTemplate.opsForSet() 操作集合
          *  Hash: stringRedisTemplate.opsForHash() 操作哈希
          *  ZSet: stringRedisTemplate.opsForZSet() 操作有序集合
          *
          *  而redisTemplate只是泛型和stringRedisTemplate不同
          */
         @Test
         public void test01() {
     
             ValueOperations<String, String> stringOps = stringRedisTemplate.opsForValue();
             //给Redis中保存数据
             //stringOps.append("msg", "hello");
     
             //读取数据
             //String msg = stringOps.get("msg");
             //System.out.println(msg);
     
             //列表中添加数据
             ListOperations<String, String> listOps = stringRedisTemplate.opsForList();
             listOps.leftPush("mylist", "1");
             listOps.leftPush("mylist", "2");
         }

   • 测试对象

         //k-v都是Object的
         @Autowired
         private RedisTemplate redisTemplate;
     
         //测试保存对象
         @Test
         public void test02() {
             //这里Employee必须序列化
             //默认如果保存对象, 使用jdk序列化机制, 序列化后的数据保存到redis中
             Employee emp = employeeMapper.getEmpById(1);
             redisTemplate.opsForValue().set("emp-01", emp);
     }

     • 但此时保存到Redis中的是序列化数据, 很难看.
     • 
   • 将对象以json形式保存
     • 配置自定义序列化规则

       @Configuration
       public class MyRedisConfig {
       
           @Bean
           public RedisTemplate<Object, Employee> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
               RedisTemplate<Object, Employee> template = new RedisTemplate<>();
               template.setConnectionFactory(redisConnectionFactory);
               Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
               template.setDefaultSerializer(serializer);
               return template;
           }
       }

     • 使用

           @Autowired
           private RedisTemplate<Object, Employee> empTemplate;
       
           //测试保存对象
           @Test
           public void test02() {
               Employee emp = employeeMapper.getEmpById(1);
       
               //1.将数据以json的方式保存
               //redisTemplate有默认的序列化规则
               //改变默认的序列化规则
               empTemplate.opsForValue().set("emp-02", emp);
           }

4. 测试缓存
   • 原理: CacheManager -> Cache缓存组件 -> 缓存组件给缓存中CRUD数据.
     • 引入redis的starter后, 容器中保存的是RedisCacheManager.
     • RedisCacheManager帮我们创建RedisCache来作为缓存组件. RedisCache通过Redis缓存数据.
     • 默认保存数据k-v, 都是Object, 利用序列化保存
   • 如何保存为json?
     • 默认创建的RedisCacheManager操作Redis时使用的RedisTemplate<Object, Object>
     • 而默认使用jdk序列化机制.
   • 自定义CacheManager

         @Bean
         public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
             //初始化一个RedisCacheWriter
             RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
             //设置CacheManager的值序列化方式为json序列化
             GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
             RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(jsonRedisSerializer);
             RedisCacheConfiguration redisCacheConfig = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
     
             //设置默认超时过期时间30秒
             redisCacheConfig.entryTtl(Duration.ofSeconds(30));
     
             //初始化RedisCacheManager
             return new RedisCacheManager(redisCacheWriter, redisCacheConfig);
         }

5. 之后, 上述测试缓存的例子如localhost:8080/emp/1 会将结果以json的形式保存在Redis中了.