使用spring自带的cache
Spring缓存注解@Cacheable、@CacheEvict、@CachePut使用
Spring缓存注解@Cacheable、@CacheEvict、@CachePut使⽤从3.1开始,Spring引⼊了对Cache的⽀持。
其使⽤⽅法和原理都类似于Spring对事务管理的⽀持。
Spring Cache是作⽤在⽅法上的,其核⼼思想是这样的:当我们在调⽤⼀个缓存⽅法时会把该⽅法参数和返回结果作为⼀个键值对存放在缓存中,等到下次利⽤同样的参数来调⽤该⽅法时将不再执⾏该⽅法,⽽是直接从缓存中获取结果进⾏返回。
所以在使⽤Spring Cache的时候我们要保证我们缓存的⽅法对于相同的⽅法参数要有相同的返回结果。
使⽤Spring Cache需要我们做两⽅⾯的事:n 声明某些⽅法使⽤缓存n 配置Spring对Cache的⽀持和Spring对事务管理的⽀持⼀样,Spring对Cache的⽀持也有基于注解和基于XML配置两种⽅式。
下⾯我们先来看看基于注解的⽅式。
1 基于注解的⽀持Spring为我们提供了⼏个注解来⽀持Spring Cache。
其核⼼主要是@Cacheable和@CacheEvict。
使⽤@Cacheable标记的⽅法在执⾏后Spring Cache将缓存其返回结果,⽽使⽤@CacheEvict标记的⽅法会在⽅法执⾏前或者执⾏后移除Spring Cache中的某些元素。
下⾯我们将来详细介绍⼀下Spring基于注解对Cache的⽀持所提供的⼏个注解。
1.1 @Cacheable@Cacheable可以标记在⼀个⽅法上,也可以标记在⼀个类上。
当标记在⼀个⽅法上时表⽰该⽅法是⽀持缓存的,当标记在⼀个类上时则表⽰该类所有的⽅法都是⽀持缓存的。
对于⼀个⽀持缓存的⽅法,Spring会在其被调⽤后将其返回值缓存起来,以保证下次利⽤同样的参数来执⾏该⽅法时可以直接从缓存中获取结果,⽽不需要再次执⾏该⽅法。
Spring在缓存⽅法的返回值时是以键值对进⾏缓存的,值就是⽅法的返回结果,⾄于键的话,Spring⼜⽀持两种策略,默认策略和⾃定义策略,这个稍后会进⾏说明。
cache的用法
cache的用法Cache的用法Cache(缓存)是一种用于存储临时数据的技术,可以提高数据的访问速度和系统的性能。
在软件开发中,Cache有多种用法,下面将详细介绍其中一些常见的用法。
1. 网页缓存静态文件缓存静态文件如CSS、JavaScript和图片等,在第一次请求后可以被服务器缓存到浏览器本地,之后再次请求时直接从缓存读取,减少了网络传输时间和服务器负载。
页面片段缓存部分动态内容如导航菜单、热门文章列表等,在后端生成后可以缓存在服务器端,下次请求时直接从缓存中获取,减少数据库查询和页面渲染时间。
2. 数据库缓存查询结果缓存数据库查询是消耗资源的操作,可以将查询的结果缓存在内存中,下次查询同样的数据时直接从缓存读取,避免了再次访问数据库。
对象级缓存一些常用的业务对象如用户信息、商品信息等,可以将其缓存在内存中,避免频繁的数据库查询操作,提高系统响应速度和并发能力。
3. 键值对缓存键值对缓存是将数据以键值对的形式存储在内存中,常用于缓存一些常用的配置参数、临时计算结果等。
它可以快速地读写数据,并可以设置过期时间,一般使用LRU(最近最少使用)算法进行缓存数据的清理。
4. HTTP缓存HTTP缓存是通过设置HTTP头信息的方式进行缓存的。
可以通过设置Expires头字段或Cache-Control头字段来控制缓存的过期时间和缓存策略。
如果服务器返回的响应带有相同的URL和头字段,则客户端可以直接从缓存获取数据,减少了网络传输时间。
5. 代码缓存编译型语言的代码在每次运行前都需要经过编译的过程,可以将编译后生成的中间代码或机器码缓存起来,下次运行时直接加载缓存,减少编译时间,提高系统性能。
6. CDN缓存内容分发网络(CDN)是一种分布式系统,可以将文件缓存到离用户更近的服务器上,用户在访问网站时可以从相对较近的服务器获取文件,减少了网络延迟和传输时间,提高了访问速度。
以上是一些常见的Cache(缓存)的用法,通过合理使用Cache,可以显著提升系统的性能和用户体验。
spring actuator原理
spring actuator原理Spring Actuator是一个功能强大的管理和监控应用程序端点,可以用来提供对Spring Boot应用程序运行情况的状态视图。
Spring Actuator有助于提供信息,可以成为针对应用程序的管理、监控以及调整的依据。
Spring Actuator使用HTTP和JMX来暴露一组端点,这些端点支持管理程序,如诊断、健康、配置和安全检查,以及在运行时可以被修改的参数。
此外,它还可以提供来自应用程序内部的运行时信息,例如JVM、类路径和内存信息。
Spring Actuator工作原理如下:1. Spring Boot应用程序启动时,Spring Actuator会自动注册一组特定的端点,这些端点用于收集有关Spring Boot应用程序的运行状态信息,以及提供相应的应用程序管理功能。
2. 使用Spring Actuator可以查看应用程序的状态信息,并使用HTTP 或JMX来访问应用程序的端点信息。
3. 当应用程序有变更时,Spring Actuator会收集有关变更的信息,并将其发布到HTTP或JMX,以保持应用程序的最新状态和管理控制情况。
4. Spring Actuator端点实现了可扩展性,可以让开发人员根据自己的需要添加新端点,或修改现有端点的行为。
5. 要使用Spring Actuator,只需在应用程序根目录中添加一个“actuator”依赖,然后就可以使用Spring Actuator的功能了。
Spring Actuator旨在为开发人员提供一个简单的、可扩展的工具,以便更好地了解和管理他们的应用程序。
它的核心功能在于向开发人员提供运行时应用程序的状态视图,以及支持管理程序的端点,如健康检查、诊断等,这有助于在良好的运行状态下快速部署应用程序。
cacheevict key表达式
cacheevict key表达式全文共四篇示例,供读者参考第一篇示例:在Spring框架中,我们经常会用到Cache来提升系统的性能,其中有一种注解叫做@CacheEvict用来清空缓存中的数据。
在使用@CacheEvict注解时,我们需要提供一个key表达式来指定缓存中需要清空的数据。
本文将从key表达式的概念、语法和实际应用等方面来详细介绍@CacheEvict key表达式。
# 一、@CacheEvict注解简介在Spring框架中,@CacheEvict注解用来清空缓存中的数据。
当我们使用Cache来缓存数据时,如果某个数据发生变化,我们可以使用@CacheEvict注解来清空缓存,从而保证缓存数据的有效性。
@CacheEvict注解有以下几个重要属性:- value:指定要清空的缓存名称- key:指定缓存中需要清空的数据的key- condition:指定清空缓存的条件其中,key属性用来指定缓存中需要清空的数据的key。
通过key 属性,我们可以定位到具体的缓存数据,并将其清空。
在实际应用中,我们经常会使用key表达式来表示缓存数据的key。
# 二、key表达式概念key表达式是@CacheEvict注解中key属性的值,通过key表达式,我们可以动态地生成缓存数据的key,从而实现精确地清空缓存数据。
key表达式可以使用SpEL(Spring Expression Language)来动态生成缓存数据的key。
SpEL是一种表达式语言,可以在运行时对表达式进行评估,生成最终的值。
通过使用SpEL,我们可以在key属性中编写复杂的表达式,灵活地指定要清空的缓存数据的key。
# 三、key表达式语法key表达式的语法与SpEL表达式一致,可以使用各种运算符、函数和变量来生成缓存数据的key。
下面是一些常用的key表达式语法:1. 字符串拼接:```java@CacheEvict(value = "userCache", key = "'user:' + #id")```上面的表达式中,使用了字符串拼接操作符+来生成缓存数据的key。
SpringBoot+SpringCache实现两级缓存(Redis+Caffeine)
SpringBoot+SpringCache实现两级缓存(Redis+Caffeine)1. 缓存、两级缓存1.1 内容说明Spring cache:主要包含spring cache定义的接⼝⽅法说明和注解中的属性说明springboot+spring cache:rediscache实现中的缺陷caffeine简介spring boot+spring cache实现两级缓存使⽤缓存时的流程图1.2 Sping Cachespring cache是spring-context包中提供的基于注解⽅式使⽤的缓存组件,定义了⼀些标准接⼝,通过实现这些接⼝,就可以通过在⽅法上增加注解来实现缓存。
这样就能够避免缓存代码与业务处理耦合在⼀起的问题。
spring cache的实现是使⽤spring aop中对⽅法切⾯(MethodInterceptor)封装的扩展,当然spring aop也是基于Aspect来实现的。
spring cache核⼼的接⼝就两个:Cache和CacheManager1.2.1 Cache接⼝提供缓存的具体操作,⽐如缓存的放⼊,读取,清理,spring框架中默认提供的实现有1.2.2 CacheManager接⼝主要提供Cache实现bean的创建,每个应⽤⾥可以通过cacheName来对Cache进⾏隔离,每个CaheName对应⼀个Cache实现,spring框架中默认提供的实现与Cache的实现都是成对出现的1.2.3 常⽤的注解说明@Cacheable:主要应⽤到查询数据的⽅法上@CacheEvict:清除缓存,主要应⽤到删除数据的⽅法上@CachePut:放⼊缓存,主要⽤到对数据有更新的⽅法上@Caching:⽤于在⼀个⽅法上配置多种注解@EnableCaching:启⽤spring cache缓存,作为总的开关,在spring boot的启动类或配置类上需要加⼊次注解才会⽣效2.实战多级缓存的⽤法package com.xfgg.demo.config;import lombok.AllArgsConstructor;import com.github.benmanes.caffeine.cache.Caffeine;import org.springframework.cache.CacheManager;import org.springframework.cache.caffeine.CaffeineCacheManager;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import java.util.concurrent.TimeUnit;@Configuration@AllArgsConstructor//把定义的缓存加⼊到Caffeine中public class CacheConfig {@Beanpublic CacheManager cacheManager(){CaffeineCacheManager cacheManager = new CaffeineCacheManager();cacheManager.setCaffeine(Caffeine.newBuilder()//使⽤refreshAfterWrite必须要设置cacheLoader//在5分钟内没有创建/覆盖时,会移除该key,下次取的时候从loading中取【重点:失效、移除Key、失效后需要获取新值】.expireAfterWrite(5, TimeUnit.MINUTES)//初始容量.initialCapacity(10)//⽤来控制cache的最⼤缓存数量.maximumSize(150));return cacheManager;}}package com.xfgg.demo.config;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.data.redis.connection.RedisPassword;import org.springframework.data.redis.connection.RedisStandaloneConfiguration;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.serializer.StringRedisSerializer;//⽣成的redis连接public class RedisConfig<GenericObjectPoolConfig> {@Value("${spring.redis1.host}")private String host;@Value("${spring.redis1.port}")private Integer port;@Value("${spring.redis1.password}")private String password;@Value("${spring.redis1.database}")private Integer database;@Value("${spring.redis1.lettuce.pool.max-active}")private Integer maxActive;@Value("${spring.redis1.lettuce.pool.max-idle}")private Integer maxIdle;@Value("${spring.redis1.lettuce.pool.max-wait}")private Long maxWait;@Value("${spring.redis1.lettuce.pool.min-idle}")private Integer minIdle;@Beanpublic RedisStandaloneConfiguration redis1RedisConfig() {RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();config.setHostName(host);config.setPassword(RedisPassword.of(password));config.setPort(port);config.setDatabase(database);return config;}//配置序列化器@Beanpublic RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){RedisTemplate<String,Object>template=new RedisTemplate<>();//关联template.setConnectionFactory(factory);//设置key的序列化器template.setKeySerializer(new StringRedisSerializer());//设置value的序列化器template.setValueSerializer(new StringRedisSerializer());return template;}}⼀个使⽤cacheable注解,⼀个使⽤redistemplate进⾏缓存因为公司项⽬中⽤到的是jedis和jediscluster所以这⾥只是做个了解,没有写的很细到此这篇关于SpringBoot+SpringCache实现两级缓存(Redis+Caffeine)的⽂章就介绍到这了,更多相关SpringBoot SpringCache两级缓存内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。
java cache用法
java cache用法Java中的缓存是一种常用的数据结构,用于提高应用程序的性能和响应速度。
Java提供了多种缓存实现,如JavaCache、Ehcache、GuavaCache等,这些缓存可以存储数据并在需要时快速检索。
本篇文章将介绍JavaCache的使用方法。
JavaCache是一个简单的缓存实现,它提供了一个易于使用的API,可以方便地添加、获取和移除缓存数据。
JavaCache的设计目标是易于使用、高性能和可扩展性。
它支持通过多个存储引擎来扩展缓存,每个存储引擎都具有不同的性能特点。
1.添加缓存数据使用JavaCache添加缓存数据非常简单。
首先,需要创建一个Cache对象,并指定存储引擎的类型和名称。
然后,可以使用put方法将数据添加到缓存中。
例如:```javaCachecache=newCache("myCache",100);//创建一个缓存对象,存储引擎类型为Memory,容量为100个字节cache.put("key","value");//将数据添加到缓存中```2.获取缓存数据使用JavaCache获取缓存数据也非常简单。
可以使用get方法从缓存中获取数据。
如果数据不存在于缓存中,则返回null。
例如:```javaStringvalue=cache.get("key");//从缓存中获取数据```3.移除缓存数据使用JavaCache移除缓存数据也非常简单。
可以使用remove方法从缓存中移除指定的数据。
例如:```javacache.remove("key");//从缓存中移除数据```4.配置存储引擎和缓存容量JavaCache支持多个存储引擎,每个存储引擎具有不同的性能特点。
可以通过配置存储引擎的类型和名称来扩展缓存。
此外,还可以配置缓存的容量,以确保缓存不会因为存储空间不足而出现性能问题。
springcache学习——@CacheEvict使用详解
springcache学习——@CacheEvict使⽤详解1. 功能说明 除了填充缓存,spring cache 也⽀持使⽤ @CacheEvict 来删除缓存。
@CacheEvict 就是⼀个触发器,在每次调⽤被它注解的⽅法时,就会触发删除它指定的缓存的动作。
跟 @Cacheable 和 @CachePut ⼀样,@CacheEvict 也要求指定⼀个或多个缓存,也指定⾃定义⼀的缓存解析器和 key ⽣成器,也⽀持指定条件(condition 参数)。
关于这些(value、cacheNames、key、keyGenerator、cacheManager、cacheResolver、condition)属性参数的⽤法和说明,请参考:2. 例⼦ 我们来举个简单的例⼦,⾸先看⼀下 mysql 数据,我们想要删除 name=“微服务测试0修改⼀下试试” 这条数据(逻辑删除) 这条数据在 redis 中已经存在了 接下来我们编写⼀个删除⽅法,并使⽤ @CacheEvict 注解:@Override@CacheEvict(value = "menuById", key = "#id")public Boolean deleteById(String id) {return this.removeById(id);} 然后在 controller 调⽤它:@DeleteMapping("/deleteById/{id}")public Boolean deleteById(@PathVariable("id")String id){return menuService.deleteById(id);} 接下来,我们请求⼀下接⼝,看看结果是否删除成功的: 再看看 mysq 数据的 del 字段和 redis 是否还有数据: 可以看到,mysql 和缓存都删除成功了。
SpringBoot中使用cache缓存的方法
SpringBoot中使用cache缓存的方法在Spring Boot中使用缓存可以提高应用程序的性能和响应速度,减少对数据库或外部服务的依赖。
Spring Boot提供了方便的注解来实现缓存功能,下面是使用缓存的方法。
步骤一:配置缓存管理器```javapublic class CacheConfigpublic CacheManager cacheManageSimpleCacheManager cacheManager = new SimpleCacheManager(;cacheManager.setCaches(Arrays.asList(new ConcurrentMapCache("exampleCache"))); // 设置一个缓存return cacheManager;}```步骤二:使用缓存注解在需要缓存的方法上添加缓存相关的注解。
Spring Boot提供了以下几个常用的缓存注解:```javapublic class ExampleServicepublic String getExampleData(String id)return "data for id " + id;}public void deleteExampleData(String id)}public String updateExampleData(String id, String newData)return newData;}})public void deleteMultipleExampleData(String id1, String id2) }```步骤三:配置缓存属性可以通过在application.properties或application.yml文件中配置缓存相关的属性。
以下是一些常用的配置选项:```properties#设置缓存的过期时间(单位毫秒)#设置缓存的最大数量spring.cache.redis.max-entries=1000#设置缓存的名称和类型spring.cache.cache-names=exampleCachespring.cache.type=simple```步骤四:使用缓存最后,在需要使用缓存的地方调用相关的方法即可。
springboot缓存管理器(CacheManager)讲解——超详细!!!
springboot缓存管理器(CacheManager)讲解——超详细⼀、引⼊随着java的慢慢学习,缓存的使⽤也越来越多。
我们使⽤缓存⼤多数是通过api的⽅式来操作,厉害的⼈也可以⾃⼰⾃定义注解来简化操作,但是看完这篇博客,以后操作注解就不会辣么⿇烦了。
因为spring中提供了CacheManager接⼝和⼀些注解⽅便我们来操作。
在我们接触的缓存⼤致两种,本地缓存与中间件缓存。
spring对常⽤的缓存都进⾏了⼀些封装。
可以通过ctrl+h查看CacheManager的继承类,主要有SimplerCacheManager(内部⼀个CurrentMap)与RedisCacheManager、EhCacheManager等。
⼆、demo操作技巧在⾃⼰动⼿写demo之前,希望能知道⼀些基础知识。
我们操作缓存是需要CacheManager与以下四种注解配合的:1. EnableCache开启Cache注解功能。
2. Cacheable根据键从缓存中取值,存在获取到后直接返回。
键不存在则执⾏⽅法,将返回结果放⼊到缓存中。
3. CachePut根据键从缓存中取值,⽆论如何,⽅法都会被执⾏,且返回值存⼊缓存中4. CacheEvict执⾏⽅法后,删除缓存中数据以上四种注解,除去第⼀个写在类上,后⾯三个都是写在⽅法上,常⽤的参数如下:1. value/cacheNames定义缓存的名字2. 定义缓存的名字3. keykey 属性是来指定缓存数据所使⽤的的 key,默认使⽤的是⽅法调⽤传过来的参数作为 key4. condition、unless⽀持SqEl表达式,都是判断条件,是否使⽤缓存案列:@Cacheable(cacheNames="test",,key = "#test = 3")此时给注解表⽰会获取键值为test::3的key,如果不存在,就执⾏⽅法,将结果放⼊缓存中。
springbootehcache配置使用方法代码详解
springbootehcache配置使⽤⽅法代码详解EhCache是⼀个⽐较成熟的Java缓存框架,最早从hibernate发展⽽来,是进程中的缓存系统,它提供了⽤内存,磁盘⽂件存储,以及分布式存储⽅式等多种灵活的cache管理⽅案,快速简单。
Springboot对ehcache的使⽤⾮常⽀持,所以在Springboot中只需做些配置就可使⽤,且使⽤⽅式也简易。
下⾯通过本⽂给⼤家介绍springboot ehcache 配置使⽤⽅法,具体内容如下所⽰:1. pom 引⼊依赖<!-- Ehcache --><dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId></dependency>2.resources ⽬录下直接放个⽂件ehcache.xml<ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="/ehcache.xsd"updateCheck="false"><diskStore path="java.io.tmpdir"/><!--defaultCache:echcache的默认缓存策略 --><defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"maxElementsOnDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></defaultCache><!-- 菜单缓存策略 --><cache name="menucache"maxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"maxElementsOnDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></cache></ehcache>3.在Service层⽅法上加上注解@CacheEvict(value="menucache", allEntries=true) ,更新缓存@Cacheable(key="'menu-'+#parentId",value="menucache") 读取缓存,"'menu-'+#parentId" 通配符,也可以直接写死字符串menucache 对应上⾯ xmlname="menucache"/**删除菜单* @param MENU_ID* @*/@CacheEvict(value="menucache", allEntries=true)public void deleteMenuById(String MENU_ID) throws Exception{this.cleanRedis();menuMapper.deleteMenuById(MENU_ID);}/*** 通过ID获取其⼦⼀级菜单* @param parentId* @return* @*/@Cacheable(key="'menu-'+#parentId",value="menucache")public List<Menu> listSubMenuByParentId(String parentId) throws Exception {return menuMapper.listSubMenuByParentId(parentId);}到此这篇关于springboot ehcache 配置使⽤⽅法代码详解的⽂章就介绍到这了,更多相关springboot ehcache 配置使⽤内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。
springboot添加cache缓存,并添加自定义缓存配置
springboot添加cache缓存,并添加⾃定义缓存配置maven依赖<!-- 缓存 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency><!-- 引⼊ehcache⽀持 --><dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId></dependency>全局配置和具体实现启动类上⾯添加@EnableCaching 注解@SpringBootApplication@EnableCachingpublic class EpidemicApplication {public static void main(String[] args) {SpringApplication.run(EpidemicApplication.class, args);}}实现上⾯添加@Cacheable@Component@CacheConfig(cacheNames = "orgCode")public class OrgCodeDaoImpl implements OrgCodeDao {@Autowiredprivate OrgCodeRepository orgCodeRepository;@Cacheable(value = "orgCodeFindAll")@Overridepublic List<OrgCode> findAll() {return orgCodeRepository.findAll();}}实体类需要实现Serializablepublic class OrgCode implements Serializable {}⾃定义配置resource⽬录下添加ehcache.xml,或者在application.properties⽂件中添加配置⽂件路径spring.cache.ehcache.config=ehcache.xml具体配置⽂件内容:<ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="/ehcache.xsd"><diskStore path="java.io.tmpdir"/><defaultCachemaxElementsInMemory="50000"maxElementsOnDisk="100000"eternal="true"overflowToDisk="true"diskPersistent="false"timeToIdleSeconds="0"timeToLiveSeconds="0"diskSpoolBufferSizeMB="50"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LFU"/><cache name="orgCodeFindAll"maxElementsInMemory="1"maxElementsOnDisk="100000"eternal="false"overflowToDisk="true"diskPersistent="false"timeToIdleSeconds="0"timeToLiveSeconds="21600"diskSpoolBufferSizeMB="50"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="FIFO"/></ehcache><!--/ehcache.xsd ⽂件idea报错,可以访问地址,将⽂件下载后引⼊项⽬,或者忽略报错,测试报错不影响使⽤diskStore:设置缓存⽂件 .data 的创建路径user.home – ⽤户主⽬录;user.dir – ⽤户当前⼯作⽬录java.io.tmpdir – 默认临时⽂件路径name:缓存名称.maxElementsInMemory:缓存最⼤个数.maxElementsOnDisk:磁盘中最⼤缓存对象数,若是0表⽰⽆穷⼤.eternal="false":缓存中对象是否为永久的,如果为true,超时设置将被忽略,对象从不过期overflowToDisk="true":当内存中对象数量达到maxElementsInMemory时,Ehcache将会对象写到磁盘中.diskPersistent:是否缓存虚拟机重启期数据,默认为false.timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒),当缓存闲置 n 秒后销毁.仅当eternal=false对象不是永久有效时使⽤,可选属性,默认值是0,也就是可闲置时间⽆穷⼤.timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒),从开始创建的时间算起,当缓存存活 n 秒后销毁.最⼤时间介于创建时间和失效时间之间.仅当eternal=false对象不是永久有效时使⽤,默认是0.,也就是对象存活时间⽆穷⼤.diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区⼤⼩.默认是30MB.每个Cache都应该有⾃⼰的⼀个缓冲区.diskExpiryThreadIntervalSeconds:对象检测线程运⾏时间间隔.标识对象状态的线程多长时间运⾏⼀次.memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存.默认策略是LRU(最近最少使⽤).你可以设置为FIFO(先进先出)或是LFU(较少使⽤).clearOnFlush:内存数量最⼤时是否清除.-->附录报错调试1.ng.IllegalArgumentException: Cannot find cache named '' for Builder[public java.util.List com.avivacofco.epidemic.hr.dao.impl.HrUserDaoImpl.findAll()] caches=[hrFindAll] | key='' | keyGenerator='' | cacheManager='' | cacheResolver='' | con 解决⽅案:在ehcache.xml中添加具体cache配置cache注解其中重要的是两个属性即 value 和 key,其中value必填,并且在ehcache.xml中进⾏配置,key可以为空,如为空,spring会使⽤默认策略⽣成key。
springboot+springcache实现两级缓存(redis+caffeine)
springboot+springcache实现两级缓存(redis+caffeine)spring boot中集成了spring cache,并有多种缓存⽅式的实现,如:Redis、Caffeine、JCache、EhCache等等。
但如果只⽤⼀种缓存,要么会有较⼤的⽹络消耗(如Redis),要么就是内存占⽤太⼤(如Caffeine这种应⽤内存缓存)。
在很多场景下,可以结合起来实现⼀、⼆级缓存的⽅式,能够很⼤程度提⾼应⽤的处理效率。
内容说明:1. 缓存、两级缓存2. spring cache:主要包含spring cache定义的接⼝⽅法说明和注解中的属性说明3. spring boot + spring cache:RedisCache实现中的缺陷4. caffeine简介5. spring boot + spring cache 实现两级缓存(redis + caffeine)缓存、两级缓存简单的理解,缓存就是将数据从读取较慢的介质上读取出来放到读取较快的介质上,如磁盘-->内存。
平时我们会将数据存储到磁盘上,如:数据库。
如果每次都从数据库⾥去读取,会因为磁盘本⾝的IO影响读取速度,所以就有了像redis这种的内存缓存。
可以将数据读取出来放到内存⾥,这样当需要获取数据时,就能够直接从内存中拿到数据返回,能够很⼤程度的提⾼速度。
但是⼀般redis是单独部署成集群,所以会有⽹络IO上的消耗,虽然与redis集群的链接已经有连接池这种⼯具,但是数据传输上也还是会有⼀定消耗。
所以就有了应⽤内缓存,如:caffeine。
当应⽤内缓存有符合条件的数据时,就可以直接使⽤,⽽不⽤通过⽹络到redis中去获取,这样就形成了两级缓存。
应⽤内缓存叫做⼀级缓存,远程缓存(如redis)叫做⼆级缓存spring cache当使⽤缓存的时候,⼀般是如下的流程:从流程图中可以看出,为了使⽤缓存,在原有业务处理的基础上,增加了很多对于缓存的操作,如果将这些耦合到业务代码当中,开发起来就有很多重复性的⼯作,并且不太利于根据代码去理解业务。
cacheevict 原理
cacheevict 原理CacheEvict是Spring框架中的一种标注,用于在缓存中删除一个或多个条目。
它通常用于在数据修改时,清除与该数据有关联的缓存,以保证数据的准确性。
CacheEvict的工作原理如下:1. 当方法调用时,Spring框架首先检查缓存中是否已存在该方法的结果。
如果存在,则返回缓存中的值,而不是执行方法体。
2. 如果缓存中不存在该方法的结果,则调用方法执行体,将返回的结果放入缓存中。
3. 如果方法被标记为CacheEvict,那么在方法执行后,Spring框架会从缓存中删除该方法的结果。
具体来说,CacheEvict支持以下属性:value:指定缓存的名称,需要在Spring配置文件中进行定义。
可以设置多个缓存名称作为数组,表示清除多个缓存。
key:指定用于删除缓存条目的键,用SpEL表达式进行配置。
缺省情况下,Spring会使用方法的参数列表作为缓存条目的键。
如果需要自定义缓存键,可以通过这个属性进行设置。
condition:指定在何种情况下删除缓存条目,用SpEL表达式进行配置。
例如,可以通过设置“#result==null”来表示只有在方法返回值为null时才删除缓存条目。
allEntries:指定是否清除缓存中所有条目。
默认值为false,表示只删除与当前方法有关的缓存条目。
如果设置为true,那么将清除该缓存中的所有条目。
CacheEvict有助于提高系统性能和响应速度,可以使缓存与数据库保持同步。
它适用于对缓存数据要求较高的场景,例如金融交易系统、在线游戏等。
但需要注意的是,缓存清除也可能导致缓存雪崩和缓存穿透等问题,因此需要谨慎使用和合理配置。
总之,CacheEvict是Spring框架中常用的缓存清除标注,通过它可以方便地清除缓存条目,保证缓存数据的准确性和一致性。
Spring缓存注解@Cache使用
Spring缓存注解@Cache使⽤@Cacheable @Cacheable 的作⽤主要针对⽅法配置,能够根据⽅法的请求参数对其结果进⾏缓存@Cacheable 作⽤和配置⽅法参数解释examplevalue缓存的名称,在 spring 配置⽂件中定义,必须指定⾄少⼀个例如:@Cacheable(value=”mycache”)@Cacheable(value={”cache1”,”cache2”}key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照⽅法的所有参数进⾏组合@Cacheable(value=”testcache”,key=”#userName”)condition缓存的条件,可以为空,使⽤ SpEL 编写,返回 true 或者 false,只有为 true 才进⾏缓存@Cacheable(value=”testcache”,condition=”#userName.length()>2”)实例 @Cacheable(value=”accountCache”),这个注释的意思是,当调⽤这个⽅法的时候,会从⼀个名叫 accountCache 的缓存中查询,如果没有,则执⾏实际的⽅法(即查询),并将执⾏的结果存⼊缓存中,否则返回缓存中的对象。
这⾥的缓存中的 key 就是参数 userName,value 就是 Account 对象。
“accountCache”缓存是在spring*.xml 中定义的名称。
@Cacheable(value="accountCache")// 使⽤了⼀个缓存名叫 accountCachepublic Account getAccountByName(String userName) {// ⽅法内部实现不考虑缓存逻辑,直接实现业务System.out.println("real query account."+userName);return getFromDB(userName);}@CachePut@CachePut 的作⽤主要针对⽅法配置,能够根据⽅法的请求参数对其结果进⾏缓存,和 @Cacheable 不同的是,它每次都会触发真实⽅法的调⽤@CachePut 作⽤和配置⽅法参数解释examplevalue缓存的名称,在 spring 配置⽂件中定义,必须指定⾄少⼀个@CachePut(value=”my cache”)key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照⽅法的所有参数进⾏组合@CachePut(value=”testcache”,key=”#userName”)condition缓存的条件,可以为空,使⽤ SpEL 编写,返回 true 或者 false,只有为 true 才进⾏缓存@CachePut(value=”testcache”,condition=”#userName.length()>2”)实例@CachePut 注释,这个注释可以确保⽅法被执⾏,同时⽅法的返回值也被记录到缓存中,实现缓存与数据库的同步更新。
SpringCache之@CachePut的使用
SpringCache之@CachePut的使⽤使⽤CachePut注解,该⽅法每次都会执⾏,会清除对应的key值得缓存(或者更新),分为以下两种情况:如果返回值null,下次进⾏该key值查询时,还会查⼀次数据库,此时相当于@CacheEvict注解;如果返回值不为null,此时会进⾏该key值缓存的更新,更新缓存值为返回的数据;分析:情况⼀返回值为null://使⽤Redis缓存@Cacheable(value="Manager",key="#id")public User findById(Integer id) {System.out.println("---查数据库DB-----");return userMapper.selectByPrimaryKey(id);}@CachePut(value="Manager",key="#manager.getId()")//@CacheEvict(value="Manager",key="#manager.getId()")//清除数据public User update(User manager) {userMapper.updateByPrimaryKeySelective(manager);//return userMapper.selectByPrimaryKey(manager.getId());return null;}情况⼆返回值不为null:先进⾏数据id为1的查询,发现下次查询id为1的数据不会再查询DB,直接⾛缓存;此时进⾏id为1数据更新操作,并且返回值为null;进⾏id为1的数据查询,发现此时id为1缓存不存在,进⾏DB查询;//使⽤Redis缓存@Cacheable(value="Manager",key="#id")public User findById(Integer id) {System.out.println("---查数据库DB-----");return userMapper.selectByPrimaryKey(id);}@CachePut(value="Manager",key="#manager.getId()")//@CacheEvict(value="Manager",key="#manager.getId()")//清除数据public User update(User manager) {userMapper.updateByPrimaryKeySelective(manager);return userMapper.selectByPrimaryKey(manager.getId());//return null;}先进⾏数据id为1的查询,发现下次查询id为1的数据不会再查询DB,直接⾛缓存;此时进⾏id为1数据更新操作,返回值不为null;进⾏id为1的数据查询,发现此时id为1缓存被更新为更新的数据,且没有进⾏DB查询操作;补充:@CachePut和@Cacheable的区别@CachePut负责增加缓存@Cacheable负责查询缓存,如果没查到,则将执⾏⽅法,并将⽅法的结果增加到缓存以上为个⼈经验,希望能给⼤家⼀个参考,也希望⼤家多多⽀持。
springCache注解详解
springCache注解详解@CacheConfig:主要⽤于配置该类中会⽤到的⼀些共⽤的缓存配置。
在这⾥@CacheConfig(cacheNames = "users"):配置了该数据访问对象中返回的内容将存储于名为users的缓存对象中,我们也可以不使⽤该注解,直接通过@Cacheable⾃⼰配置缓存集的名字来定义。
@Cacheable:配置了findByName函数的返回值将被加⼊缓存。
同时在查询时,会先从缓存中获取,若不存在才再发起对数据库的访问。
该注解主要有下⾯⼏个参数:@Cacheable(cacheNames="books", key="#isbn")public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)@Cacheable(cacheNames="books", key="#isbn.rawNumber")public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)@Cacheable(cacheNames="books", key="T(someType).hash(#isbn)")public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)@Cacheable(cacheNames="books", key="#map['bookid'].toString()")public Book findBook(Map<String, Object> map)缓存的同步 sync:在多线程环境下,某些操作可能使⽤相同参数同步调⽤。
springboot(九)Cache缓存和Redis缓存
springboot(九)Cache缓存和Redis缓存1. Cache缓存1.1 缓存的概念&缓存注解Cache缓存接⼝,定义缓存操作。
实现有:RedisCache、EhCacheCache、ConcurrentMapCache等CacheManager缓存管理器,管理各种缓存(Cache)组件@Cacheable主要针对⽅法配置,能够根据⽅法的请求参数对其结果进⾏缓存@CacheEvict清空缓存@CachePut保证⽅法被调⽤,⼜希望结果被缓存。
@EnableCaching开启基于注解的缓存keyGenerator缓存数据时key⽣成策略serialize缓存数据时value序列化策略1.2 @Cacheable/@CachePut/@CacheEvict 主要的参数value缓存的名称,在 spring 配置⽂件中定义,必须指定⾄少⼀个例如:@Cacheable(value=”mycache”) 或者@Cacheable(value={”cache1”,”cache2”}key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照⽅法的所有参数进⾏组合例如:@Cacheable(value=”testcache”,key=”#userName”)condition缓存的条件,可以为空,使⽤ SpEL 编写,返回true 或者 false,只有为true 才进⾏缓存/清除缓存,在调⽤⽅法之前之后都能判断例如:@Cacheable(value=”testcache”, condition=”#userName.length()>2”)allEntries(@CacheEvict )是否清空所有缓存内容,缺省为 false,如果指定为true,则⽅法调⽤后将⽴即清空所有缓存例如:@CachEvict(value=”testcache”,allEntries=true)beforeInvocation (@CacheEvict)是否在⽅法执⾏前就清空,缺省为 false,如果指定为 true,则在⽅法还没有执⾏的时候就清空缓存,缺省情况下,如果⽅法执⾏抛出异常,则不会清空缓存例如:@CachEvict(value=”testcache”,beforeInvocation=true)unless(@CachePut) (@Cacheable)⽤于否决缓存的,不像condition,该表达式只在⽅法执⾏之后判断,此时可以拿到返回值result进⾏判断。
关于Spring中一级缓存、二级缓存和三级缓存的那些事
关于Spring中⼀级缓存、⼆级缓存和三级缓存的那些事⽬录题记缓存作⽤分析⼀级缓存、⼆级缓存、三级缓存区别是什么总结题记常常听到别⼈提起:“⼀级缓存、⼆级缓存、三级缓存”。
那么它们是什么呢?有什么作⽤呢?缓存作⽤分析Spring中的⼀级缓存名为singletonObjects,⼆级缓存名为earlySingletonObjects,三级缓存名为singletonFactories,除了⼀级缓存是ConcurrentHashMap之外,⼆级缓存和三级缓存都是HashMap。
它们的定义是在DefaultSingletonBeanRegistry类中。
⼀级缓存-singletonObjects是⽤来存放就绪状态的Bean。
保存在该缓存中的Bean所实现Aware⼦接⼝的⽅法已经回调完毕,⾃定义初始化⽅法已经执⾏完毕,也经过BeanPostProcessor实现类的postProcessorBeforeInitialization、postProcessorAfterInitialization⽅法处理;⼆级缓存-earlySingletonObjects是⽤来存放早期曝光的Bean,⼀般只有处于循环引⽤状态的Bean才会被保存在该缓存中。
保存在该缓存中的Bean所实现Aware⼦接⼝的⽅法还未回调,⾃定义初始化⽅法未执⾏,也未经过BeanPostProcessor实现类的postProcessorBeforeInitialization、postProcessorAfterInitialization⽅法处理。
如果启⽤了Spring AOP,并且处于切点表达式处理范围之内,那么会被增强,即创建其代理对象。
这⾥额外提⼀点,普通Bean被增强(JDK动态代理或CGLIB)的时机是在AbstractAutoProxyCreator实现的BeanPostProcessor的postProcessorAfterInitialization⽅法中,⽽处于循环引⽤状态的Bean被增强的时机是在AbstractAutoProxyCreator实现的SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference⽅法中。
caffeinecachemanager用法
caffeinecachemanager用法CaffeineCacheManager是一个类,用于将Spring的cache管理器接口实现为基于Caffeine的缓存管理器。
它是基于Java 8中Caffeine库的实现,因此,要使用CaffeineCacheManager,您必须首先在项目中添加Caffeine库。
CaffeineCacheManager的使用方法非常简单,只需要在Spring配置文件中进行少量配置即可。
下面是一些常用的配置。
1.创建CaffeineCacheManager bean要使用CaffeineCacheManager,您必须首先创建一个bean。
通过在Spring配置文件中添加以下代码来创建bean:``` @Configuration public class CacheConfig {@Bean public CaffeineCacheManager caffeineCacheManager() { return new CaffeineCacheManager(); }} ```2.将bean注册为缓存管理器要使用CaffeineCacheManager作为缓存管理器,您必须将其注册到Spring的cache管理器中。
通过在Spring 配置文件中添加以下代码来注册bean:``` @Configuration @EnableCaching public class CacheConfig {@Bean public CaffeineCacheManager caffeineCacheManager() { return new CaffeineCacheManager(); }@Bean public CacheManagercacheManager(CaffeineCacheManager caffeineCacheManager) { return caffeineCacheManager; }} ```3.配置缓存要在CaffeineCacheManager中配置缓存,您可以使用以下方法之一:- 在bean方法上添加@Cacheable注释 - 在类级别上添加@CacheConfig注释,然后在方法上使用@Cacheable注释 - 直接在CaffeineCacheManager bean上添加缓存配置下面是一个基于@Cacheable注释的示例:``` @Service public class UserService {@Cacheable(value = "usersCache", key ="#userId") public User getUser(String userId) { // Some logic to retrieve user return user; } } ```在这个示例中,“usersCache”是缓存的名称,“#userId”是缓存键。
concurrentmapcache 原理
concurrentmapcache 原理ConcurrentMapCache是Spring框架中的一种缓存实现方式,它基于ConcurrentMap并实现了Spring的Cache接口。
它是一个线程安全的缓存实现,能够在多线程环境下保证数据的一致性和线程安全性。
ConcurrentMapCache的原理主要基于ConcurrentMap接口,ConcurrentMap是Java中线程安全的HashMap实现,可以支持并发的读写操作。
ConcurrentMapCache在缓存数据时,会将数据存储在一个ConcurrentMap中,其中键是缓存的名称,值是实际的缓存数据。
在读取缓存数据时,会直接从ConcurrentMap中读取数据,而在写入缓存数据时,会使用ConcurrentMap的putIfAbsent()方法来保证线程安全性。
ConcurrentMapCache的使用非常简单,只需要在Spring的配置文件中配置好缓存的名称和缓存的有效时间,然后在需要缓存的方法上添加@Cacheable注解即可。
当方法第一次被调用时,会将返回值缓存起来,之后的调用会直接从缓存中获取数据,而不会再执行实际的方法体。
ConcurrentMapCache的优点在于它的简单易用和线程安全性,能够在多线程环境下保证数据的一致性和线程安全性。
但是它也有一些缺点,比如在大规模数据量和高并发的情况下,性能可能会有一定的影响,因为ConcurrentMap的实现是基于分段锁的,可能会存在一定的竞争。
总的来说,ConcurrentMapCache是一种简单且实用的缓存实现方式,适用于一般的应用场景,能够满足大部分的缓存需求。
在实际的应用中,可以根据具体的情况选择合适的缓存实现方式,来保证系统的性能和可靠性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
结合测试类发现,显然第二次调用没有进service实现类
5、下面补充几个概念
@Cacheable、@CachePut、@CacheEvict 注释介绍
通过上面的例子,我们可以看到 spring cache 主要使用两个注释标签,即 @Cacheable、@CachePut 和 @CacheEvict,我们总结一下其作用和配置方法。
表 1. @Cacheable 作用和配置方法
@Cacheable 的作用主要针对方法配置,能够根据方法的请求参数对其结果进行缓存
@Cacheable
主要的参数
value缓存的名称,在 spring 配置文件中定义,必须指定至少一个例如:
@Cacheable(value=”mycache”) 或者
@Cacheable(value={”cache1”,”cache2”}
key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合例如:
@Cacheable(value=”testcache”,key=”#u serName”)
condition缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存例如:
@Cacheable(value=”testcache”,condition =”#userName.length()>2”)
表 2. @CachePut 作用和配置方法
@CachePut 的作用主要针对方法配置,能够根据方法的请求参数对其结果进行缓存,和 @Cacheable 不同的是,它每次都会触发真实方法的调用
@CachePut
主要的参数
value缓存的名称,在 spring 配置文件中定义,必须指定至少一个例如:
@Cacheable(value=”mycache”) 或者
@Cacheable(value={”cache1”,”cache2”}
key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合例如:
@Cacheable(value=”testcache”,key=”#us erName”)
condition缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存例如:
@Cacheable(value=”testcache”,condition =”#userName.length()>2”)
表 3. @CacheEvict 作用和配置方法
@CachEvict 的作用主要针对方法配置,能够根据一定的条件对缓存进行清空@CacheEvi
ct 主要的参
数
value缓存的名称,在 spring 配置文件中定义,必须指定至少一个例如:
@CachEvict(value=”mycach e”) 或者
@CachEvict(value={”cache1”,”cache2”}
key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合例如:
@CachEvict(value=”testcach e”,key=”#userName”)
condition缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才清空缓存例如:
@CachEvict(value=”testcach e”,
condition=”#userName.lengt h()>2”)
allEntries是否清空所有缓存内容,缺省为 false,如果指定为 true,则方法调用后将立即清空所有缓存例如:
@CachEvict(value=”testcach e”,allEntries=true)
beforeInvoca tion 是否在方法执行前就清空,缺省为 false ,如果指定为 true ,则在方法还没有执行的时候就清空缓存,缺省情况下,如果方法执行抛出异常,则不会清空缓存例如:
@CachEvict(value=”testcach e”,beforeInvocation=true)。