【SpringBoot1.x】SpringBoot1.x 缓存

SpringBoot1.x 缓存

文章源码

JSR107

Java Caching 定义了 5 个核心接口,分别为:

  • CachingProvider 定义了创建、配置、获取、管理和控制多个 CacheManager。一个应用可以在运行期访问多个 CachingProvider。
  • CacheManager 定义了创建、配置、获取、管理和控制多个唯一命名的 Cache,这些 Cache 存在于 CacheManager 的上下文中。一个 CacheManager 仅被一个 CachingProvider 拥有。
  • Cache 是一个类似 Map 的数据结构并临时存储以 Key 为索引的值。一个 Chache 仅被一个 CacheManager 拥有。
  • Entry 是一个存储在 Cache 中的 key-value 对。
  • Expiry 指每一个存储在 Chche 中的条目有一个定义的有效期,一旦超过这个时间,条目就为过期的状态。一旦过期,条目将不可访问、更新和删除。有效期可以通过 ExpiryPolicy 设置。

【SpringBoot1.x】SpringBoot1.x 缓存

Spring 缓存抽象

Spring3.1 后定义了 org.springframework.cache.Cacheorg.springframework.cache.CacheManager 接口来统一不同的缓存技术,并支持使用 JCache(JSR107) 注解简化我们开发。

  • Cache 接口 为缓存的组件规范定义,包含缓存的各种操作集合;
  • Cache 接口下 Spring 提供了各种 xxxCache 的实现,如 RedisCache、EhCacheCache、ConcurrentMapCache等;
  • 每次调用需要缓存功能的方法时,Spring 会检查指定参数的指定目标方法是否被调用过。如果有就直接从缓存中获取方法调用后的结果,如果没有就调用方法就缓存结果后返回给用户。下次调用直接从缓存中获取。
  • 使用 Spring 缓存抽象需注意:
    • 确定方法需要被缓存以及它们的缓存策略;
    • 从缓存中读取之前缓存存储的数据。

重要概念及缓存注解

  • Chche 缓存接口,定义缓存操作。实现有 RedisCache、EhCacheCache、ConcurrentMapCache等。
  • ChacheManager 缓存管理器,管理各种缓存组件。
  • @EnableCaching 开启基于注解的缓存,用在主配置类上。
  • @Cacheable 能够根据方法的请求参数对其结果进行缓存
  • @CachePut 即调用方法,又更新缓存数据
  • @CacheEvict 清除缓存
  • @Caching 定义复杂的缓存规则

@Cacheable@CachePut@Caching 等注解主要的参数:

  • cacheNames/value 缓存的名字,即将方法的返回结果放在那个缓存中,可以指定多个
  • key 缓存的数据,为空时默认是使用方法参数的值,可以为 SpEL 表达式,例如 #id
  • keyGenerator key 的生成器,可以自己指定 key 的生成器的组件 id,它与 key 二选一
  • cacheManager 缓存管理器
  • cacheResolver 缓存解析器,它与 cacheManager 二选一
  • condition 执行符合条件才缓存
  • unless 执行不符合条件才缓存
  • sync 是否使用异步模式
  • allEntries 是否清空所有缓存,默认为 false,如果指定为 true,则方法调用后将立即清空所有缓存
  • beforeInvocation 默认为 false,即缓存清除操作是在方法之后执行,出现异常不会清除缓存。如果指定为 true,即缓存清除操作是在方法之前执行。无论是否出现异常,缓存都会清除

SpEL 表达式

名字 位置 描述 示例
methodName root object 当前被调用的方法名 #root.methodName
method root object 当前被调用的方法 #root.method.name
target root object 当前被调用的目标对象 #root.target
targetClass root object 当前被调用的目标对象类 #root.targetClass
args root object 当前被调用的方法的参数列表 #root.args[0]
caches root object 当前方法调用使用的缓存列表,例如@Cacheable(value={"cache1", "cache2"}),则有两个 cache #root.caches[0].name
argument name evaluation context 方法参数的名字,可以直接 #参数名,也可以使用 #p0#a0 的形式,0 代表参数的索引 #id#a0#p0
result evaluation context 方法执行后的返回值,仅当方法执行之后的判断有效 #result

缓存使用

使用步骤

  • 第一步:建立相应表结构
  • 第二步:编写相应的实体类
  • 第三步:整合 MyBatis
    • 配置数据源信息
    • 使用注解版的 Mybatis,即在主配置类上加上 @MapperScan
  • 第四步:使用缓存
    • 在主配置类上加上 @EnableCaching
    • 在业务层方法加上 @Cacheable@CachePut@CacheEvict@Caching 等注解

缓存配置原理

  • 使用 CacheAutoConfiguration 自动配置类
  • 扫描到各种缓存的配置类:
    • 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
  • 给容器中注册了一个 CacheManager,默认是 ConcurrentMapCacheManager
  • 创建和获取 ConcurrentMapCache 类型的缓存组件,它的作用是将数据保存在 ConcurrentMap 中

EmployeeService:

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : 员工业务层
 */

@Service
public class EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    /**
     *
     * 根据 Id 查询员工信息
     *
     * @Cacheable 运行流程:
     * 1. 方法运行之前,先去查询 Cache 缓存组件,按照 cacheNames 指定的名字获取,第一次获取缓存时如果没有 Cache 组件会自动创建
     * 2. 去 Cache 中查询缓存的内容,使用一个 key,默认是方法的参数。也可以按照某种策略生成,默认使用 SimpleKeyGenerator 生成 key
     *    SimpleKeyGenerator 生成 key 的默认策略为:
     *      如果没有参数,key = new SimpleKey()
     *      如果有一个参数,key = 参数的值
     *      如果有多个参数,key = new SimpleKey(params)
     * 3. 有查询到缓存,则直接使用缓存;没有查询到缓存,则调用目标方法并将目标方法返回的结果放进缓存中
     */
    @Cacheable(cacheNames = {"emp"})
    public Employee getEmp(Integer id) {
        return employeeMapper.getEmpById(id);
    }

    /**
     *
     * 更新员工信息
     *
     * @CachePut 运行流程
     * 1. 先调用目标方法
     * 2. 将目标方法的结果缓存起来
     * 3. 比较适用与修改了数据库某个数据后,更新缓存
     */
    @CachePut(value = {"emp"}, key = "#result.id")
    public Employee updateEmp(Employee employee) {
        employeeMapper.updateEmp(employee);
        return  employee;
    }

    /**
     *
     * 删除员工信息
     *
     */
    @CacheEvict(value = {"emp"}, key = "#id")
    public void deleteEmp(Integer id) {
        employeeMapper.deleteEmpById(id);
    }

    /**
     *
     * 根据 lastName 查询员工信息
     *
     * @Caching 定义复杂的缓存规则
     */
    @Caching(
            cacheable = {
                    @Cacheable(value = {"emp"}, key = "#lastName")
            },
            put = {
                    @CachePut(value = {"emp"}, key = "#result.id"),
                    @CachePut(value = {"emp"}, key = "#result.email")
            }
    )
    public Employee getEmp(String lastName) {
        List<Employee> employees = employeeMapper.getEmpByName(lastName);
        if (employees.isEmpty()) {
            return null;
        }
        return employees.get(0);
    }
}

EmployeeController:

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : 员工控制器
 */

@RestController
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;

    // http://localhost:8080/emp/1
    @GetMapping("/emp/{id}")
    public Employee getEmp(@PathVariable("id") Integer id) {
        return employeeService.getEmp(id);
    }

    // http://localhost:8080/emp?id=1&lastName=ha&email=ha@gmail.com&gender=0&dId=1001
    @GetMapping("/emp")
    public Employee updateEmp(Employee employee) {
        return employeeService.updateEmp(employee);
    }

    // http://localhost:8080/empDel?id=1
    @GetMapping("/empDel")
    public String deleteEmp(Integer id) {
        employeeService.deleteEmp(id);
        return "success";
    }

    // http://localhost:8080/emp/lastName/parzulpan
    @GetMapping("/emp/lastName/{lastName}")
    public Employee getEmp(@PathVariable("lastName") String lastName) {
        return employeeService.getEmp(lastName);
    }
}

开启 debug 配置后,可以观察缓存的作用:

logging:
  level:
    cn.parzulpan.mapper: debug

可以使用 @CacheConfig,它指定这个类的缓存配置,通常用于抽取公共配置。

@CacheConfig(cacheNames = {"emp"})
@Service
public class EmployeeService {}

整合 Redis

使用步骤:

  • 引入 Redis 启动器依赖

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
    
  • 配置 Redis

    spring:
    # 配置 Redis
    redis:
        host: localhost
    
  • 测试 Redis

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class IntegrationCacheApplicationTests {
    
        @Autowired
        RedisTemplate redisTemplate;    // k-v 都是对象
    
        @Autowired
        StringRedisTemplate stringRedisTemplate;    // k-v 都是字符串
    
        @Test
        public void testRedisString() {
            // 字符串操作
            // String 类型 是 Redis 中最基本的数据类型,一个 key 对应一个 value 。
    
            stringRedisTemplate.opsForValue().set("stringMsg", "hello");
            stringRedisTemplate.opsForValue().append("stringMsg", "world");
    
            String msg = stringRedisTemplate.opsForValue().get("stringMsg");
            System.out.println(msg);
        }
    
        @Test
        public void testRedisList() {
            // 列表操作
            // List 类型 是简单的字符串列表,按照插入顺序排序。可以添加一个元素到列表的头部(左边)或者尾部(右边)。
            ListOperations<String, String> ops = redisTemplate.opsForList();
            ops.leftPush("listMsg", "hello");
            ops.leftPushAll("listMsg", "world", "parzulpan");
            List<String> listMsg = ops.range("listMsg", 0, 2);// 索引 0 到2的 listMsg
            System.out.println(listMsg.toString());
        }
    
        @Test
        public void testRedisSet() {
            // 集合操作
            // Set 类型 是 String 类型 的无序集合。它的特点是无序且唯一,它是通过哈希表实现的,所以添加、删除、查找的复杂度都是 O(1)。
            SetOperations<String, String> ops = redisTemplate.opsForSet();
            ops.add("setMsg", "hello");
            ops.add("setMsg", "world", "parzulpan");
            Set<String> setMsg = ops.members("setMsg"); //  取 set
            System.out.println(setMsg.toString());
        }
    
        @Test
        public void testRedisZSet() {
            // 有序集合操作
            // ZSet 类型 和 Set 类型 一样,也是 String 类型元素的集合,且不允许有重复的成员。
            // 不同的是每个元素都会关联一个 double 类型 的分数,它正是通过分数来为集合中的成员进行从小到大的排序。
            // ZSet 类型的成员是唯一的,但分数(score) 却可以重复。
            ZSetOperations<String, String> ops = redisTemplate.opsForZSet();
            ops.add("zsetMsg", "hello", 1);
            ops.add("zsetMsg", "parzulpan", 3);
            ops.add("zsetMsg", "world", 2);
            Set<String> zsetMsg = ops.range("zsetMsg", 0, 2);
            System.out.println(zsetMsg.toString());
        }
    
        @Test
        public void testRedisHash() {
            // 哈希操作
            // Hash 类型 是一个键值对的集合。它是一个 String 类型 的 field 和 value 组合的映射表,它特别适合用于存储对象。
            HashOperations<String, String, String> ops = redisTemplate.opsForHash();
            ops.put("hashMsg", "key1", "hello");
            ops.put("hashMsg", "key2", "world");
            ops.put("hashMsg", "key3", "parzulpan");
            String key2 = ops.get("hashMsg", "key2");
            System.out.println(key2);
        }
    }
    
  • 对于上面的测试,Redis 默认保存对象,使用 JDK 序列化机制,序列化后的数据保存到 redis 中。可以使用自定义的序列化器。值得注意的是,无论是 json 序列化还是 jdk 序列化,redis 接受的都是字符串的文本,而 jdk 的序列化方式字符串会把 json 序列化方式字符串大几倍,性能较差,所以一般都使用自定义的序列化器。

    /**
     * @Author : parzulpan
     * @Time : 2021-01
     * @Desc : 自定义 Redis 配置类
     */
    
    @Configuration
    public class CustomRedisConfig {
    
        // 使用 Jackson 序列化器,不使用默认的 JDK 的
        @Bean
        public RedisTemplate<Object, Employee> employeeRedisTemplate(RedisConnectionFactory rcf){
            RedisTemplate<Object, Employee> template = new RedisTemplate<>();
            template.setConnectionFactory(rcf);
            Jackson2JsonRedisSerializer<Employee> jrs = new Jackson2JsonRedisSerializer<>(Employee.class);
            template.setDefaultSerializer(jrs);
            return template;
        }
    }
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class IntegrationCacheApplicationTests {
        @Autowired
        RedisTemplate employeeRedisTemplate;    // 使用自定义的 RedisTemplate
    
        @Test
        public void testEmployeeRedisTemplate() {
            ValueOperations ops = employeeRedisTemplate.opsForValue();
            Employee employee = employeeMapper.getEmpById(1);
            ops.set("emp-01", employee);
        }
    }
    
  • 使用 Redis 缓存,它的原理是:

    • CacheManager,生成一个 Cache 缓存组件来实际给缓存中存取数据

    • 引入 redis 的 starter,容器中保存的是 RedisCacheManager;

    • RedisCacheManager 帮我们创建 RedisCache 来作为缓存组件,RedisCache 通过操作 redis 缓存数据

    • 默认保存数据 k-v 都是 Object。利用序列化保存,所以实体类需要继承 Serializable。它默认使用的是 RedisTemplate<Object, Object>,它是 jdk 默认的序列化机制

    • 可以通过自定义 CacheManager,更改序列化机制:

      /**
       * @Author : parzulpan
       * @Time : 2021-01
       * @Desc : 自定义 Redis 配置类
       */
      
      @Configuration
      public class CustomRedisConfig {
      
          // 使用 Jackson 序列化器,不使用默认的 JDK 的
          @Bean
          public RedisTemplate<Object, Employee> employeeRedisTemplate(RedisConnectionFactory rcf){
              RedisTemplate<Object, Employee> template = new RedisTemplate<>();
              template.setConnectionFactory(rcf);
              Jackson2JsonRedisSerializer<Employee> jrs = new Jackson2JsonRedisSerializer<>(Employee.class);
              template.setDefaultSerializer(jrs);
              return template;
          }
      
          // 自定义缓存管理器
          @Bean
          public RedisCacheManager employeeCacheManager(RedisTemplate<Object, Employee> employeeRedisTemplate) {
              RedisCacheManager redisCacheManager = new RedisCacheManager(employeeRedisTemplate);
      
              // 使用前缀,默认将 CacheName 作为 key 的前缀
              redisCacheManager.setUsePrefix(true);
      
              return redisCacheManager;
          }
      }
      
  • 使用示例:

    /**
     * @Author : parzulpan
     * @Time : 2021-01
     * @Desc : 部门业务层
     */
    
    @Service
    public class DepartmentService {
    
        @Autowired
        DepartmentMapper departmentMapper;
    
        @Autowired
        RedisCacheManager departmentCacheManager;
    
        // 注解的方式
        @Cacheable(cacheNames = "dept", cacheManager = "departmentCacheManager")
        public Department getDeptById(Integer id) {
            return departmentMapper.getDeptById(id);
        }
    
        // api 调用的方式
        public Department getDeptById2(Integer id) {
            Department department = departmentMapper.getDeptById(id);
    
            // 获取某个缓存
            Cache dept = departmentCacheManager.getCache("dept");
            dept.put("dept2:" + id, department);
    
            return department;
        }
    }
    

总之,相对于默认的 Cache,使用 Redis,需要多写如下的一个 Redis 配置类:

/**
 * @Author : parzulpan
 * @Time : 2021-01
 * @Desc : 自定义 Redis 配置类
 */

@Configuration
public class CustomRedisConfig {

    // 使用 Jackson 序列化器,不使用默认的 JDK 的
    @Bean
    public RedisTemplate<Object, Employee> employeeRedisTemplate(RedisConnectionFactory rcf){
        RedisTemplate<Object, Employee> template = new RedisTemplate<>();
        template.setConnectionFactory(rcf);
        Jackson2JsonRedisSerializer<Employee> jrs = new Jackson2JsonRedisSerializer<>(Employee.class);
        template.setDefaultSerializer(jrs);
        return template;
    }

    @Bean
    public RedisTemplate<Object, Department> departmentRedisTemplate(RedisConnectionFactory rcf){
        RedisTemplate<Object, Department> template = new RedisTemplate<>();
        template.setConnectionFactory(rcf);
        Jackson2JsonRedisSerializer<Department> jrs = new Jackson2JsonRedisSerializer<>(Department.class);
        template.setDefaultSerializer(jrs);
        return template;
    }

    // 自定义缓存管理器
    @Primary    // 将其作为默认的
    @Bean
    public RedisCacheManager employeeCacheManager(RedisTemplate<Object, Employee> employeeRedisTemplate) {
        RedisCacheManager redisCacheManager = new RedisCacheManager(employeeRedisTemplate);

        // 使用前缀,默认将 CacheName 作为 key 的前缀
        redisCacheManager.setUsePrefix(true);

        return redisCacheManager;
    }

    @Bean
    public RedisCacheManager departmentCacheManager(RedisTemplate<Object, Department> departmentRedisTemplate) {
        RedisCacheManager redisCacheManager = new RedisCacheManager(departmentRedisTemplate);

        // 使用前缀,默认将 CacheName 作为 key 的前缀
        redisCacheManager.setUsePrefix(true);

        return redisCacheManager;
    }
}

练习和总结

上一篇:CSP认证201403-3 命令行选项2[C++题解]:模拟题、字符串处理、stringstream处理getline


下一篇:解决AttributeError: module ‘torchvision‘ has no attribute ‘ops‘