浅谈Spring boot cache使用和原理

缓存要解决的问题:一个程序的瓶颈在于数据库,我们也知道内存的速度是大大快于硬盘的速度的。当我们需要重复地获取相同的数据的时候,我们一次又一次的请求数据库或者远程服务,导致大量的时间耗费在数据库查询或者远程方法调用上,导致程序性能的恶化,这便是数据缓存要解决的问题。

类似的缓存技术有:Redis、EhCache、Guava等,现在一般常用的为Redis。

Spring 3.1 引入了激动人心的基于注释(annotation)的缓存(cache)技术,它本质上不是一个具体的缓存实现方案(例如EHCache 或者 OSCache),而是一个对缓存使用的抽象,通过在既有代码中添加少量它定义的各种 annotation,即能够达到缓存方法的返回对象的效果。

Spring 的缓存技术还具备相当的灵活性,不仅能够使用 SpEL(Spring Expression Language)来定义缓存的 key 和各种 condition,还提供开箱即用的缓存临时存储方案,也支持和主流的专业缓存例如 EHCache 集成。

其特点总结如下:

1. 通过少量的配置 annotation 注释即可使得既有代码支持缓存
2. 支持开箱即用 Out-Of-The-Box,即不用安装和部署额外第三方组件即可使用缓存
3. 支持 Spring Express Language,能使用对象的任何属性或者方法来定义缓存的 key 和 condition
4. 支持 AspectJ,并通过其实现任何方法的缓存支持
5. 支持自定义 key 和自定义缓存管理者,具有相当的灵活性和扩展性

一、Spring boot cache原理

第一步、自动配置类;

自动启动类:CacheAutoConfiguration

属性配置:CacheProperties

主启动类添加:@EnableCaching注解

cache POM添加:

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

第二步、从缓存的配置类 中获取 多个cache

CacheConfigurationImportSelector.selectImports()方法获取

static class CacheConfigurationImportSelector implements ImportSelector {
​
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
      CacheType[] types = CacheType.values();
      String[] imports = new String[types.length];
      for (int i = 0; i < types.length; i++) {
        imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
      }
      return imports;
    }
​
}

获取结果:SimpleCacheConfiguration 默认cache

 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

第三步:SimpleCacheConfiguration.cacheManager()

此方法中给容器中注册了一个CacheManager组件:类型为ConcurrentMapCacheManager

@Bean
public ConcurrentMapCacheManager cacheManager() {
  ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
  List<String> cacheNames = this.cacheProperties.getCacheNames();
  if (!cacheNames.isEmpty()) {
   cacheManager.setCacheNames(cacheNames);
  }
  return this.customizerInvoker.customize(cacheManager);
}

第四步:查看获取缓存方法getCache()

ConcurrentMapCacheManager 类里,数据都存储到为ConcurrentMap 中

public Cache getCache(String name) {
  Cache cache = this.cacheMap.get(name); //cacheMap 为ConcurrentMap 类型,获取一个cache组件
  if (cache == null && this.dynamic) {
   synchronized (this.cacheMap) {
     cache = this.cacheMap.get(name); //cahceMap不为空获取
     if (cache == null) {
      //可以获取或者创建ConcurrentMapCache类型的缓存组件;他的作用将数据保存在ConcurrentMap中;
      cache = createConcurrentMapCache(name);
      this.cacheMap.put(name, cache); //ConcurrentMapCache.lookup();
     }
   }
  }
  return cache;
}

二、Cacheable运行流程:

​ @Cacheable: 1、方法运行之前,先去查询Cache(缓存组件),按照cacheNames指定的名字获取; (CacheManager先获取相应的缓存),第一次获取缓存如果没有Cache组件会自动创建。 2、去Cache中查找缓存的内容(ConcurrentMapCache.lookup()方法中去查找),使用一个key,默认就是方法的参数; key是按照某种策略生成的;默认是使用keyGenerator生成的,默认使用SimpleKeyGenerator生成key; SimpleKeyGenerator生成key的默认策略; 如果没有参数;key=new SimpleKey(); 如果有一个参数:key=参数的值 如果有多个参数:key=new SimpleKey(params);

 //这个方法 SimpleKeyGenerator.generateKey()  方法生成key
public static Object generateKey(Object... params) {
  if (params.length == 0) {
   return SimpleKey.EMPTY;
  }
  if (params.length == 1) { //如果只有一个参数,直接返回这个参数为key
   Object param = params[0];
   if (param != null && !param.getClass().isArray()) {
     return param;
   }
  }
  return new SimpleKey(params);
}

3、没有查到缓存就调用目标方法; 4、将目标方法返回的结果,放进缓存中ConcurrentMapCache.put();

@Cacheable标注的方法执行之前先来检查缓存中有没有这个数据,默认按照参数的值作为key去查询缓存, 如果没有就运行方法并将结果放入缓存;以后再来调用就可以直接使用缓存中的数据;

​ 核心: 1)、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件 2)、key使用keyGenerator生成的,默认是SimpleKeyGenerator

详细执行流程:ConcurrentMapCache.lookup()上断点查看,执行过程

//第一步CacheAspectSupport 中execute()
private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts)
//第二步 CacheAspectSupport
private Cache.ValueWrapper findCachedItem(Collection<CacheOperationContext> contexts) {
  Object result = CacheOperationExpressionEvaluator.NO_RESULT;
  for (CacheOperationContext context : contexts) {
    if (isConditionPassing(context, result)) {
      Object key = generateKey(context, result); //获取key
      Cache.ValueWrapper cached = findInCaches(context, key);
      if (cached != null) {
        return cached;
      }
      else {
        if (logger.isTraceEnabled()) {
          logger.trace("No cache entry for key '" + key + "' in cache(s) " + context.getCacheNames());
        }
      }
    }
  }
  return null;
}
//第三步:CacheAspectSupport.findInCaches()
//第四步:AbstractCacheInvoker.doGet()
//第五步:AbstractValueAdaptingCache.get();
@Override
public ValueWrapper get(Object key) {
    Object value = lookup(key);
    return toValueWrapper(value);
}
// 第六步:ConcurrentMapCache.lookup(); 从ConcurrentMap 中根据key获取值
@Override
protected Object lookup(Object key) {
    return this.store.get(key);
}

三、Cacheable 注解的几个属性:

1、cacheNames/value:指定缓存组件的名字;将方法的返回结果放在哪个缓存中,是数组的方式,可以指定 多个缓存;

2、key:缓存数据使用的key;可以用它来指定。默认是使用方法参数的值 1-方法的返回值

​ 编写SpEL; #i d;参数id的值 #a0 #p0 #root.args[0]

​ getEmp[2]

3、keyGenerator:key的生成器;可以自己指定key的生成器的组件id

​ key/keyGenerator:二选一使用;

4、cacheManager:指定缓存管理器;或者cacheResolver指定获取解析器

5、condition:指定符合条件的情况下才缓存;

​ ,condition = "#id>0"

​ condition = "#a0>1":第一个参数的值》1的时候才进行缓存

6、unless:否定缓存;当unless指定的条件为true,方法的返回值就不会被缓存;可以获取到结果进行判断

​ unless = "#result == null"

​ unless = "#a0==2":如果第一个参数的值是2,结果不缓存;

7、sync:是否使用异步模式;异步模式的情况下unless不支持

四、Cache使用:

1.Cacheable的使用

@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.自定义keyGenerator:

@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()+"]";
    }
  };
}

3.CachePut的使用:更新缓存

/**
   * @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 = "#result.id")
  public Employee updateEmp(Employee employee){
    System.out.println("updateEmp:"+employee);
    employeeMapper.updateEmp(employee);
    return employee;
  }

4.CacheEvict 缓存清除

/**
 * @CacheEvict:缓存清除
 * key:指定要清除的数据
 * allEntries = true:指定清除这个缓存中所有的数据
 * beforeInvocation = false:缓存的清除是否在方法之前执行
 *   默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除
 *
 * 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;
}

5.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){
  return employeeMapper.getEmpByLastName(lastName);
}

6.CacheConfig缓存清除

@CacheConfig(cacheNames="emp",cacheManager = "employeeCacheManager") //抽取缓存的公共配置
@Service
public class EmployeeService {

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Spring Boot 简单使用EhCache缓存框架的方法

    我的环境是Gradle + Kotlin + Spring Boot,这里介绍EhCache缓存框架在Spring Boot上的简单应用. 在build.gradle文件添加依赖 compile("org.springframework.boot:spring-boot-starter-cache") compile("net.sf.ehcache:ehcache") 修改Application的配置,增加@EnableCaching配置 @MapperScan(&

  • springboot集成spring cache缓存示例代码

    本文介绍如何在springboot中使用默认的spring cache, 声明式缓存 Spring 定义 CacheManager 和 Cache 接口用来统一不同的缓存技术.例如 JCache. EhCache. Hazelcast. Guava. Redis 等.在使用 Spring 集成 Cache 的时候,我们需要注册实现的 CacheManager 的 Bean. Spring Boot 为我们自动配置了 JcacheCacheConfiguration. EhCacheCacheCo

  • SpringBoot手动使用EhCache的方法示例

    SpringBoot在annotation的层面实现了数据缓存的功能,基于Spring的AOP技术.所有的缓存配置只是在annotation层面配置,像声明式事务一样. Spring定义了CacheManager和Cache接口统一不同的缓存技术.其中CacheManager是Spring提供的各种缓存技术的抽象接口.而Cache接口包含缓存的各种操作. CacheManger 针对不同的缓存技术,需要实现不同的cacheManager,Spring定义了如下的cacheManger实现. Ca

  • Spring Boot缓存实战 EhCache示例

    Spring boot默认使用的是SimpleCacheConfiguration,即使用ConcurrentMapCacheManager来实现缓存.但是要切换到其他缓存实现也很简单 pom文件 在pom中引入相应的jar包 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web<

  • 详解SpringBoot缓存的实例代码(EhCache 2.x 篇)

    本篇介绍了SpringBoot 缓存(EhCache 2.x 篇),分享给大家,具体如下: SpringBoot 缓存 在 spring Boot中,通过@EnableCaching注解自动化配置合适的缓存管理器(CacheManager),Spring Boot根据下面的顺序去侦测缓存提供者: Generic JCache (JSR-107) EhCache 2.x Hazelcast Infinispan Redis Guava Simple 关于 Spring Boot 的缓存机制: 高速

  • Spring Boot 中使用cache缓存的方法

    一.什么是缓存 Cache Cache 一词最早来自于CPU设计 当CPU要读取一个数据时,首先从CPU缓存中查找,找到就立即读取并送给CPU处理:没有找到,就从速率相对较慢的内存中读取并送给CPU处理,同时把这个数据所在的数据块调入缓存中,可以使得以后对整块数据的读取都从缓存中进行,不必再调用内存.正是这样的读取机制使CPU读取缓存的命中率非常高(大多数CPU可达90%左右),也就是说CPU下一次要读取的数据90%都在CPU缓存中,只有大约10%需要从内存读取.这大大节省了CPU直接读取内存的

  • spring boot+spring cache实现两级缓存(redis+caffeine)

    spring boot中集成了spring cache,并有多种缓存方式的实现,如:Redis.Caffeine.JCache.EhCache等等.但如果只用一种缓存,要么会有较大的网络消耗(如Redis),要么就是内存占用太大(如Caffeine这种应用内存缓存).在很多场景下,可以结合起来实现一.二级缓存的方式,能够很大程度提高应用的处理效率. 内容说明: 缓存.两级缓存 spring cache:主要包含spring cache定义的接口方法说明和注解中的属性说明 spring boot

  • 浅谈Spring boot cache使用和原理

    缓存要解决的问题:一个程序的瓶颈在于数据库,我们也知道内存的速度是大大快于硬盘的速度的.当我们需要重复地获取相同的数据的时候,我们一次又一次的请求数据库或者远程服务,导致大量的时间耗费在数据库查询或者远程方法调用上,导致程序性能的恶化,这便是数据缓存要解决的问题. 类似的缓存技术有:Redis.EhCache.Guava等,现在一般常用的为Redis. Spring 3.1 引入了激动人心的基于注释(annotation)的缓存(cache)技术,它本质上不是一个具体的缓存实现方案(例如EHCa

  • 浅谈spring boot 1.5.4 异常控制

    spring boot 已经做了统一的异常处理,下面看看如何自定义处理异常 1.错误码页面映射 1.1静态页面 必须配置在 resources/static/error文件夹下,以错误码命名 下面是404错误页面内容,当访问一个不存在的链接的时候,定位到此页 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Not F

  • 浅谈spring boot 集成 log4j 解决与logback冲突的问题

    现在很流行springboot的开发,小编闲来无事也学了学,开发过程中遇见了log4j日志的一个小小问题,特此记载. 首先在pox.xml中引入对应的maven依赖: <!-- 引入log4j--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency&g

  • 浅谈Spring Boot: 接口压测及简要优化策略

    工程做好之后,需要对接口进行压力测试.可以自己编写线程池模拟多用户访问测试,也可以使用jmeter进行压测.jmeter的好处是测试方便,并且有完善的结果分析功能.本次采用jmeter进行压力测试. 1.准备数据,为了测试准备200w条以上的数据.一个简单的方法是使用下面的sql快速创建. INSERT INTO table (user_name,address) SELECT user_name, address FROM table; 但这样创建的数据不同记录的重复部分太多,和实际业务不太相

  • 浅谈Spring Boot中Redis缓存还能这么用

    经过Spring Boot的整合封装与自动化配置,在Spring Boot中整合Redis已经变得非常容易了,开发者只需要引入Spring Data Redis依赖,然后简单配下redis的基本信息,系统就会提供一个RedisTemplate供开发者使用,但是今天松哥想和大伙聊的不是这种用法,而是结合Cache的用法.Spring3.1中开始引入了令人激动的Cache,在Spring Boot中,可以非常方便的使用Redis来作为Cache的实现,进而实现数据的缓存. 工程创建 首先创建一个Sp

  • 浅谈Spring Boot 微服务项目的推荐部署方式

    如果开发过spring boot的程序,应该都知道,使用spring boot官方的maven打包插件(spring-boot-maven-plugin) 来打包,打出来的jar包一般有40M以上. 如果公司的服务器上传带宽不高,那么手动上传一个jar或者jenkins部署一次jar,都是非常痛苦的........ 但是,如果打包的时候不引入lib,那么打出来的jar包一般只有几十k而已,非常小,想怎么传就怎么传......... 本文会提供一个bash启动脚本,只需要稍做更改,即可适应你的程序

  • 浅谈Spring Boot 异常处理篇

    前言 先谈谈"异常处理"这件事.下面有 2 份伪代码,对比下: // ① 基于 if/else 判断 if(deletePage(page) == E_OK){ if(registry.deleteReference(page.name) == E_OK){ if(configKeys.deleteKey(page.name.makeKey()) == E_OK){ logger.log("page deleted"); }else{ logger.log(&quo

  • 浅谈Spring Boot 整合ActiveMQ的过程

    RabbitMQ是比较常用的AMQP实现,这篇文章是一个简单的Spring boot整合RabbitMQ的教程. 安装ActiveMQ服务器,(也可以不安装,如果不安装,会使用内存mq) 构建Spring boot项目,增加依赖项,只需要添加这一项即可 <!-- 添加acitivemq依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring

  • 浅谈Spring Boot 属性配置和自定义属性配置

    在使用spring boot过程中,可以发现项目中只需要极少的配置就能完成相应的功能,这归功于spring boot中的模块化配置,在pom.xml中依赖的每个Starter都有默认配置,而这些默认配置足以满足正常的功能开发. 如果需要修改自定义修改默认配置,spring boot 提供了很简便的方法,只需要在application.properties 中添加修改相应的配置.(spring boot启动的时候会读取application.properties这份默认配置) 一.修改默认配置 例

  • 浅谈Spring Boot日志框架实践

    Java应用中,日志一般分为以下5个级别: ERROR 错误信息 WARN 警告信息 INFO 一般信息 DEBUG 调试信息 TRACE 跟踪信息 Spring Boot使用Apache的Commons Logging作为内部的日志框架,其仅仅是一个日志接口,在实际应用中需要为该接口来指定相应的日志实现. SpringBt默认的日志实现是Java Util Logging,是JDK自带的日志包,此外SpringBt当然也支持Log4J.Logback这类很流行的日志实现. 统一将上面这些 日志

随机推荐