企业网站建设版本,wordpress自动发货如何设置,有没有可以发布需求的网站,电脑网页打不开怎么回事#x1f440;中文文档
Caffeine
#x1f440;使用Caffeine #xff08;本地缓存#xff09;
当与Spring Boot结合使用时#xff0c;Caffeine提供了一个直观且功能强大的二级缓存解决方案。Spring Boot的缓存抽象使得整合Caffeine变得相当简单。以下是如何在Spring Boot…中文文档
Caffeine
使用Caffeine 本地缓存
当与Spring Boot结合使用时Caffeine提供了一个直观且功能强大的二级缓存解决方案。Spring Boot的缓存抽象使得整合Caffeine变得相当简单。以下是如何在Spring Boot应用中使用Caffeine作为二级缓存的方法
结合Spring Boot让我们对Caffeine的各个方面进行一个快速概览
✌1. 添加:
手动或自动地将条目添加到缓存中。使用cache.put(key, value)可以手动添加。
✍1. 手动加载 作用 手动加载是在需要时显式地调用缓存的 get 方法来加载数据。 使用场景 适用于需要精确控制加载时机和逻辑的情况。 示例代码基于 Spring Boot
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Service;Service
public class MyService {private final Cache myCache;public MyService(CacheManager cacheManager) {this.myCache cacheManager.getCache(myCache);}public String getDataById(String id) {Cache.ValueWrapper valueWrapper myCache.get(id);if (valueWrapper ! null) {return (String) valueWrapper.get();} else {// 手动加载数据的逻辑String loadedData loadData(id);myCache.put(id, loadedData);return loadedData;}}private String loadData(String id) {// 手动加载数据的逻辑// ...return data;}
}✍2. 自动加载 作用 自动加载是指当缓存中不存在某个键的数据时自动触发加载数据并将其存入缓存。 使用场景 适用于数据加载逻辑相对简单的情况。 示例代码基于 Spring Boot
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class MyService {Cacheable(value myCache, key #id)public String getDataById(String id) {// 自动加载数据的逻辑String loadedData loadData(id);return loadedData;}private String loadData(String id) {// 数据加载逻辑// ...return data;}
}✍3. 手动异步加载 作用 手动异步加载是在需要数据时手动调用异步方法来加载数据然后将加载的数据存入缓存。 使用场景 适用于数据加载可能耗时较长且不希望阻塞主线程的情况。 示例代码基于 Spring Boot
import org.springframework.scheduling.annotation.Async;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Service;Service
public class MyService {private final Cache myCache;public MyService(CacheManager cacheManager) {this.myCache cacheManager.getCache(myCache);}Asyncpublic void fetchDataAsync(String id) {String loadedData fetchDataFromDatabase(id);if (loadedData ! null) {myCache.put(id, loadedData);} else {// 如果数据为空可以进行一些处理例如记录日志等}}private String fetchDataFromDatabase(String id) {// 异步加载数据的逻辑例如从数据库获取数据// ...return data;}
}✍4. 自动异步加载 作用 自动异步加载是指当缓存中不存在某个键的数据时自动触发异步加载数据并将其存入缓存。 使用场景 适用于数据加载可能耗时较长且需要自动触发的情况。 示例代码基于 Spring Boot
import org.springframework.scheduling.annotation.Async;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class MyService {AsyncCacheable(value myCache, key #id)public String getDataById(String id) {// 异步加载数据的逻辑String loadedData loadData(id);return loadedData;}private String loadData(String id) {// 异步加载数据的逻辑// ...return data;}
}✌2. 驱逐:
基于大小、权重或时间等策略来移除缓存条目。maximumSize、expireAfterAccess等策略可用于配置。在 Spring Boot 中结合 Caffeine 缓存库Caffeine 提供了三种驱逐eviction策略用于控制缓存中的数据何时被清除。这三种驱逐策略分别是基于大小的驱逐、基于时间的驱逐和基于引用的驱逐。下面将为每种策略提供作用、使用场景、优缺点和示例代码并结合 Spring Boot 进行说明。
✍1. 基于大小的驱逐 作用 基于大小的驱逐策略在缓存达到一定大小限制时会驱逐一些缓存项以腾出空间。 使用场景 适用于需要限制缓存大小以防止内存占用过多的情况。 优点 可以有效控制缓存的内存使用避免内存溢出问题。 缺点 不适用于某些情况如需要保留所有数据而不基于大小驱逐。
代码配置示例
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().maximumSize(100) // 最大缓存项数量.build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}配置文件配置示例
# application.properties
spring.cache.cache-namesmyCache
spring.cache.caffeine.specmaximumSize100✍2. 基于时间的驱逐 作用 基于时间的驱逐策略会根据设置的过期时间自动清除缓存项。 使用场景 适用于需要缓存数据有时效性的场景例如缓存一些临时数据。 优点 简单易用适用于具有时效性数据的场景。 缺点 不适用于那些需要在数据使用频繁时保持缓存的场景。
代码配置示例
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().expireAfterWrite(30, TimeUnit.MINUTES) // 设置过期时间.build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}配置文件配置示例
# application.properties
spring.cache.cache-namesmyCache
spring.cache.caffeine.specexpireAfterWrite30m✍3. 基于引用的驱逐 作用 基于引用的驱逐策略根据 Java 的引用类型决定是否清除缓存项。 使用场景 适用于需要更加灵活的缓存策略可以根据引用情况进行驱逐。 优点 可以更精细地控制缓存项的驱逐适应不同类型的需求。 缺点 较复杂需要了解 Java 的引用类型。
代码配置示例
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().weakKeys() // 使用弱引用作为键.weakValues() // 使用弱引用作为值.build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}配置文件配置示例
# application.properties
spring.cache.cache-namesmyCache
spring.cache.caffeine.specweakKeys,weakValues✌3. 移除:
当条目不再需要时它们会被移除。使用cache.invalidate(key)可以手动移除条目。
当结合 Spring Boot 使用 Caffeine 缓存库时下面是 Caffeine 提供的三种移除eviction策略以及针对每种策略的作用、使用场景、优缺点和示例代码分别提供了通过代码配置和配置文件配置的示例。
✍1. SIZE_BASED 作用 在缓存项数量达到指定阈值时移除最近最少使用的缓存项。 使用场景 适用于需要限制缓存大小同时保留经常访问的数据的场景。 优点 能够限制缓存项数量同时保持常用数据的缓存。 缺点 可能会移除一些仍然有用的数据。
代码配置示例
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().maximumSize(100) // 最大缓存项数量.evictionListener((key, value, cause) -System.out.println(Evicted key: key , cause: cause)).build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}配置文件配置示例
# application.properties
spring.cache.cache-namesmyCache
spring.cache.caffeine.specmaximumSize100✍2. TIME_BASED 作用 在缓存项的固定时间段内不被访问时移除缓存项。 使用场景 适用于需要保留数据一段时间并且数据在一段时间后变得过期或不再有效的场景。 优点 简单易用适用于有时效性需求的数据。 缺点 无法根据数据的实际使用情况来移除。
代码配置示例
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;
import org.springframework.cache.caffeine.CaffeineCacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().expireAfterAccess(30, TimeUnit.MINUTES) // 访问后过期时间.evictionListener((key, value, cause) -System.out.println(Evicted key: key , cause: cause)).build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}配置文件配置示例
# application.properties
spring.cache.cache-namesmyCache
spring.cache.caffeine.specexpireAfterAccess30m✍3. ACCESS_BASED 作用 在缓存项被访问一定次数后移除缓存项。 使用场景 适用于需要根据访问频率移除缓存的数据。 优点 可以根据实际使用情况移除缓存项保留经常访问的数据。 缺点 需要实时监控缓存项的访问次数。
代码配置示例
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().maximumSize(100) // 最大缓存项数量.recordStats() // 启用统计.evictionListener((key, value, cause) -System.out.println(Evicted key: key , cause: cause)).build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}配置文件配置示例
# application.properties
spring.cache.cache-namesmyCache
spring.cache.caffeine.specmaximumSize100,recordStats✍4. 驱逐移除示例 作用 驱逐是缓存中数据移除的一种策略通过特定的条件和算法从缓存中移除一些数据以腾出空间。 引起原因 驱逐通常由缓存达到容量限制或者基于时间、大小、引用等的设定的条件触发。最常见的例子是基于大小的驱逐当缓存项数量超过了一定的最大值时系统会自动移除一些缓存项。 示例 在基于大小的驱逐策略中当缓存项数量超过一定限制时会移除最不常用的缓存项。这是通过 Caffeine 的 maximumSize 设置来实现的。
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().maximumSize(100) // 最大缓存项数量.build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}✍5. 失效示例 作用 失效是手动移除缓存元素的操作通常由应用程序代码触发。 引起原因 失效通常由开发人员在特定情况下主动调用比如当数据被更新、删除或者某些条件满足时开发人员可以选择手动将相应的缓存项标记为无效。 示例 失效是手动从缓存中移除特定数据的操作。在 Spring Boot 中你可以通过调用缓存管理器的 evict 方法来手动使缓存项失效。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Scheduled;Configuration
EnableCaching
public class CacheConfig {Autowiredprivate CacheManager cacheManager;// 每小时触发一次失效操作Scheduled(fixedRate 3600000)public void invalidateCache() {cacheManager.getCache(myCache).clear();}
}✍6. 移除示例 作用 移除是驱逐和失效的结果即从缓存中删除数据。 引起原因 移除可以是基于驱逐策略比如基于大小、时间等的结果也可以是开发人员手动调用失效操作导致的结果。 示例 移除是驱逐和失效的结果导致缓存中的数据被删除。下面是基于失效和驱逐的移除示例
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().maximumSize(100) // 最大缓存项数量.evictionListener((key, value, cause) -System.out.println(Evicted key: key , cause: cause)).build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}在 Spring Boot 中使用 Caffeine 缓存库显式移除Explicit Removal和移除监听器Removal Listener是两个重要的概念用于更精细地控制缓存数据的移除行为。下面将详细解释这两个概念并提供项目性的示例代码。
✍7. 显式移除 作用 显式移除是通过代码手动从缓存中移除特定的缓存项。 使用场景 适用于需要根据特定条件或操作主动清除缓存项的场景比如数据更新、删除等。 优点 可以根据业务需求灵活地选择要移除的缓存项从而避免缓存中存储无效或过时数据。 缺点 需要在适当的时机手动调用移除操作。
示例代码基于 Spring Boot
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.CacheManager;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().maximumSize(100) // 最大缓存项数量.build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}// 显式移除示例CacheEvict(cacheNames myCache, key #key)public void removeCacheItem(String key) {// 此方法将从缓存中移除指定 key 的缓存项}
}在上述示例代码中我们使用了 Spring 的 CacheEvict 注解来实现显式移除。在 removeCacheItem 方法中通过指定的 key 参数调用该方法可以手动移除缓存中的指定缓存项。
✍8. 移除监听器 作用 移除监听器是一种机制当缓存项被移除时会触发监听器执行特定的操作。 使用场景 适用于需要在缓存项移除时执行一些后续操作的场景比如记录日志、数据清理等。 优点 允许在缓存项被移除时执行定制化的操作增强了缓存的灵活性。 缺点 需要编写额外的监听器代码增加了一定的复杂性。
示例代码基于 Spring Boot
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.RemovalCause;
import com.github.benmanes.caffeine.cache.RemovalListener;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import java.util.logging.Logger;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().maximumSize(100) // 最大缓存项数量.removalListener(new CustomRemovalListener()) // 添加移除监听器.build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}// 自定义移除监听器private class CustomRemovalListener implements RemovalListenerObject, Object {private final Logger logger Logger.getLogger(getClass().getName());Overridepublic void onRemoval(Object key, Object value, RemovalCause cause) {logger.info(Removed key: key , cause: cause);// 在缓存项被移除时记录日志}}
}在上述示例代码中我们通过 removalListener 方法添加了一个自定义的移除监听器当缓存项被移除时会调用监听器中的 onRemoval 方法我们在这个方法中记录了移除的缓存项信息。
这些示例代码演示了如何在 Spring Boot 中结合 Caffeine 缓存库使用显式移除和移除监听器的概念并展示了如何在项目中应用这些概念以满足特定的业务需求。
✌4. 刷新: 作用 刷新策略允许在缓存中的数据保持一定时间后自动更新确保缓存数据的新鲜性。 使用场景 适用于需要定期更新缓存中数据以保持数据的实时性的场景比如缓存数据库查询结果。 优点 使缓存数据保持较新的状态避免数据过时。 缺点 需要考虑缓存的更新频率不适用于所有类型的数据。
✍1. 配置代码中的刷新策略示例
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import java.util.concurrent.TimeUnit;Configuration
EnableCaching
public class CacheConfig {Beanpublic CaffeineObject, Object caffeineConfig() {return Caffeine.newBuilder().expireAfterWrite(30, TimeUnit.MINUTES) // 过期时间.refreshAfterWrite(5, TimeUnit.MINUTES) // 刷新时间.build();}Beanpublic CaffeineCacheManager cacheManager() {CaffeineCacheManager caffeineCacheManager new CaffeineCacheManager();caffeineCacheManager.setCaffeine(caffeineConfig());return caffeineCacheManager;}
}✍2. 配置文件中的刷新策略示例application.properties
# application.properties
spring.cache.cache-namesuserCache
spring.cache.caffeine.specexpireAfterWrite30m,refreshAfterWrite5m在上述代码示例中我们展示了如何通过代码配置和配置文件配置 Caffeine 的刷新策略。在代码配置中我们使用了 expireAfterWrite 方法来设置缓存项的过期时间为 30 分钟以及 refreshAfterWrite 方法来设置刷新时间为 5 分钟。在配置文件配置中我们直接使用了 spring.cache.caffeine.spec 属性来配置刷新策略。
✍3. 示例场景
假设你的 Spring Boot 项目中有一个用户信息缓存你希望用户信息在一段时间后自动刷新以保持实时性。以下是一个项目性的示例
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;import java.util.HashMap;
import java.util.Map;Service
public class UserService {private MapLong, User userDatabase new HashMap();Cacheable(cacheNames userCache, key #userId)public User getUserById(Long userId) {System.out.println(Fetching user from database for userId: userId);// Simulating fetching user data from databasereturn userDatabase.get(userId);}
}在这个示例中getUserById 方法使用了 Spring Cache 的 Cacheable 注解并设置了缓存名称为 “userCache”。刷新策略的配置可以在代码中进行也可以在配置文件中通过属性进行配置。
✌5. 计算:
Caffeine可以使用计算的方式来加载或重新加载条目。适用于需要延迟加载的数据。
当结合 Spring Boot 使用 Caffeine 缓存库时可以利用 Caffeine 提供的不同计算策略来优化缓存的使用。以下将按照你提供的解析方向对每个计算策略进行说明包括作用、使用场景、优缺点以及项目中使用 Spring Boot 的示例代码。
✍1. 写模式
1. 批量和合并操作
批量和合并操作是 Caffeine 缓存提供的一种计算策略旨在优化并发访问下的缓存数据计算和填充过程。这种策略可以有效地将多个相似的请求合并为一个从而降低计算成本、减少缓存填充次数并提高系统性能。以下是对批量和合并操作策略的详细解释
作用 批量和合并操作策略的主要作用是在并发请求中将多个相似的计算请求合并成一个以减少计算成本和缓存填充的开销。
使用场景 批量和合并操作适用于以下场景
并发访问当多个并发请求需要计算相同结果时可以将这些请求合并为一个减少重复计算。缓存填充合并操作可以减少频繁的缓存填充操作降低缓存填充的开销。
优缺点
优点 减少计算成本合并相似请求可以避免重复计算提高计算效率。减少缓存填充合并操作可以降低缓存填充次数减少对底层数据源的访问。提高性能通过减少计算和填充开销可以提高系统的响应性能和吞吐量。 缺点 不适用于不相似请求只有在请求之间存在相似性时才能充分发挥合并操作的优势。
示例代码
假设有一个需要进行重复计算的服务我们可以使用 Caffeine 缓存的批量和合并操作策略来优化。
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class BatchAndMergeService {private final CacheString, String cache Caffeine.newBuilder().build();Cacheable(cacheNames batchAndMergeCache, key #key, sync true, cacheManager caffeineCacheManager)public String computeValue(String key) {// Simulate a time-consuming computationtry {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return ComputedValue for key;}
}在这个示例中computeValue 方法模拟了一个耗时的计算过程。通过使用 Cacheable 注解并将 sync 参数设置为 true我们告诉 Caffeine 缓存要应用批量和合并操作策略。当多个并发请求同时调用 computeValue 方法时只有一个计算实际被执行其他请求会等待该计算完成后直接从缓存中获取计算结果从而避免了重复计算的开销。
总之批量和合并操作策略在并发访问情况下非常有用可以通过合并相似请求来减少计算和缓存填充的开销从而提高系统的性能和效率。
2. 延迟操作指定的时间窗口
延迟操作指定的时间窗口是 Caffeine 缓存提供的一种计算策略它允许你推迟对缓存值的计算以便在实际需要使用这些值之前进行计算从而在不影响数据有效性的情况下降低计算成本。以下是对延迟操作指定的时间窗口策略的详细解释
作用 延迟操作策略的主要作用是将计算操作推迟到数据被实际访问之前以减少不必要的计算开销。
使用场景 延迟操作指定的时间窗口适用于以下场景
高成本计算当计算某个值的成本较高时可以推迟计算只在需要时才进行。数据保持有效性当数据在一定时间内保持有效时可以延迟计算以降低计算压力。
优缺点
优点 减少计算成本推迟计算可以避免不必要的计算开销提高计算效率。利用数据有效性延迟操作可以利用数据的有效性避免计算过早导致的数据失效。 缺点 数据可能不是最新的由于延迟计算缓存中的数据可能不是实时的适用于数据有效时间较长的场景。
示例代码
假设有一个需要复杂计算的服务在某个时间窗口内计算结果保持有效。
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;import java.util.concurrent.TimeUnit;Service
public class DelayedComputeService {private final CacheString, String cache Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES) // Data is valid for 10 minutes.build();Cacheable(cacheNames delayedComputeCache, key #key, cacheManager caffeineCacheManager)public String getDelayedValue(String key) {// Simulate a time-consuming computationtry {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return ComputedValue for key;}
}在这个示例中getDelayedValue 方法模拟了一个耗时的计算过程。通过使用 Cacheable 注解并配置 expireAfterWrite我们告诉 Caffeine 缓存将缓存值保持有效时间为 10 分钟。因此当多个请求访问相同的 key 时在时间窗口内只有第一个请求会执行实际计算其他请求直接从缓存中获取计算结果从而减少了重复计算。
综上所述延迟操作指定的时间窗口策略适用于需要复杂计算且数据保持有效性的场景通过推迟计算以减少不必要的计算开销并利用数据有效性来提高计算效率。
3. 批处理数据超过阈值大小
批处理数据超过阈值大小是 Caffeine 缓存提供的一种计算策略它允许在定期刷新之前如果批处理数据量超过设定的阈值大小提前触发批处理操作确保数据及时刷新。这个策略可以有效地减轻定期刷新时的压力确保缓存中的数据保持最新。以下是对批处理数据超过阈值大小策略的详细解释
作用 批处理数据超过阈值大小策略的主要作用是在定期刷新之前根据批处理数据量是否超过阈值来提前触发批处理操作确保缓存中的数据及时刷新。
使用场景 批处理数据超过阈值大小适用于以下场景
定期刷新当缓存需要定期刷新时通过批处理数据来减轻刷新时的压力。数据更新频繁当数据更新频繁可能在定期刷新前达到阈值可以提前触发刷新操作。
优缺点
优点 压力分散通过提前触发批处理操作可以将刷新压力分散到多个时间点降低系统负载。数据保持最新确保缓存中的数据保持最新避免过时数据的访问。 缺点 阈值设置需要根据实际情况合理设置阈值避免过于频繁或过于稀疏的刷新。
示例代码
假设有一个需要定期刷新的服务我们可以使用 Caffeine 缓存的批处理数据超过阈值大小策略来优化。
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;Service
public class BatchRefreshService {private final CacheString, String cache Caffeine.newBuilder().maximumSize(100) // Set the maximum cache size.build();CacheEvict(cacheNames batchRefreshCache, allEntries true, cacheManager caffeineCacheManager)public void refreshCache() {// Your batch refresh logic here}
}在这个示例中我们使用了 CacheEvict 注解来触发缓存的刷新操作。通过设置 maximumSize我们限制了缓存的最大大小如果批处理数据量超过阈值将触发 refreshCache 方法来执行批处理操作。
总之批处理数据超过阈值大小策略适用于需要定期刷新的场景通过提前触发批处理操作来分散刷新压力确保缓存中的数据保持最新。
4. 从 write-behind 缓存加载数据
从 write-behind 缓存加载数据是 Caffeine 缓存提供的一种计算策略它允许在外部资源操作还没有刷新时从 write-behind 缓存中加载数据以提供最新数据。这个策略可以确保缓存中的数据实时性即使外部资源操作尚未完成。以下是对从 write-behind 缓存加载数据策略的详细解释
作用 从 write-behind 缓存加载数据策略的主要作用是在外部资源操作尚未刷新时从 write-behind 缓存中加载数据以确保缓存数据的实时性。
使用场景 从 write-behind 缓存加载数据适用于以下场景
外部资源操作当缓存需要加载来自外部资源的数据时而外部资源操作还未完成时。数据实时性当要求缓存中的数据实时性即使数据尚未持久化到外部资源。
优缺点
优点 数据实时性确保缓存中的数据实时更新无论外部资源操作是否完成。最新数据提供最新的数据给请求方增强数据访问的准确性。 缺点 内存开销write-behind 缓存需要维护额外的内存空间存储尚未持久化的数据。
示例代码
假设有一个需要从外部资源加载数据的服务我们可以使用 Caffeine 缓存的从 write-behind 缓存加载数据策略来确保数据实时性。
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class WriteBehindLoadService {private final CacheString, String cache Caffeine.newBuilder().writer((key, value) - {// Write-behind cache logic// This method is called when the cache entry is created or updated}).build();Cacheable(cacheNames writeBehindCache, key #key, cacheManager caffeineCacheManager)public String getValue(String key) {// Your logic to load data from external resourcereturn LoadedValue;}
}在这个示例中我们使用了 Caffeine.newBuilder().writer(...) 来配置 write-behind 缓存逻辑。当缓存的条目被创建或更新时writer 方法会被调用你可以在其中实现将缓存数据写入外部资源的逻辑。通过使用 Cacheable 注解来触发缓存加载操作即使外部资源操作尚未完成也可以从 write-behind 缓存中获取数据。
综上所述从 write-behind 缓存加载数据策略适用于需要缓存中数据实时性的场景通过确保数据的最新性增强了数据访问的准确性和可靠性。
5. 根据外部资源特性控制重试、速率和并发度
根据外部资源特性控制重试、速率和并发度是 Caffeine 缓存提供的一种计算策略它允许你根据外部资源的特性来控制缓存操作的重试次数、访问速率和并发度以避免对外部资源造成过度压力。这个策略可以帮助你优化缓存的使用确保与外部资源的交互更加稳定和可控。以下是对根据外部资源特性控制重试、速率和并发度策略的详细解释
作用 根据外部资源特性控制重试、速率和并发度策略的主要作用是根据外部资源的特性来优化缓存操作确保与外部资源的交互更加稳定和可控。
使用场景 根据外部资源特性控制重试、速率和并发度适用于以下场景
远程资源调用当缓存需要从远程资源中加载数据时需要考虑远程资源的可靠性和稳定性。避免过度请求当缓存操作可能对外部资源造成过度压力时需要限制重试、速率和并发度。
优缺点
优点 外部资源保护通过限制重试、速率和并发度可以保护外部资源免受过度请求的影响。稳定性增强通过优化缓存与外部资源的交互可以增强系统的稳定性。 缺点 复杂性增加需要根据外部资源的特性进行合理的设置增加了配置和调优的工作。
示例代码
假设有一个需要与远程资源交互的服务为了避免对远程资源的过度请求我们可以使用 Caffeine 缓存的根据外部资源特性控制重试、速率和并发度策略来进行限制。
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class ExternalResourceService {private final CacheString, String cache Caffeine.newBuilder().maximumSize(100).build();Cacheable(cacheNames externalResourceCache, key #key, cacheManager caffeineCacheManager)public String getExternalData(String key) {// Your logic to interact with the external resourcereturn ExternalData for key;}
}在这个示例中我们使用了 Cacheable 注解来触发缓存加载操作。通过设置 maximumSize我们限制了缓存的最大大小同时也可以在 Caffeine.newBuilder() 中进行其他配置如最大并发度、重试次数等。
综上所述根据外部资源特性控制重试、速率和并发度策略适用于需要与外部资源交互的场景通过合理设置缓存操作的限制保护外部资源免受过度请求的影响提高系统的稳定性和可靠性。
✍2. 分层
分层是 Caffeine 缓存提供的一种计算策略允许你在缓存中实现多层级的数据存储结构通常包括两个缓存层例如 L1 缓存和 L2 缓存。这种策略旨在通过将数据存储在不同层级的缓存中以提高数据访问效率和灵活性。以下是对分层策略的详细解释
作用 分层策略的主要作用是在缓存中实现多层级的数据存储结构以提高数据访问效率和灵活性。
使用场景 分层适用于以下场景
数据访问优化将热门或常用数据存储在 L1 缓存中将不常用数据存储在 L2 缓存中以提高数据的访问效率。容量控制通过限制 L1 缓存的容量将部分数据迁移到 L2 缓存中以避免 L1 缓存溢出。
优缺点
优点 数据访问优化将常用数据存储在 L1 缓存中可以提高数据的访问速度和响应性能。容量管理通过分层可以更好地控制缓存的容量避免溢出问题。 缺点 复杂性增加分层策略需要额外的配置和管理增加了系统的复杂性。数据一致性需要考虑数据在不同层级之间的一致性维护。
示例代码
假设有一个需要数据分层存储的服务我们可以使用 Caffeine 缓存的分层策略来实现。
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.stereotype.Service;import java.util.Arrays;Service
public class LayeredCacheService {private final CacheString, String l1Cache Caffeine.newBuilder().maximumSize(100).build();private final CacheString, String l2Cache Caffeine.newBuilder().maximumSize(1000).build();public LayeredCacheService() {SimpleCacheManager cacheManager new SimpleCacheManager();cacheManager.setCaches(Arrays.asList(new CaffeineCache(l1Cache, l1Cache), new CaffeineCache(l2Cache, l2Cache)));}public String getValue(String key) {String value l1Cache.getIfPresent(key);if (value null) {value l2Cache.getIfPresent(key);if (value ! null) {l1Cache.put(key, value);}}return value;}
}在这个示例中我们使用两个不同的 Caffeine 缓存实例分别代表 L1 缓存和 L2 缓存。在 getValue 方法中我们首先尝试从 L1 缓存中获取数据如果不存在则从 L2 缓存中获取数据并将数据加载到 L1 缓存中。通过这种方式我们实现了分层的数据存储结构。
综上所述分层策略适用于需要优化数据访问和管理缓存容量的场景通过将数据存储在不同层级的缓存中可以提高数据的访问效率和灵活性。
✍3. 同步监听器
同步监听器是 Caffeine 缓存提供的一种计算策略它允许你在缓存数据发生更改时触发一些操作例如更新其他关联数据或触发异步处理。这个策略可以帮助你实现数据变更时的后续处理逻辑保证数据的一致性和可靠性。以下是对同步监听器策略的详细解释
作用 同步监听器策略的主要作用是在缓存数据发生更改时触发一些操作以实现数据变更时的后续处理逻辑。
使用场景 同步监听器适用于以下场景
数据更新通知当缓存中的数据发生更改时需要及时更新其他关联的数据。异步处理在数据发生更改时触发异步任务进行后续处理如日志记录、通知等。
优缺点
优点 数据一致性通过同步监听器可以实现缓存数据和其他数据的一致性维护。后续处理允许你在数据变更时触发后续处理逻辑增加了数据的可靠性。 缺点 阻塞问题同步监听器可能导致缓存操作的阻塞影响性能和响应时间。复杂性增加需要在监听器中实现合适的处理逻辑增加了代码的复杂性。
示例代码
假设有一个需要在数据变更时触发后续处理的服务我们可以使用 Caffeine 缓存的同步监听器策略来实现。
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.stereotype.Service;import java.util.concurrent.TimeUnit;Service
public class SyncListenerService {private final CacheString, String cache Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).removalListener((key, value, cause) - {if (cause.wasEvicted()) {// Cache entry was evicted due to expiration or size limit// Perform additional actions here}}).build();public String getValue(String key) {// Your logic to load data from cache or external resourcereturn cache.get(key, this::loadData);}private String loadData(String key) {// Your logic to load data from external resourcereturn LoadedValue;}
}在这个示例中我们使用了 Caffeine.newBuilder().removalListener(...) 来配置同步监听器。当缓存条目被移除时监听器的逻辑会被触发你可以在其中实现相应的后续处理如记录日志或触发异步任务。
综上所述同步监听器策略适用于需要在缓存数据变更时触发后续处理逻辑的场景通过监听缓存操作可以实现数据的一致性和可靠性维护。
✌6. Interner:
提供了一个对象池用于复用等效的对象以节省内存。类似于String.intern()但更加灵活。 Caffeine 提供的 Interner 是一个用于管理共享对象引用的工具它可以用于限制在一个 JVM 中对象的数量以便在应用程序中重用相同的实例从而节省内存。在 Spring Boot 中你可以使用 Caffeine 的 Interner 来优化对象引用的共享和管理。以下是使用 Caffeine 的 Interner 的作用、使用场景、优缺点以及适用于 Spring Boot 项目的实际示例代码
✍作用
Interner 的作用是维护一组共享的对象引用以便重用相同的实例从而节省内存并提高性能。它适用于需要频繁创建和使用对象的场景通过限制对象实例的数量避免了创建过多的重复对象。
✍使用场景
适用于以下场景
频繁创建对象当应用程序中频繁创建对象时可以使用 Interner 来共享相同的实例减少内存占用。对象重用当对象实例被频繁使用时可以使用 Interner 来重用这些实例提高性能。
✍优缺点
优点
内存节省通过共享对象实例可以降低内存占用。性能提升避免频繁创建对象减少了垃圾回收和对象初始化的开销。
缺点
不适用于所有场景并不是所有的对象都适合通过 Interner 进行管理一些对象可能需要独立实例化。
✍示例代码
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Interner;
import org.springframework.stereotype.Service;Service
public class ObjectInternerService {private final InternerString stringInterner Caffeine.newBuilder().buildInterner();public String internString(String value) {return stringInterner.intern(value);}
}在这个示例中我们创建了一个 Interner 来共享字符串对象的实例。internString 方法使用 stringInterner 来共享相同值的字符串实例从而节省内存。这在处理大量相同值字符串时特别有用。
综上所述Caffeine 提供的 Interner 可以在 Spring Boot 项目中用于优化对象引用的共享和管理。通过使用 Interner你可以在需要频繁创建和使用对象的场景中减少内存占用和性能开销。
✌7. 统计:
可以记录缓存的命中率、加载时间等统计信息。使用recordStats()方法启用统计。 Caffeine 提供的统计功能可以帮助你监控和分析缓存的使用情况从而优化缓存配置和性能。在 Spring Boot 中你可以使用 Caffeine 的统计功能来收集缓存的统计信息并根据这些信息进行调优。以下是使用 Caffeine 的统计功能的作用、使用场景、优缺点以及适用于 Spring Boot 项目的实际示例代码
✍作用
Caffeine 的统计功能可以用于监控和分析缓存的使用情况包括缓存的命中率、加载次数、剔除次数等。这些统计信息可以帮助你了解缓存的性能表现和数据访问模式从而做出相应的调整和优化。
✍使用场景
适用于以下场景
缓存性能优化通过监控缓存的命中率和加载次数可以判断缓存是否有效从而进行性能优化。调优决策根据统计信息可以调整缓存的配置参数如缓存大小、过期时间等以获得更好的性能。
✍优缺点
优点
性能优化通过统计信息可以针对性地进行性能优化。决策支持统计信息可以帮助你做出更合理的缓存调优决策。
缺点
额外开销收集统计信息可能会带来一定的额外开销。
✍示例代码
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.stereotype.Service;Service
public class CacheStatisticsService {private final CacheString, String cache Caffeine.newBuilder().maximumSize(100).recordStats() // Enable statistics collection.build();public void addToCache(String key, String value) {cache.put(key, value);}public String getFromCache(String key) {return cache.getIfPresent(key);}public CacheStats getCacheStatistics() {return cache.stats();}
}在这个示例中我们使用了 recordStats() 方法来启用统计功能。addToCache 和 getFromCache 方法用于操作缓存getCacheStatistics 方法用于获取缓存的统计信息。
你可以在 Spring Boot 项目中使用 CacheStatisticsService 来监控缓存的性能和使用情况并根据统计信息进行性能优化和配置调整。
综上所述Caffeine 提供的统计功能可以在 Spring Boot 项目中用于监控和优化缓存的性能。通过收集和分析统计信息你可以更好地了解缓存的表现从而做出合适的性能优化和决策。
✌8. 规范:
定义缓存的配置如大小、过期时间等。在Spring Boot中使用spring.cache.caffeine.spec来设置规范字符串。
✍作用 CaffeineSpec 的作用是提供一种使用简单的字符格式配置来定义 Caffeine 缓存的各种参数从而在* 不直接编写代码的情况下配置缓存行为。 CaffeineSpec为Caffeine提供了一个简单的字符格式配置。这里的字符串语法是一系列由逗号隔开的键值对组成其中每个键值对对应一个配置方法。但是这里的字符配置不支持需要对象来作为参数的配置方法比如 removalListener这样的配置必须要在代码中进行配置。 以下是各个配置键值对字符串所对应的配置方法。将maximumSize和maximumWeight或者将weakValues和weakValues 在一起使用是不被允许的。
配置键配置方法描述initialCapacity[integer]Caffeine.initialCapacity设置初始容量maximumSize[long]Caffeine.maximumSize设置最大缓存条目数量maximumWeight[long]Caffeine.maximumWeight设置最大缓存权重expireAfterAccess[持续时间]Caffeine.expireAfterAccess(Duration)设置访问后过期时间expireAfterWrite[持续时间]Caffeine.expireAfterWrite(Duration)设置写入后过期时间refreshAfterWrite[持续时间]Caffeine.refreshAfterWrite(Duration)设置写入后刷新时间weakKeysCaffeine.weakKeys启用弱引用键weakValuesCaffeine.weakValues启用弱引用值softValuesCaffeine.softValues启用软引用值recordStatsCaffeine.recordStats启用统计信息收集
✍使用场景
适用于以下场景
简化配置当需要配置多个 Caffeine 缓存的时候使用字符串格式的配置可以更简洁地定义缓存的参数。配置可视化对于不熟悉代码编写的人员使用字符串配置可以更直观地理解和配置缓存。
✍优缺点
优点
简化配置通过字符串格式的配置可以简化缓存的配置过程。可视化配置更直观不需要直接编写代码。
缺点
有限制某些复杂配置需要在代码中进行而不支持在字符串中配置。
✍示例代码
首先在 Spring Boot 项目的配置文件中添加 Caffeine 缓存的配置例如 application.properties
spring.cache.cache-namesmyCache
spring.cache.caffeine.specmaximumSize100,expireAfterWrite30m,recordStats然后在你的服务类中使用配置的缓存
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class CacheService {Cacheable(cacheNames myCache, cacheManager caffeineCacheManager)public String getCachedValue(String key) {// Simulate fetching value from a data sourcereturn CachedValue for key;}
}在这个示例中我们使用了 spring.cache.caffeine.spec 配置来定义缓存的参数包括最大大小、写入后过期时间和启用统计功能。然后在 CacheService 类中我们使用 Cacheable 注解来应用该缓存配置。
请注意根据你提供的信息CaffeineSpec 并不支持在字符串配置中直接配置复杂参数比如 removalListener。这类配置仍然需要在代码中进行。
综上所述CaffeineSpec 可以在 Spring Boot 项目中用于简化和可视化 Caffeine 缓存的配置过程。通过配置字符串你可以更方便地定义缓存的参数同时仍然可以通过代码来配置一些复杂的参数。
✍持续时间示例代码
当使用 Caffeine 的配置字符串来表示持续时间时你可以选择使用不同的格式包括普通格式和 ISO-8601 标准的格式。下面是不同格式下的示例用于表示不同的持续时间
普通格式ISO-8601 格式描述50sPT50S50秒11mPT11M11分钟6hPT6H6小时3dP3D3天P3DT3H4M3天3小时4分钟--7小时-3分钟不支持
这些格式可以用于设置不同的缓存时间参数如过期时间、刷新时间等具体取决于你在 spring.cache.caffeine.spec 配置中使用的键值对。在 Spring Boot 项目中你可以将这些格式中的任何一个用于设置缓存的时间参数。
示例代码中的配置示范了如何在 Spring Boot 项目中使用不同的持续时间格式来配置 Caffeine 缓存参数。根据你的实际需求你可以选择最适合的持续时间表示方式以达到优化缓存性能的目标。
下面是示例代码展示如何使用不同的持续时间表示方法来配置 Caffeine 缓存的参数以及如何在 Spring Boot 项目中应用这些配置
# 使用不同的持续时间表示方式配置 Caffeine 缓存
spring.cache.caffeine.specexpireAfterAccess50s,refreshAfterWritePT11M然后在服务类中使用配置的缓存
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class CacheService {Cacheable(cacheNames myCache, cacheManager caffeineCacheManager)public String getCachedValue(String key) {// Simulate fetching value from a data sourcereturn CachedValue for key;}
}在这个示例中我们使用了 expireAfterAccess 和 refreshAfterWrite 配置来演示如何使用不同的持续时间表示方法。你可以根据需要在 spring.cache.caffeine.spec 属性中配置其他的缓存参数。
综上所述通过不同的持续时间表示方法你可以在 Spring Boot 项目中更灵活地配置 Caffeine 缓存的参数以满足不同的业务需求和性能要求。
✌9. 清理:
清理操作由Caffeine自动处理确保缓存不会过度消耗资源。使用cleanUp()方法可以手动触发清理。 Caffeine 提供了 Cache.cleanUp() 方法用于手动触发缓存的清理操作。虽然 Caffeine 内部会根据配置的清理策略自动进行清理但在某些场景下你可能需要手动调用清理操作来立即释放一些缓存资源。以下是 Cache.cleanUp() 方法的作用、使用场景、优缺点以及适用于 Spring Boot 项目的实际示例代码
✍作用
Cache.cleanUp() 方法的作用是手动触发缓存的清理操作以立即释放一些缓存资源。这可以帮助你在某些特定情况下控制缓存的内存占用以及确保过期或无用的缓存条目得到及时清理。
✍使用场景
适用于以下场景
手动控制清理在特定操作后你可能希望立即清理缓存以释放内存。紧急情况当你需要确保过期的缓存数据被及时清理时可以手动调用清理操作。
✍优缺点
优点
灵活性允许你在需要的时候手动触发缓存的清理从而更灵活地控制缓存资源。
缺点
过度使用频繁调用清理操作可能会导致性能下降应该在合适的时机使用。
✍示例代码
下面是一个使用 Spring Boot 中的 Caffeine 缓存以及手动触发清理操作的示例代码
首先在 Spring Boot 项目的配置文件中配置 Caffeine 缓存
# application.properties
spring.cache.cache-namesmyCache
spring.cache.caffeine.specmaximumSize100,expireAfterWrite30m然后在你的服务类中使用缓存和手动触发清理操作
import com.github.benmanes.caffeine.cache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class CacheService {Autowiredprivate CacheObject, Object myCache;Cacheable(cacheNames myCache, cacheManager caffeineCacheManager)public String getCachedValue(String key) {// Simulate fetching value from a data sourcereturn CachedValue for key;}public void manualCacheCleanup() {myCache.cleanUp(); // 手动触发缓存清理}
}在这个示例中我们在 CacheService 中使用 Cacheable 注解来定义缓存策略。然后我们通过 myCache.cleanUp() 方法来手动触发缓存的清理操作。
综上所述Cache.cleanUp() 方法可以在 Spring Boot 项目中使用帮助你在特定场景下手动触发缓存的清理以确保缓存资源得到适时释放。
✌10. 策略:
内部API允许插件来修改缓存的行为。一般用于高级用途。
下面我将为你详细解释每个基于容量和基于时间的策略包括它们的作用、使用场景、优缺点和适用于 Spring Boot 项目的实际示例代码
✍基于容量的策略
cache.policy().eviction().ifPresent(eviction - {...});
作用 通过该策略你可以调整缓存的最大条目数量以控制缓存中的数据数量。
使用场景 适用于需要动态地调整缓存的容量以适应数据量的变化。
优缺点
优点允许你根据数据量的变化进行灵活的缓存容量调整。缺点可能导致频繁的调整影响性能。
示例代码
import com.github.benmanes.caffeine.cache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;Service
public class CacheService {Autowiredprivate CacheObject, Object myCache;public void adjustCacheCapacity() {myCache.policy().eviction().ifPresent(eviction - {eviction.setMaximum(2 * eviction.getMaximum()); // 将最大条目数量翻倍});}
}✍基于时间的策略
cache.policy().expireAfterAccess().ifPresent(expiration - {...}); cache.policy().expireAfterWrite().ifPresent(expiration - {...}); cache.policy().expireVariably().ifPresent(expiration - {...}); cache.policy().refreshAfterWrite().ifPresent(refresh - {...});
作用 这些基于时间的策略允许你设置不同的失效时间以控制缓存数据何时过期或刷新。
使用场景 适用于需要根据数据的实际使用情况来设置失效时间的场景。
优缺点
优点可以根据数据的使用频率或写入时间进行动态的失效时间设置。缺点需要根据业务需求进行合理的设置否则可能导致缓存数据不准确。
示例代码
import com.github.benmanes.caffeine.cache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;Service
public class CacheService {Autowiredprivate CacheObject, Object myCache;public void adjustExpirationPolicy() {myCache.policy().expireAfterAccess().ifPresent(expiration - {expiration.setExpiresAfterAccess(30, TimeUnit.MINUTES); // 设置访问后的过期时间为30分钟});myCache.policy().expireAfterWrite().ifPresent(expiration - {expiration.setExpiresAfterWrite(1, TimeUnit.HOURS); // 设置写入后的过期时间为1小时});// 其他策略类似...}
}在这个示例中我们使用不同的基于时间的策略来调整缓存的失效时间。
综上所述Caffeine 提供了基于容量和基于时间的策略可以根据不同的业务需求来管理缓存的容量和失效行为。在 Spring Boot 项目中你可以根据不同的场景选择合适的策略以优化缓存的性能和资源利用。
✌11. 测试:
Caffeine提供了测试工具来模拟和验证缓存的行为。可以使用Ticker来模拟时间。
Caffeine 提供了在测试中使用的一些策略例如在测试基于时间的驱逐策略时不需要等待真实时间的推进以及自定义执行周期维护和异步生成操作。以下是解释这些策略的作用、使用场景、优缺点以及适用于 Spring Boot 项目的实际示例代码
✍1. 自定义时间源和驱逐策略的测试
作用
在测试中当涉及基于时间的缓存驱逐策略时不需要等待实际时间的推进。你可以使用 Caffeine 的 Ticker 接口和 Caffeine.ticker(Ticker) 方法来定义自定义的时间源而不必等待系统时钟。
使用场景
适用于测试基于时间的缓存策略以模拟时间的推进而不依赖于实际的系统时钟。
优缺点
优点
可以在测试中更精确地模拟时间的推进加速测试的执行。减少了测试的等待时间提高了测试效率。
缺点
需要编写额外的代码来配置和使用自定义的时间源。
示例代码
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Ticker;
import org.springframework.cache.Cache;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.stereotype.Service;Service
public class CacheService {private final CacheObject, Object caffeineCache;public CacheService() {Ticker ticker Ticker.systemTicker(); // 使用系统时间CaffeineObject, Object caffeineBuilder Caffeine.newBuilder().ticker(ticker).expireAfterWrite(1, TimeUnit.HOURS); // 设置缓存写入后的过期时间为1小时caffeineCache new CaffeineCache(myCache, caffeineBuilder.build());}public String getCachedValue(String key) {// Simulate fetching value from a data sourcereturn (String) caffeineCache.get(key, k - CachedValue for k);}
}在这个示例中我们使用了 Ticker.systemTicker() 来设置自定义的时间源以模拟时间的推进。
✍2. 自定义执行器的测试
作用
Caffeine 通过 Executor 来执行周期维护、移除通知和异步生成操作。你可以通过配置一个自定义的执行器来更好地控制这些操作。
使用场景
适用于在测试中模拟和控制异步操作的执行以提高测试的可靠性。
优缺点
优点
可以在测试中更好地模拟异步操作的执行。提高了测试的可靠性减少了异步操作的不确定性。
缺点
需要额外的配置和代码来使用自定义的执行器。
示例代码
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;Configuration
EnableCaching
public class CacheConfig {Beanpublic CacheManager caffeineCacheManager() {CaffeineCacheManager cacheManager new CaffeineCacheManager();cacheManager.setCaffeine(Caffeine.newBuilder().executor(Executors.newSingleThreadExecutor()) // 设置自定义的执行器.expireAfterWrite(1, TimeUnit.HOURS)); // 设置缓存写入后的过期时间为1小时return cacheManager;}
}在这个示例中我们使用 Executors.newSingleThreadExecutor() 来设置一个单线程的自定义执行器以控制异步操作的执行。
综上所述Caffeine 提供了在测试中使用的策略可以帮助你更好地模拟和控制缓存的行为以确保测试的准确性和可靠性。在 Spring Boot 项目中你可以使用这些策略来优化测试验证缓存的效果。
✌12. Faq:
Caffeine 提供了一些常见问题的解决方案涉及固定缓存元素、递归生成和写竞争等问题。以下是解释这些解决方案的作用、使用场景、优缺点以及适用于 Spring Boot 项目的实际示例代码
✍1. 固定缓存元素
作用
固定缓存元素是一种特殊的策略可以让缓存的值保持不变无论缓存策略是否过期。适用于需要在一段时间内保持特定值的情况不受过期时间影响。
使用场景
适用于需要在缓存中存储静态数据或配置信息并保持这些数据不变的场景。
优缺点
优点
保持特定值不变适用于存储静态数据。可以避免频繁的缓存刷新提高性能。
缺点
不适合动态数据可能导致数据不准确。
示例代码
import com.github.benmanes.caffeine.cache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;Service
public class CacheService {Autowiredprivate CacheObject, Object myCache;Cacheable(cacheNames myCache, key #key)public String getStaticValue(String key) {// Simulate fetching static value from a data sourcereturn StaticValue;}
}在这个示例中我们使用 Cacheable 注解将静态值缓存起来无论缓存是否过期都会返回相同的静态值。
✍2. 递归生成
作用
递归生成是指在获取缓存值时如果值不存在则通过计算生成新的值并将其存储在缓存中。这样可以避免多个线程同时计算相同的值。
使用场景
适用于计算开销较大的值以及需要避免多线程计算冲突的场景。
优缺点
优点
避免多个线程同时计算相同的值提高性能。适用于计算开销较大的值。
缺点
可能会导致第一个线程计算的值被其他线程使用如果这个值是可变的可能会引起问题。
示例代码
import com.github.benmanes.caffeine.cache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;Service
public class CacheService {Autowiredprivate CacheObject, Object myCache;public String computeValue(String key) {return myCache.get(key, k - computeExpensiveValue(k));}private String computeExpensiveValue(Object key) {// Simulate expensive computationreturn ComputedValue for key;}
}在这个示例中我们使用 myCache.get(key, k - computeExpensiveValue(k)) 来实现递归生成新的值。
✍3. 写竞争
作用
写竞争是指多个线程同时写入相同的缓存条目可能导致数据不一致。Caffeine 提供了一些解决方案来处理写竞争问题。
使用场景
适用于多个线程同时写入相同缓存条目的场景需要确保数据一致性。
优缺点
优点
解决了多个线程同时写入缓存的数据不一致问题。提高了数据的一致性和可靠性。
缺点
可能会增加一些额外的开销例如同步或锁。
示例代码
import com.github.benmanes.caffeine.cache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;Service
public class CacheService {Autowiredprivate CacheObject, Object myCache;public void writeToCache(String key, String value) {synchronized (myCache) {myCache.put(key, value);}}
}在这个示例中我们
使用同步块来确保多个线程同时写入缓存时不会产生竞争问题。
综上所述Caffeine 提供了在 Spring Boot 项目中解决固定缓存元素、递归生成和写竞争等问题的解决方案。这些方案可以帮助你更好地管理和优化缓存的使用。
