--- highlight: a11y-dark theme: juejin --- 在高并发环境下，直接查询 Elasticsearch 常成为性能瓶颈。本文分享如何使用 Java 构建高效多层次缓存，显著提升 ES 查询性能。 ## 为什么需要多层次缓存？单纯依赖 ES 内置缓存在高负载环境下存在明显不足： * 缓存空间有限，热点数据易被淘汰 * 集群扩缩容时缓存失效 * 重建索引会清空缓存 * 无法针对业务场景做精细优化通过在应用层构建多级缓存，可以大幅减轻 ES 集群压力。 ## 多层次缓存架构设计 ![多级缓存架构设计.png](https://p3-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/83530d0ca6c445e0b6d0847cae91919b~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5byC5bi45ZCb:q75.awebp?rk3s=f64ab15b&x-expires=1751955536&x-signature=eKKPPkncaRPjFguUtl2sb34vdE8%3D) 这种架构提供全面防护： 1. **速率限制器**：防止过载 2. **本地缓存**：响应最快，但容量有限 3. **分布式缓存**：容量大，跨实例共享 4. **布隆过滤器**：拦截无效查询 5. **熔断器**：保护 ES 集群 6. **Elasticsearch**：最终数据源 ## 实现代码 ### 1. 定义缓存接口 ```java public interface ESCache { V get(K key); void put(K key, V value); void invalidate(K key); void clear(); Map getStats(); //用于处理敏感数据 default void putWithSensitiveDataProtection(K key, V value) { put(key, value); } } ``` ### 2. 本地缓存实现 (Caffeine) ```java import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.Cache; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.Objects; public class LocalESCache implements ESCache { private static final Logger logger = LoggerFactory.getLogger(LocalESCache.class); private final Cache cache; private final int maximumSize; private final int baseExpireSeconds; public LocalESCache(int maximumSize, int expireAfterWriteSeconds) { Objects.requireNonNull(maximumSize, "最大容量不能为null"); if (maximumSize <= 0) { throw new IllegalArgumentException("最大容量必须为正数"); } Objects.requireNonNull(expireAfterWriteSeconds, "过期时间不能为null"); if (expireAfterWriteSeconds <= 0) { throw new IllegalArgumentException("过期时间必须为正数"); } this.maximumSize = maximumSize; this.baseExpireSeconds = expireAfterWriteSeconds; logger.info("初始化本地缓存，最大容量: {}, 基础过期时间: {}秒", maximumSize, expireAfterWriteSeconds); // 计算抖动值，避免缓存雪崩 int jitter = (int)(Math.random() * expireAfterWriteSeconds * 0.1); int finalExpiry = expireAfterWriteSeconds + jitter; this.cache = Caffeine.newBuilder() .maximumSize(maximumSize) .expireAfterWrite(finalExpiry, TimeUnit.SECONDS) .recordStats() .build(); } @Override public V get(K key) { try { V value = cache.getIfPresent(key); if (value != null) { logger.debug("本地缓存命中: {}", key); } else { logger.debug("本地缓存未命中: {}", key); } return value; } catch (Exception e) { logger.error("从本地缓存获取数据异常: {}", e.getMessage(), e); return null; } } @Override public void put(K key, V value) { try { if (value != null) { // 检查内存压力 if (isMemoryPressureHigh()) { logger.warn("系统内存压力高，跳过缓存存储: {}", key); return; } cache.put(key, value); logger.debug("数据已放入本地缓存: {}", key); } else { logger.warn("尝试放入空值到本地缓存，已忽略: {}", key); } } catch (Exception e) { logger.error("放入本地缓存异常: {}", e.getMessage(), e); } } @Override public void invalidate(K key) { try { cache.invalidate(key); logger.debug("已从本地缓存移除: {}", key); } catch (Exception e) { logger.error("从本地缓存移除数据异常: {}", e.getMessage(), e); } } @Override public void clear() { try { cache.invalidateAll(); logger.info("本地缓存已清空"); } catch (Exception e) { logger.error("清空本地缓存异常: {}", e.getMessage(), e); } } @Override public Map getStats() { Map stats = new HashMap<>(); stats.put("hitCount", cache.stats().hitCount()); stats.put("missCount", cache.stats().missCount()); stats.put("hitRate", cache.stats().hitRate()); stats.put("evictionCount", cache.stats().evictionCount()); stats.put("estimatedSize", cache.estimatedSize()); // 添加内存使用情况 Runtime runtime = Runtime.getRuntime(); double memoryUsage = (double) (runtime.totalMemory() - runtime.freeMemory()) / runtime.maxMemory(); stats.put("systemMemoryUsage", Math.round(memoryUsage * 100) + "%"); return stats; } /** * 检查系统内存压力 * @return 如果内存压力高返回true */ private boolean isMemoryPressureHigh() { Runtime runtime = Runtime.getRuntime(); double memoryUsage = (double) (runtime.totalMemory() - runtime.freeMemory()) / runtime.maxMemory(); return memoryUsage > 0.85; // 内存使用率超过85%视为高压力 } /** * 根据内存压力主动清理部分缓存 */ public void trimToSize() { Runtime runtime = Runtime.getRuntime(); double memoryUsage = (double) (runtime.totalMemory() - runtime.freeMemory()) / runtime.maxMemory(); if (memoryUsage > 0.8) { logger.warn("系统内存使用率高 ({}%)，主动清理部分本地缓存", Math.round(memoryUsage * 100)); // Caffeine没有直接提供部分清理的API，模拟实现 int targetSize = (int)(cache.estimatedSize() * 0.7); // 保留70% // 执行清理 if (cache.estimatedSize() > targetSize) { logger.info("尝试从{}项减少到{}项", cache.estimatedSize(), targetSize); cache.cleanUp(); // 触发过期清理 } } } /** * 基于内存压力的自适应缓存清理策略 * 根据不同的内存压力级别采取不同的清理策略 */ public void adaptiveTrimToSize() { long currentSize = cache.estimatedSize(); Runtime runtime = Runtime.getRuntime(); double memoryUsage = (double) (runtime.totalMemory() - runtime.freeMemory()) / runtime.maxMemory(); // 根据内存压力动态调整缓存大小 if (memoryUsage > 0.9) { // 极高内存压力：保留10%的项并减少过期时间 logger.warn("极高内存压力 ({}%)，执行紧急缓存清理", Math.round(memoryUsage * 100)); cache.invalidateAll(); // 紧急情况直接清空 // 重建缓存配置，缩短过期时间 int newExpiry = baseExpireSeconds / 4; logger.info("临时缩短缓存过期时间至{}秒", newExpiry); } else if (memoryUsage > 0.8) { // 高内存压力：保留25%的项 int targetSize = (int)(currentSize * 0.25); logger.warn("高内存压力 ({}%)，激进清理缓存从{}项到{}项", Math.round(memoryUsage * 100), currentSize, targetSize); // 执行部分清理 cache.cleanUp(); // 触发过期清理 // 若清理后仍超过目标，尝试主动驱逐部分缓存 if (cache.estimatedSize() > targetSize) { // 这里只能通过间接方式，因为Caffeine不提供直接裁剪的API logger.info("清理后缓存大小仍为{}，需要更多清理", cache.estimatedSize()); } } else if (memoryUsage > 0.7) { // 中等内存压力：保留50%的项 int targetSize = (int)(currentSize * 0.5); logger.info("中等内存压力 ({}%)，适度清理缓存从{}项到{}项", Math.round(memoryUsage * 100), currentSize, targetSize); // 执行轻度清理 cache.cleanUp(); // 触发过期清理 } } } ``` ### 3. Redis 分布式缓存实现 ```java import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.core.script.DefaultRedisScript; import org.springframework.data.redis.serializer.RedisSerializer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; import java.util.Objects; public class RedisESCache implements ESCache { private static final Logger logger = LoggerFactory.getLogger(RedisESCache.class); private final RedisTemplate redisTemplate; private final int expireTimeSeconds; private final String cachePrefix; private final AtomicLong hitCount = new AtomicLong(0); private final AtomicLong missCount = new AtomicLong(0); private final DataProtectionService dataProtectionService; public RedisESCache(RedisTemplate redisTemplate, int expireTimeSeconds, String cachePrefix) { this(redisTemplate, expireTimeSeconds, cachePrefix, null, null); } public RedisESCache(RedisTemplate redisTemplate, int expireTimeSeconds, String cachePrefix, RedisSerializer valueSerializer, DataProtectionService dataProtectionService) { Objects.requireNonNull(redisTemplate, "Redis模板不能为null"); Objects.requireNonNull(cachePrefix, "缓存前缀不能为null"); if (expireTimeSeconds <= 0) { throw new IllegalArgumentException("过期时间必须为正数"); } this.redisTemplate = redisTemplate; this.expireTimeSeconds = expireTimeSeconds; this.cachePrefix = cachePrefix; this.dataProtectionService = dataProtectionService; // 如果提供了自定义序列化器，应用它 if (valueSerializer != null) { redisTemplate.setValueSerializer(valueSerializer); } logger.info("初始化Redis缓存，前缀: {}, 基础过期时间: {}秒, 序列化器: {}", cachePrefix, expireTimeSeconds, redisTemplate.getValueSerializer().getClass().getSimpleName()); } @SuppressWarnings("unchecked") private K getCacheKey(K key) { return (K) (cachePrefix + ":" + key); } @Override public V get(K key) { try { K cacheKey = getCacheKey(key); V value = redisTemplate.opsForValue().get(cacheKey); if (value != null) { hitCount.incrementAndGet(); logger.debug("Redis缓存命中: {}", cacheKey); } else { missCount.incrementAndGet(); logger.debug("Redis缓存未命中: {}", cacheKey); } return value; } catch (Exception e) { logger.error("从Redis缓存获取数据异常: {}", e.getMessage(), e); return null; } } @Override public void put(K key, V value) { try { if (value != null) { K cacheKey = getCacheKey(key); // 添加随机过期时间，避免缓存雪崩 int jitter = (int)(Math.random() * expireTimeSeconds * 0.1); int finalExpiry = expireTimeSeconds + jitter; redisTemplate.opsForValue().set(cacheKey, value, finalExpiry, TimeUnit.SECONDS); logger.debug("数据已放入Redis缓存: {}, 过期时间: {}秒", cacheKey, finalExpiry); } else { logger.warn("尝试放入空值到Redis缓存，已忽略: {}", key); } } catch (Exception e) { logger.error("放入Redis缓存异常: {}", e.getMessage(), e); } } @Override public void putWithSensitiveDataProtection(K key, V value) { try { if (value == null) { logger.warn("尝试放入空值到Redis缓存，已忽略: {}", key); return; } // 如果配置了数据保护服务，则进行数据保护处理 if (dataProtectionService != null && dataProtectionService.containsSensitiveData(value)) { V protectedValue = (V) dataProtectionService.protectData(value); logger.info("已对敏感数据进行保护处理: {}", key); put(key, protectedValue); } else { put(key, value); } } catch (Exception e) { logger.error("放入Redis缓存敏感数据异常: {}", e.getMessage(), e); } } @Override public void invalidate(K key) { try { K cacheKey = getCacheKey(key); redisTemplate.delete(cacheKey); logger.debug("已从Redis缓存移除: {}", cacheKey); } catch (Exception e) { logger.error("从Redis缓存移除数据异常: {}", e.getMessage(), e); } } @Override public void clear() { try { // 使用scan命令清除指定前缀的缓存，避免keys命令阻塞Redis String script = "local keys = redis.call('scan', 0, 'MATCH', ARGV[1], 'COUNT', 1000);" + "if keys[2] then redis.call('del', unpack(keys[2])) end;" + "return keys[1];"; DefaultRedisScript redisScript = new DefaultRedisScript<>(script, String.class); String pattern = cachePrefix + ":*"; redisTemplate.execute(redisScript, Collections.emptyList(), (V) pattern); logger.info("已清空Redis缓存, 前缀: {}", cachePrefix); } catch (Exception e) { logger.error("清空Redis缓存异常: {}", e.getMessage(), e); } } @Override public Map getStats() { Map stats = new HashMap<>(); stats.put("hitCount", hitCount.get()); stats.put("missCount", missCount.get()); double hitRatio = hitCount.get() + missCount.get() > 0 ? (double) hitCount.get() / (hitCount.get() + missCount.get()) : 0; stats.put("hitRate", hitRatio); stats.put("keyCount", getKeyCount()); return stats; } private long getKeyCount() { try { String pattern = cachePrefix + ":*"; return redisTemplate.keys((K) pattern).size(); } catch (Exception e) { logger.error("获取Redis键数量异常: {}", e.getMessage(), e); return -1; } } // 分布式锁实现，用于防止缓存击穿 public boolean acquireLock(K key, int lockTimeSeconds) { try { K lockKey = (K) (cachePrefix + ":lock:" + key); Boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, (V) "1", lockTimeSeconds, TimeUnit.SECONDS); return Boolean.TRUE.equals(success); } catch (Exception e) { logger.error("获取分布式锁异常: {}", e.getMessage(), e); return false; } } public void releaseLock(K key) { try { K lockKey = (K) (cachePrefix + ":lock:" + key); redisTemplate.delete(lockKey); } catch (Exception e) { logger.error("释放分布式锁异常: {}", e.getMessage(), e); } } } ``` ### 4. 数据保护服务实现 ```java import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.Arrays; import java.util.HashSet; import java.util.Set; import java.util.regex.Pattern; /** * 数据保护服务，用于识别和保护敏感数据 */ public class DataProtectionService { private static final Logger logger = LoggerFactory.getLogger(DataProtectionService.class); // 敏感字段名称 private final Set sensitiveFieldNames = new HashSet<>(Arrays.asList( "password", "creditCard", "ssn", "idCard", "phoneNumber", "email", "address" )); // 正则表达式匹配器 private final Pattern creditCardPattern = Pattern.compile("\\d{4}-\\d{4}-\\d{4}-\\d{4}"); private final Pattern emailPattern = Pattern.compile("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}"); private final Pattern phonePattern = Pattern.compile("\\d{3}-\\d{3}-\\d{4}"); /** * 检测对象是否包含敏感数据 */ public boolean containsSensitiveData(Object data) { if (data == null) { return false; } try { // 如果是Map，检查键名 if (data instanceof Map) { Map map = (Map) data; for (Object key : map.keySet()) { if (key instanceof String && sensitiveFieldNames.contains(((String) key).toLowerCase())) { return true; } // 递归检查值 Object value = map.get(key); if (containsSensitiveData(value)) { return true; } } } // 如果是字符串，使用正则表达式检查 else if (data instanceof String) { String str = (String) data; return creditCardPattern.matcher(str).find() || emailPattern.matcher(str).find() || phonePattern.matcher(str).find(); } // 如果是普通JavaBean，通过反射检查字段 else if (isJavaBean(data)) { return containsSensitiveFieldsInBean(data); } return false; } catch (Exception e) { logger.error("检测敏感数据异常: {}", e.getMessage(), e); return false; } } /** * 保护敏感数据（脱敏、加密等） */ public Object protectData(Object data) { if (data == null) { return null; } try { // 根据数据类型选择不同的保护方式 if (data instanceof Map) { return protectMapData((Map) data); } else if (data instanceof String) { return protectStringData((String) data); } else if (isJavaBean(data)) { return protectBeanData(data); } return data; // 默认不变 } catch (Exception e) { logger.error("保护敏感数据异常: {}", e.getMessage(), e); return data; } } /** * 保护Map中的敏感数据 */ @SuppressWarnings("unchecked") private Object protectMapData(Map map) { Map result = new HashMap<>(); for (Map.Entry entry : map.entrySet()) { Object key = entry.getKey(); Object value = entry.getValue(); // 检查键名是否敏感 if (key instanceof String && sensitiveFieldNames.contains(((String) key).toLowerCase())) { // 对敏感字段进行脱敏 result.put(key, maskSensitiveValue(value)); } else { // 递归处理值 result.put(key, protectData(value)); } } return result; } /** * 保护字符串中的敏感数据 */ private String protectStringData(String str) { // 信用卡号脱敏 str = creditCardPattern.matcher(str).replaceAll(matcher -> { String card = matcher.group(); return card.substring(0, 9) + "****" + card.substring(card.length() - 4); }); // 邮箱脱敏 str = emailPattern.matcher(str).replaceAll(matcher -> { String email = matcher.group(); int atIndex = email.indexOf('@'); if (atIndex > 1) { return email.charAt(0) + "***" + email.substring(atIndex); } return email; }); // 电话号码脱敏 str = phonePattern.matcher(str).replaceAll(matcher -> { String phone = matcher.group(); return phone.substring(0, 4) + "***" + phone.substring(phone.length() - 4); }); return str; } /** * 对JavaBean进行敏感数据保护 */ private Object protectBeanData(Object bean) { try { // 创建一个新的同类型对象 Object newBean = bean.getClass().getDeclaredConstructor().newInstance(); // 通过反射获取所有字段 Field[] fields = bean.getClass().getDeclaredFields(); for (Field field : fields) { field.setAccessible(true); // 检查字段名是否敏感 if (sensitiveFieldNames.contains(field.getName().toLowerCase())) { // 对敏感字段进行脱敏 Object value = field.get(bean); field.set(newBean, maskSensitiveValue(value)); } else { // 非敏感字段直接复制，但递归检查对象类型字段 Object value = field.get(bean); field.set(newBean, protectData(value)); } } return newBean; } catch (Exception e) { logger.error("保护Bean数据异常: {}", e.getMessage(), e); return bean; } } /** * 脱敏敏感值 */ private Object maskSensitiveValue(Object value) { if (value == null) { return null; } if (value instanceof String) { String str = (String) value; if (str.length() <= 2) { return "***"; } else if (str.length() <= 6) { return str.charAt(0) + "***" + str.charAt(str.length() - 1); } else { return str.substring(0, 3) + "****" + str.substring(str.length() - 3); } } // 其他类型不处理 return value; } /** * 判断对象是否为普通JavaBean */ private boolean isJavaBean(Object obj) { if (obj == null) { return false; } Class clazz = obj.getClass(); return !clazz.isArray() && !clazz.isPrimitive() && !clazz.isEnum() && !clazz.isInterface() && !clazz.getName().startsWith("java.") && !clazz.getName().startsWith("javax.") && !clazz.getName().startsWith("sun."); } /** * 检查JavaBean中是否包含敏感字段 */ private boolean containsSensitiveFieldsInBean(Object bean) { try { // 通过反射获取所有字段 Field[] fields = bean.getClass().getDeclaredFields(); for (Field field : fields) { field.setAccessible(true); // 检查字段名是否敏感 if (sensitiveFieldNames.contains(field.getName().toLowerCase())) { return true; } // 递归检查对象类型字段 Object value = field.get(bean); if (value != null && !field.getType().isPrimitive() && !field.getType().getName().startsWith("java.lang")) { if (containsSensitiveData(value)) { return true; } } } return false; } catch (Exception e) { logger.error("检查Bean敏感字段异常: {}", e.getMessage(), e); return false; } } } ``` ### 5. 限流和熔断实现 ```java import io.github.resilience4j.circuitbreaker.CircuitBreaker; import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig; import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry; import io.github.resilience4j.ratelimiter.RateLimiter; import io.github.resilience4j.ratelimiter.RateLimiterConfig; import io.github.resilience4j.ratelimiter.RateLimiterRegistry; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.time.Duration; import java.util.function.Supplier; /** * 弹性服务：提供限流和熔断功能 */ public class ResilienceService { private static final Logger logger = LoggerFactory.getLogger(ResilienceService.class); private final RateLimiter rateLimiter; private final CircuitBreaker circuitBreaker; public ResilienceService(String name, int permitsPerSecond, int failureThreshold) { // 创建限流器配置 RateLimiterConfig rateLimiterConfig = RateLimiterConfig.custom() .limitRefreshPeriod(Duration.ofSeconds(1)) .limitForPeriod(permitsPerSecond) .timeoutDuration(Duration.ofMillis(100)) .build(); RateLimiterRegistry rateLimiterRegistry = RateLimiterRegistry.of(rateLimiterConfig); this.rateLimiter = rateLimiterRegistry.rateLimiter(name + "-rate-limiter"); // 创建熔断器配置 CircuitBreakerConfig circuitBreakerConfig = CircuitBreakerConfig.custom() .failureRateThreshold(failureThreshold) .waitDurationInOpenState(Duration.ofSeconds(30)) .permittedNumberOfCallsInHalfOpenState(5) .slidingWindowSize(10) .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED) .build(); CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.of(circuitBreakerConfig); this.circuitBreaker = circuitBreakerRegistry.circuitBreaker(name + "-circuit-breaker"); logger.info("弹性服务初始化完成，限流: {}次/秒, 熔断阈值: {}%", permitsPerSecond, failureThreshold); } /** * 执行带限流和熔断保护的操作 * @param supplier 要执行的操作 * @param fallback 降级函数 * @return 操作结果或降级结果 */ public T execute(Supplier supplier, Supplier fallback) { // 先进行限流检查 if (!rateLimiter.acquirePermission()) { logger.warn("触发限流保护"); return fallback.get(); } // 然后进行熔断检查 try { return circuitBreaker.executeSupplier(supplier); } catch (Exception e) { logger.error("操作执行异常: {}", e.getMessage(), e); return fallback.get(); } } /** * 获取熔断器状态 */ public String getCircuitBreakerState() { return circuitBreaker.getState().name(); } /** * 获取限流器指标 */ public Map getRateLimiterMetrics() { Map metrics = new HashMap<>(); metrics.put("availablePermissions", rateLimiter.getMetrics().getAvailablePermissions()); metrics.put("numberOfWaitingThreads", rateLimiter.getMetrics().getNumberOfWaitingThreads()); return metrics; } /** * 获取熔断器指标 */ public Map getCircuitBreakerMetrics() { Map metrics = new HashMap<>(); metrics.put("failureRate", circuitBreaker.getMetrics().getFailureRate()); metrics.put("numberOfSuccessfulCalls", circuitBreaker.getMetrics().getNumberOfSuccessfulCalls()); metrics.put("numberOfFailedCalls", circuitBreaker.getMetrics().getNumberOfFailedCalls()); metrics.put("state", circuitBreaker.getState()); return metrics; } } ``` ### 6. 多层缓存管理器 ```java import co.elastic.clients.elasticsearch.ElasticsearchClient; import co.elastic.clients.elasticsearch.core.SearchRequest; import co.elastic.clients.elasticsearch.core.SearchResponse; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import io.micrometer.core.instrument.Counter; import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.core.instrument.Timer; import java.io.IOException; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.function.Function; public class MultiLevelESCache { private static final Logger logger = LoggerFactory.getLogger(MultiLevelESCache.class); private final ESCache localCache; private final ESCache distributedCache; private final ElasticsearchClient esClient; private final ESBloomFilter bloomFilter; private final MeterRegistry meterRegistry; private final ResilienceService resilienceService; // 监控指标 private final Counter localHits; private final Counter redisHits; private final Counter misses; private final Counter errors; private final Counter cacheRejections; private final Counter rateLimiterRejections; private final Counter circuitBreakerRejections; private final Timer localCacheAccessTimer; private final Timer redisCacheAccessTimer; private final Timer esQueryTimer; private final Timer totalQueryTimer; public MultiLevelESCache(ESCache localCache, ESCache distributedCache, ElasticsearchClient esClient, ESBloomFilter bloomFilter, MeterRegistry meterRegistry, ResilienceService resilienceService) { // 参数验证 Objects.requireNonNull(localCache, "本地缓存不能为null"); Objects.requireNonNull(distributedCache, "分布式缓存不能为null"); Objects.requireNonNull(esClient, "ES客户端不能为null"); Objects.requireNonNull(meterRegistry, "监控注册器不能为null"); this.localCache = localCache; this.distributedCache = distributedCache; this.esClient = esClient; this.bloomFilter = bloomFilter; this.meterRegistry = meterRegistry; this.resilienceService = resilienceService; // 初始化监控指标 this.localHits = Counter.builder("es.cache.hits") .tag("level", "local") .description("本地缓存命中次数") .register(meterRegistry); this.redisHits = Counter.builder("es.cache.hits") .tag("level", "redis") .description("Redis缓存命中次数") .register(meterRegistry); this.misses = Counter.builder("es.cache.misses") .description("缓存未命中次数") .register(meterRegistry); this.errors = Counter.builder("es.cache.errors") .description("缓存操作错误次数") .register(meterRegistry); this.cacheRejections = Counter.builder("es.cache.rejections") .description("由于内存压力拒绝缓存的次数") .register(meterRegistry); this.rateLimiterRejections = Counter.builder("es.resilience.rejections") .tag("type", "rate_limiter") .description("限流器拒绝次数") .register(meterRegistry); this.circuitBreakerRejections = Counter.builder("es.resilience.rejections") .tag("type", "circuit_breaker") .description("熔断器拒绝次数") .register(meterRegistry); this.localCacheAccessTimer = Timer.builder("es.cache.access.time") .tag("level", "local") .description("本地缓存访问耗时") .register(meterRegistry); this.redisCacheAccessTimer = Timer.builder("es.cache.access.time") .tag("level", "redis") .description("Redis缓存访问耗时") .register(meterRegistry); this.esQueryTimer = Timer.builder("es.cache.access.time") .tag("level", "elasticsearch") .description("ES查询耗时") .register(meterRegistry); this.totalQueryTimer = Timer.builder("es.cache.query.time") .description("总查询耗时") .register(meterRegistry); logger.info("多层缓存初始化完成"); } /** * 从缓存或ES获取数据，带限流和熔断保护 */ public V get(K key, SearchRequest searchRequest, Function, V> responseMapper) { // 使用弹性服务执行缓存查询 if (resilienceService != null) { return resilienceService.execute( () -> getFromCacheOrES(key, searchRequest, responseMapper), () -> { // 降级处理 logger.warn("触发弹性保护，返回降级结果"); if ("OPEN".equals(resilienceService.getCircuitBreakerState())) { circuitBreakerRejections.increment(); } else { rateLimiterRejections.increment(); } return null; // 或其他降级值 } ); } else { // 不使用弹性服务直接执行 return getFromCacheOrES(key, searchRequest, responseMapper); } } /** * 从缓存或ES获取数据的核心逻辑 */ private V getFromCacheOrES(K key, SearchRequest searchRequest, Function, V> responseMapper) { return totalQueryTimer.record(() -> { try { // 检查布隆过滤器，防止缓存穿透 if (bloomFilter != null) { String bloomKey = key.toString(); if (!bloomFilter.mightContain(bloomKey)) { logger.debug("布隆过滤器拦截: {}", key); return null; } } // 1. 尝试从本地缓存获取 V result = localCacheAccessTimer.record(() -> localCache.get(key)); if (result != null) { localHits.increment(); return result; } // 2. 尝试从分布式缓存获取 result = redisCacheAccessTimer.record(() -> distributedCache.get(key)); if (result != null) { // 回填本地缓存 localCache.put(key, result); redisHits.increment(); return result; } // 防止缓存击穿，使用分布式锁 boolean locked = false; try { if (distributedCache instanceof RedisESCache) { RedisESCache redisCache = (RedisESCache) distributedCache; locked = redisCache.acquireLock(key, 10); // 10秒锁超时 if (!locked) { // 如果获取锁失败，等待100ms后重试一次Redis缓存 try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } result = distributedCache.get(key); if (result != null) { localCache.put(key, result); redisHits.increment(); return result; } logger.warn("获取分布式锁失败，可能存在并发重建缓存: {}", key); } } // 3. 从ES获取 misses.increment(); logger.debug("从ES获取数据: {}", key); // 执行ES查询 SearchResponse