高级java每日一道面试题-2025年5月28日-基础篇[JCache（JSR-107）]-在 JCache 中，如何配置和使用基于容量的驱逐策略？

JCache中基于容量的驱逐策略配置与使用详解

一、JCache驱逐策略概述

JCache（JSR-107）是Java的标准缓存API，它提供了统一的缓存操作接口。容量驱逐策略是缓存管理的核心功能之一，用于在缓存达到容量上限时自动移除条目。

二、配置基于容量的驱逐策略

2.1 基本配置方式

import javax.cache.Cache;
import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.configuration.*;
import javax.cache.spi.CachingProvider;

public class CacheEvictionConfig {

public void configureCache() {
// 1. 获取缓存提供者
CachingProvider cachingProvider = Caching.getCachingProvider();

// 2. 创建缓存管理器
CacheManager cacheManager = cachingProvider.getCacheManager();

// 3. 配置缓存（基于容量的驱逐策略）
MutableConfiguration<String, String> config =
new MutableConfiguration<String, String>()
.setTypes(String.class, String.class)
// 启用统计
.setStatisticsEnabled(true)
// 配置容量和驱逐策略
.setExpiryPolicyFactory(
CreatedExpiryPolicy.factoryOf(Duration.ONE_HOUR)
);

// 4. 创建缓存
Cache<String, String> cache =
cacheManager.createCache("myCache", config);
}
}

2.2 使用Ehcache实现容量配置

import org.ehcache.config.CacheConfiguration;
import org.ehcache.config.builders.*;
import org.ehcache.jsr107.Eh107Configuration;

public class EhcacheCapacityConfig {

public void configureWithEhcache() {
CachingProvider cachingProvider = Caching.getCachingProvider();
CacheManager cacheManager = cachingProvider.getCacheManager();

// 使用Ehcache特定的配置
CacheConfiguration<String, String> ehcacheConfig =
CacheConfigurationBuilder.newCacheConfigurationBuilder(
String.class, // Key类型
String.class, // Value类型
ResourcePoolsBuilder.newResourcePoolsBuilder()
// 堆内存储：最多1000个条目
.heap(1000, EntryUnit.ENTRIES)
// 堆外存储：10MB
.offheap(10, MemoryUnit.MB)
// 磁盘存储：1GB
.disk(1, MemoryUnit.GB, true) // true表示持久化
)
// 配置驱逐策略（LRU）
.withEvictionAdvisor((key, value) -> {
// 自定义驱逐建议逻辑
return key.toString().startsWith("temp");
})
.build();

// 转换为JCache配置
javax.cache.configuration.Configuration<String, String> config =
Eh107Configuration.fromEhcacheCacheConfiguration(ehcacheConfig);

Cache<String, String> cache =
cacheManager.createCache("ehcacheExample", config);
}
}

2.3 使用Hazelcast实现容量配置

import com.hazelcast.cache.ICache;
import com.hazelcast.config.*;

public class HazelcastCapacityConfig {

public void configureWithHazelcast() {
// 创建Hazelcast配置
Config hazelcastConfig = new Config();

// 配置缓存策略
EvictionConfig evictionConfig = new EvictionConfig()
.setEvictionPolicy(EvictionPolicy.LRU) // 驱逐策略：LRU
.setSize(1000) // 最大条目数
.setMaxSizePolicy(MaxSizePolicy.ENTRY_COUNT);

CacheSimpleConfig cacheConfig = new CacheSimpleConfig()
.setName("hazelcastCache")
.setKeyType(String.class.getName())
.setValueType(String.class.getName())
.setStatisticsEnabled(true)
.setManagementEnabled(true)
.setEvictionConfig(evictionConfig) // 设置驱逐配置
.setInMemoryFormat(InMemoryFormat.BINARY);

hazelcastConfig.addCacheConfig(cacheConfig);

// 创建缓存管理器
CachingProvider cachingProvider = Caching.getCachingProvider();
CacheManager cacheManager = cachingProvider.getCacheManager(
null, null,
HazelcastCachingProvider.propertiesByInstanceName("hazelcastInstance")
);

Cache<String, String> cache =
cacheManager.createCache("hazelcastCache",
new MutableConfiguration<String, String>()
.setTypes(String.class, String.class));
}
}

三、详细的配置示例

3.1 完整的配置示例

import javax.cache.configuration.*;
import javax.cache.expiry.*;
import java.util.concurrent.TimeUnit;

public class CompleteCacheConfiguration {

public void createCompleteCache() {
CachingProvider provider = Caching.getCachingProvider();
CacheManager cacheManager = provider.getCacheManager();

// 创建完整的缓存配置
CompleteConfiguration<String, User> config =
new MutableConfiguration<String, User>()
.setTypes(String.class, User.class)
.setExpiryPolicyFactory(
// 创建后30分钟过期
CreatedExpiryPolicy.factoryOf(
new Duration(TimeUnit.MINUTES, 30))
)
.setStoreByValue(false) // 按引用存储
.setStatisticsEnabled(true)
.setManagementEnabled(true)
// 添加缓存监听器
.addCacheEntryListenerConfiguration(
new CacheEntryListenerConfiguration<>(
() -> new CacheEntryListener<String, User>() {
@Override
public void onCreated(Iterable<CacheEntryEvent<? extends String,
? extends User>> events) {
// 处理创建事件
}
// 实现其他监听方法…
},
null, // 过滤器工厂
true, // 是否同步
false // 是否在注册后接收旧事件
)
);

// 对于容量配置，需要使用实现特定的API
configureCapacityProgrammatically();
}

private void configureCapacityProgrammatically() {
// 实际容量配置依赖于具体的缓存实现
// 这里以Ehcache为例
ResourcePools pools = ResourcePoolsBuilder.newResourcePoolsBuilder()
.heap(1000, EntryUnit.ENTRIES) // 堆内：1000个条目
.offheap(100, MemoryUnit.MB) // 堆外：100MB
.disk(1, MemoryUnit.GB, true) // 磁盘：1GB，持久化
.build();

// 创建驱逐策略
EvictionAdvisor<String, String> evictionAdvisor = (key, value) -> {
// 自定义驱逐建议
// 返回true表示建议驱逐，false表示不建议驱逐
return key.startsWith("temp_") ||
value.length() > 10000; // 大对象优先驱逐
};
}
}

3.2 使用XML配置文件

ehcache.xml:

<config xmlns='http://www.ehcache.org/v3'>
<cache alias="userCache">
<key-type>java.lang.String</key-type>
<value-type>com.example.User</value-type>
<resources>
<!– 堆内最多1000个条目 –>
<heap unit="entries">1000</heap>
<!– 堆外最多100MB –>
<offheap unit="MB">100</offheap>
<!– 磁盘最多1GB –>
<disk unit="GB" persistent="true">1</disk>
</resources>
<expiry>
<!– 30分钟后过期 –>
<tti unit="minutes">30</tti>
</expiry>
<eviction-advisor
class="com.example.CustomEvictionAdvisor"/>
</cache>
</config>

使用XML配置创建缓存:

public class XmlConfigurationExample {

public void createCacheFromXml() {
// 创建配置管理器
ConfigurationXmlManager configManager =
new ConfigurationXmlManager();

// 从XML加载配置
CacheConfiguration<String, User> cacheConfig =
configManager.parseConfiguration(
getClass().getResourceAsStream("/ehcache.xml"))
.getCacheConfigurations()
.get("userCache");

// 使用配置创建缓存
CachingProvider provider = Caching.getCachingProvider();
CacheManager manager = provider.getCacheManager();

javax.cache.configuration.Configuration<String, User> config =
Eh107Configuration.fromEhcacheCacheConfiguration(cacheConfig);

Cache<String, User> cache = manager.createCache("userCache", config);
}
}

四、高级驱逐策略配置

4.1 自定义驱逐策略

public class AdvancedEvictionExample {

public static class SizeBasedEvictionAdvisor<K, V>
implements EvictionAdvisor<K, V> {

private final long maxSizeBytes;

public SizeBasedEvictionAdvisor(long maxSizeBytes) {
this.maxSizeBytes = maxSizeBytes;
}

@Override
public boolean adviseAgainstEviction(K key, V value) {
// 估计对象大小（简单实现）
long estimatedSize = estimateSize(value);

// 如果对象很小，尽量保留
if (estimatedSize < 1024) { // 小于1KB
return true; // 不建议驱逐
}

// 如果对象很大，建议驱逐
return estimatedSize <= maxSizeBytes;
}

private long estimateSize(Object obj) {
// 简化的大小估算逻辑
if (obj == null) return 0;
if (obj instanceof String) {
return ((String) obj).length() * 2L;
}
// 其他类型的估算逻辑…
return 100; // 默认值
}
}

public void configureWithCustomAdvisor() {
ResourcePools pools = ResourcePoolsBuilder.newResourcePoolsBuilder()
.heap(500, EntryUnit.ENTRIES)
.build();

CacheConfiguration<String, String> config =
CacheConfigurationBuilder.newCacheConfigurationBuilder(
String.class, String.class, pools)
.withEvictionAdvisor(new SizeBasedEvictionAdvisor<>(10 * 1024)) // 10KB
.build();
}
}

4.2 多层存储的容量配置

public class MultiTierCacheConfiguration {

public void configureMultiTierCache() {
// 配置多层缓存
ResourcePools pools = ResourcePoolsBuilder.newResourcePoolsBuilder()
// L1: 堆内缓存 – 热数据，1000个条目
.heap(1000, EntryUnit.ENTRIES)
// L2: 堆外缓存 – 温数据，100MB
.offheap(100, MemoryUnit.MB)
// L3: 磁盘缓存 – 冷数据，1GB
.disk(1, MemoryUnit.GB, true)
.build();

// 配置分层存储的缓存
CacheConfiguration<String, byte[]> config =
CacheConfigurationBuilder.newCacheConfigurationBuilder(
String.class, byte[].class, pools)
// 配置数据在不同层之间的移动策略
.withResourcePools(pools)
// 添加服务配置（如分层存储服务）
.add(ResourcePoolsBuilder.newResourcePoolsBuilder()
.heap(100, EntryUnit.ENTRIES)
.build())
.build();
}
}

五、监控和调优

5.1 监控缓存统计信息

public class CacheMonitoring {

public void monitorCachePerformance(Cache<String, String> cache) {
// 获取缓存统计信息
CacheStatistics statistics =
cache.unwrap(Cache.class).getCacheStatistics();

System.out.println("命中率: " +
statistics.getCacheHitPercentage());
System.out.println("驱逐数量: " +
statistics.getCacheEvictions());
System.out.println("平均获取时间: " +
statistics.getAverageGetTime());

// 定期检查并调整配置
if (statistics.getCacheEvictions() > 1000) {
// 缓存驱逐过多，可能需要增加容量
adjustCacheCapacity(cache);
}
}

private void adjustCacheCapacity(Cache<String, String> cache) {
// 动态调整缓存容量的逻辑
// 注意：JCache标准API不支持动态调整，需要具体实现支持
}
}

5.2 性能优化建议

public class CacheOptimization {

public void optimizeCacheConfiguration() {
// 1. 根据应用特性选择合适的驱逐策略
Map<String, String> strategyChoices = new HashMap<>();
strategyChoices.put("LRU", "最近最少使用 – 适合时间局部性好的场景");
strategyChoices.put("LFU", "最不经常使用 – 适合访问频率差异大的场景");
strategyChoices.put("FIFO", "先进先出 – 简单但效果一般");

// 2. 容量规划建议
Runtime runtime = Runtime.getRuntime();
long maxMemory = runtime.maxMemory();
long recommendedHeapSize = maxMemory / 4; // 推荐使用1/4堆内存

// 3. 监控和调整
// – 监控命中率，保持在85%以上
// – 监控驱逐率，避免频繁驱逐
// – 根据业务峰值调整容量
}
}

六、最佳实践总结

七、常见问题解决方案

通过以上配置和使用方法，可以有效地在JCache中实现基于容量的驱逐策略管理，提高缓存系统的性能和可靠性。