@Component
public class MultiLevelCacheClient {
    // L1本地緩存（Caffeine）
    private final LoadingCache<String, Object> localCache;
    // L2分布式緩存（Redis）
    @Autowired
    private StringRedisTemplate redisTemplate;
    // 數(shù)據(jù)庫(kù)訪問層
    @Autowired
    private DataDao dataDao;

    // 初始化本地緩存
    public MultiLevelCacheClient() {
        this.localCache = Caffeine.newBuilder()
                .maximumSize(10_000)  // 限制最大條目數(shù)，防止內(nèi)存溢出
                .expireAfterWrite(5, TimeUnit.MINUTES)  // 寫入后5分鐘過期
                .build(this::loadFromRedis);  // L1未命中時(shí)從L2加載
    }

    // 對(duì)外查詢接口
    public Object query(String key) {
        try {
            return localCache.get(key);  // 優(yōu)先查L(zhǎng)1
        } catch (Exception e) {
            // 緩存查詢異常時(shí)直接查數(shù)據(jù)庫(kù)兜底
            log.error("多級(jí)緩存查詢失敗，key:{}", key, e);
            return dataDao.query(key);
        }
    }

    // 從L2加載數(shù)據(jù)（供Caffeine回調(diào)）
    private Object loadFromRedis(String key) {
        // 查L(zhǎng)2
        String valueStr = redisTemplate.opsForValue().get(key);
        if (valueStr != null) {
            return JSON.parseObject(valueStr, Object.class);
        }
        // L2未命中則查數(shù)據(jù)庫(kù)，并回寫L2
        Object value = dataDao.query(key);
        if (value != null) {
            redisTemplate.opsForValue().set(key, JSON.toJSONString(value), 30, TimeUnit.MINUTES);
        }
        return value;
    }
}

/**
 * 數(shù)據(jù)更新事件：當(dāng)數(shù)據(jù)庫(kù)數(shù)據(jù)發(fā)生新增/修改/刪除時(shí)發(fā)布
 */
public class DataUpdateEvent extends ApplicationEvent {
    // 數(shù)據(jù)唯一標(biāo)識(shí)（如商品ID、用戶ID）
    private final String key;
    // 操作類型（新增/更新/刪除）
    private final OperationType operationType;

    public DataUpdateEvent(Object source, String key, OperationType operationType) {
        super(source);
        this.key = key;
        this.operationType = operationType;
    }

    // getter方法
    public String getKey() { return key; }
    public OperationType getOperationType() { return operationType; }

    // 操作類型枚舉
    public enum OperationType {
        CREATE, UPDATE, DELETE
    }
}

@Service
public class ProductService {
    @Autowired
    private ProductDao productDao;
    // Spring事件發(fā)布器
    @Autowired
    private ApplicationEventPublisher eventPublisher;

    /**
     * 更新商品信息（包含事件發(fā)布邏輯）
     */
    @Transactional
    public void updateProduct(Product product) {
        // 1. 執(zhí)行數(shù)據(jù)庫(kù)更新
        productDao.update(product);
        
        // 2. 數(shù)據(jù)庫(kù)操作成功后，發(fā)布數(shù)據(jù)更新事件
        String key = "product:" + product.getId(); // 緩存鍵（與查詢時(shí)保持一致）
        eventPublisher.publishEvent(
            new DataUpdateEvent(this, key, DataUpdateEvent.OperationType.UPDATE)
        );
    }

    /**
     * 刪除商品（包含事件發(fā)布邏輯）
     */
    @Transactional
    public void deleteProduct(Long productId) {
        // 1. 執(zhí)行數(shù)據(jù)庫(kù)刪除
        productDao.delete(productId);
        
        // 2. 發(fā)布刪除事件
        String key = "product:" + productId;
        eventPublisher.publishEvent(
            new DataUpdateEvent(this, key, DataUpdateEvent.OperationType.DELETE)
        );
    }
}

@Component
public class CacheConsistencyManager {
    @Autowired
    private LoadingCache<String, Object> localCache;
    @Autowired
    private StringRedisTemplate redisTemplate;
    // 線程池用于異步操作
    private final ExecutorService cacheExecutor = Executors.newFixedThreadPool(5);

    // 處理數(shù)據(jù)更新事件
    @EventListener
    public void onDataUpdated(DataUpdateEvent event) {
        String key = event.getKey();
        // 1. 立即刪除本地緩存（同步操作，確保當(dāng)前實(shí)例無舊數(shù)據(jù)）
        localCache.invalidate(key);

        // 2. 異步刪除分布式緩存（避免阻塞主流程）
        cacheExecutor.submit(() -> {
            try {
                redisTemplate.delete(key);
                // 發(fā)送緩存刪除事件，通知其他實(shí)例清理L1（集群場(chǎng)景）
                redisTemplate.convertAndSend("cache:invalid:channel", key);
            } catch (Exception e) {
                log.error("異步刪除Redis緩存失敗，key:{}", key, e);
                // 失敗不影響主流程，依賴過期時(shí)間兜底
            }
        });
    }

    // 監(jiān)聽其他實(shí)例的緩存刪除通知
    @Bean
    public RedisMessageListenerContainer redisListener() {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisTemplate.getConnectionFactory());
        container.addMessageListener((message, pattern) -> {
            String key = new String(message.getBody());
            localCache.invalidate(key);  // 清理當(dāng)前實(shí)例的L1緩存
        }, new PatternTopic("cache:invalid:channel"));
        return container;
    }
}

@Configuration
@EnableAsync // 開啟異步支持
public class AsyncConfig {
    @Bean
    public Executor eventExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("event-publisher-");
        executor.initialize();
        return executor;
    }
}

// 在發(fā)布者中指定異步執(zhí)行
@Service
public class ProductService {
    @Async("eventExecutor") // 使用自定義線程池異步發(fā)布
    public void publishUpdateEvent(String key) {
        eventPublisher.publishEvent(
            new DataUpdateEvent(this, key, DataUpdateEvent.OperationType.UPDATE)
        );
    }
}