// 緩存抽象的關(guān)鍵注解示例
@Service
public class ProductService {
    
    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // 方法調(diào)用將被緩存，相同參數(shù)的重復(fù)調(diào)用直接返回緩存結(jié)果
        return productRepository.findById(id).orElse(null);
    }
    
    @CacheEvict(value = "products", key = "#product.id")
    public void updateProduct(Product product) {
        // 更新產(chǎn)品信息并清除對(duì)應(yīng)的緩存條目
        productRepository.save(product);
    }
    
    @CachePut(value = "products", key = "#result.id")
    public Product createProduct(Product product) {
        // 創(chuàng)建產(chǎn)品并更新緩存，同時(shí)返回結(jié)果
        return productRepository.save(product);
    }
    
    @CacheEvict(value = "products", allEntries = true)
    public void clearProductCache() {
        // 清除products緩存中的所有條目
        System.out.println("產(chǎn)品緩存已清空");
    }
}

// Spring Cache核心接口關(guān)系
public interface Cache {
    // 緩存的名稱(chēng)，用于標(biāo)識(shí)不同的緩存
    String getName();
    
    // 底層的原生緩存，可轉(zhuǎn)換為特定實(shí)現(xiàn)
    Object getNativeCache();
    
    // 根據(jù)鍵獲取緩存值
    ValueWrapper get(Object key);
    
    // 將值存入緩存
    void put(Object key, Object value);
    
    // 從緩存中移除指定鍵的條目
    void evict(Object key);
    
    // 清除緩存中的所有條目
    void clear();
}

// CacheManager定義
public interface CacheManager {
    // 獲取指定名稱(chēng)的緩存
    Cache getCache(String name);
    
    // 獲取所有緩存名稱(chēng)的集合
    Collection<String> getCacheNames();
}

// 不同CacheManager的配置示例
@Configuration
@EnableCaching
public class CacheConfig {
    
    // 簡(jiǎn)單內(nèi)存緩存配置
    @Bean
    public CacheManager concurrentMapCacheManager() {
        ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
        cacheManager.setCacheNames(Arrays.asList("products", "customers"));
        return cacheManager;
    }
    
    // Redis緩存配置
    @Bean
    public CacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10))  // 設(shè)置緩存過(guò)期時(shí)間
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()));
                
        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .withCacheConfiguration("products", RedisCacheConfiguration
                        .defaultCacheConfig().entryTtl(Duration.ofMinutes(5)))
                .build();
    }
    
    // Caffeine緩存配置
    @Bean
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        
        // 為不同緩存設(shè)置不同的配置
        cacheManager.setCacheSpecification("products=maximumSize=500,expireAfterWrite=5m");
        cacheManager.setCacheSpecification("customers=maximumSize=1000,expireAfterWrite=10m");
        
        return cacheManager;
    }
}

// 復(fù)合緩存管理器配置
@Bean
public CacheManager compositeCacheManager(
        CaffeineCacheManager caffeineCacheManager,
        RedisCacheManager redisCacheManager) {
    
    // 創(chuàng)建復(fù)合緩存管理器
    CompositeCacheManager compositeCacheManager = new CompositeCacheManager(
            caffeineCacheManager,
            redisCacheManager
    );
    
    // 設(shè)置回退機(jī)制，當(dāng)指定緩存不存在時(shí)創(chuàng)建默認(rèn)緩存
    compositeCacheManager.setFallbackToNoOpCache(true);
    
    return compositeCacheManager;
}

// 緩存使用策略示例
@Service
public class TieredCacheService {
    
    // 使用本地緩存，適合高頻訪(fǎng)問(wèn)數(shù)據(jù)
    @Cacheable(value = "localProducts", cacheManager = "caffeineCacheManager")
    public Product getProductForFrontend(Long id) {
        return productRepository.findById(id).orElse(null);
    }
    
    // 使用分布式緩存，適合集群共享數(shù)據(jù)
    @Cacheable(value = "sharedProducts", cacheManager = "redisCacheManager")
    public Product getProductForApi(Long id) {
        return productRepository.findById(id).orElse(null);
    }
    
    // 兩級(jí)緩存同步更新
    @Caching(evict = {
        @CacheEvict(value = "localProducts", key = "#product.id", cacheManager = "caffeineCacheManager"),
        @CacheEvict(value = "sharedProducts", key = "#product.id", cacheManager = "redisCacheManager")
    })
    public void updateProduct(Product product) {
        productRepository.save(product);
    }
}

// 默認(rèn)鍵生成器實(shí)現(xiàn)邏輯示意
public class SimpleKeyGenerator implements KeyGenerator {
    
    @Override
    public Object generate(Object target, Method method, Object... params) {
        if (params.length == 0) {
            return SimpleKey.EMPTY;
        }
        if (params.length == 1) {
            Object param = params[0];
            if (param != null && !param.getClass().isArray()) {
                return param;
            }
        }
        return new SimpleKey(params);
    }
}

// 默認(rèn)鍵生成使用示例
@Cacheable("products") // 使用默認(rèn)鍵生成器
public Product getProduct(Long id, String region) {
    // 緩存鍵將是SimpleKey(id, region)
    return productRepository.findByIdAndRegion(id, region);
}

// 自定義鍵生成器實(shí)現(xiàn)
@Component("customKeyGenerator")
public class CustomKeyGenerator implements KeyGenerator {
    
    @Override
    public Object generate(Object target, Method method, Object... params) {
        StringBuilder keyBuilder = new StringBuilder();
        
        // 添加類(lèi)名和方法名前綴
        keyBuilder.append(target.getClass().getSimpleName())
                 .append(".")
                 .append(method.getName());
        
        // 處理參數(shù)
        for (Object param : params) {
            keyBuilder.append(":");
            if (param instanceof Product) {
                // 對(duì)于產(chǎn)品對(duì)象，只使用ID和名稱(chēng)
                Product product = (Product) param;
                keyBuilder.append("Product[")
                         .append(product.getId())
                         .append(",")
                         .append(product.getName())
                         .append("]");
            } else {
                // 其他類(lèi)型直接使用toString
                keyBuilder.append(param);
            }
        }
        
        return keyBuilder.toString();
    }
}

// 在配置類(lèi)中注冊(cè)
@Bean
public KeyGenerator customKeyGenerator() {
    return new CustomKeyGenerator();
}

// 使用自定義鍵生成器
@Cacheable(value = "products", keyGenerator = "customKeyGenerator")
public List<Product> findProductsByCategory(String category, boolean includeInactive) {
    // 鍵將類(lèi)似于: "ProductService.findProductsByCategory:Electronics:false"
    return productRepository.findByCategory(category, includeInactive);
}

// SpEL表達(dá)式緩存鍵示例
@Service
public class AdvancedCacheService {
    
    // 使用方法參數(shù)組合構(gòu)建鍵
    @Cacheable(value = "productSearch", key = "#category + '_' + #minPrice + '_' + #maxPrice")
    public List<Product> searchProducts(String category, Double minPrice, Double maxPrice) {
        return productRepository.search(category, minPrice, maxPrice);
    }
    
    // 使用對(duì)象屬性
    @Cacheable(value = "userProfile", key = "#user.id + '_' + #user.role")
    public UserProfile getUserProfile(User user) {
        return profileService.loadProfile(user);
    }
    
    // 使用條件表達(dá)式
    @Cacheable(value = "reports", 
               key = "#reportType + (T(java.lang.String).valueOf(#detailed ? '_detailed' : '_summary'))",
               condition = "#reportType != 'REALTIME'")  // 實(shí)時(shí)報(bào)告不緩存
    public Report generateReport(String reportType, boolean detailed) {
        return reportGenerator.create(reportType, detailed);
    }
    
    // 結(jié)合內(nèi)置對(duì)象和方法
    @Cacheable(value = "securedData", 
               key = "#root.target.getTenantPrefix() + '_' + #dataId",
               unless = "#result == null")
    public SecuredData getSecuredData(String dataId) {
        return securityRepository.findData(dataId);
    }
    
    // 輔助方法，用于SpEL表達(dá)式中
    public String getTenantPrefix() {
        return SecurityContextHolder.getContext().getAuthentication().getName() + "_tenant";
    }
}

// 緩存一致性維護(hù)示例
@Service
public class ConsistentCacheService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    // 讀取緩存數(shù)據(jù)
    @Cacheable(value = "productDetails", key = "#id")
    public ProductDetails getProductDetails(Long id) {
        return productDetailsRepository.findById(id).orElse(null);
    }
    
    // 更新并刷新緩存
    @Transactional
    public ProductDetails updateProductDetails(ProductDetails details) {
        // 先保存數(shù)據(jù)
        ProductDetails saved = productDetailsRepository.save(details);
        
        // 發(fā)布緩存更新事件
        eventPublisher.publishEvent(new ProductCacheInvalidationEvent(saved.getId()));
        
        return saved;
    }
    
    // 事件監(jiān)聽(tīng)器，處理緩存刷新
    @EventListener
    public void handleProductCacheInvalidation(ProductCacheInvalidationEvent event) {
        clearProductCache(event.getProductId());
    }
    
    // 清除特定產(chǎn)品緩存
    @CacheEvict(value = "productDetails", key = "#id")
    public void clearProductCache(Long id) {
        // 方法體可以為空，注解處理緩存清除
        System.out.println("產(chǎn)品緩存已清除: " + id);
    }
    
    // 緩存事件定義
    public static class ProductCacheInvalidationEvent {
        private final Long productId;
        
        public ProductCacheInvalidationEvent(Long productId) {
            this.productId = productId;
        }
        
        public Long getProductId() {
            return productId;
        }
    }
}