/**
 * 查詢緩存配置管理類
 */
@Configuration
@EnableTransactionManagement
public class HibernateCacheConfig {
    
    /**
     * 配置SessionFactory并啟用查詢緩存
     */
    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan("com.example.entity");
        
        Properties hibernateProperties = new Properties();
        
        // 啟用二級(jí)緩存
        hibernateProperties.setProperty("hibernate.cache.use_second_level_cache", "true");
        
        // 啟用查詢緩存
        hibernateProperties.setProperty("hibernate.cache.use_query_cache", "true");
        
        // 配置緩存提供者
        hibernateProperties.setProperty("hibernate.cache.region.factory_class", 
            "org.hibernate.cache.ehcache.EhCacheRegionFactory");
        
        // 開(kāi)啟統(tǒng)計(jì)信息收集
        hibernateProperties.setProperty("hibernate.generate_statistics", "true");
        
        sessionFactory.setHibernateProperties(hibernateProperties);
        
        return sessionFactory;
    }
    
    /**
     * 配置數(shù)據(jù)源
     */
    @Bean
    public DataSource dataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/testdb");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        return dataSource;
    }
}

/**
 * 產(chǎn)品實(shí)體類，支持查詢緩存
 */
@Entity
@Table(name = "product")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Product {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "name")
    private String name;
    
    @Column(name = "category_id")
    private Long categoryId;
    
    @Column(name = "price")
    private BigDecimal price;
    
    @Column(name = "status")
    @Enumerated(EnumType.STRING)
    private ProductStatus status;
    
    @Column(name = "create_time")
    @Temporal(TemporalType.TIMESTAMP)
    private Date createTime;
    
    // 構(gòu)造函數(shù)
    public Product() {}
    
    public Product(String name, Long categoryId, BigDecimal price) {
        this.name = name;
        this.categoryId = categoryId;
        this.price = price;
        this.status = ProductStatus.ACTIVE;
        this.createTime = new Date();
    }
    
    // getter和setter方法省略
    
    /**
     * 產(chǎn)品狀態(tài)枚舉
     */
    public enum ProductStatus {
        ACTIVE, INACTIVE, DISCONTINUED
    }
}

/**
 * 產(chǎn)品查詢服務(wù)類
 */
@Service
@Transactional(readOnly = true)
public class ProductQueryService {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 根據(jù)分類查詢產(chǎn)品，啟用查詢緩存
     */
    public List<Product> findProductsByCategory(Long categoryId) {
        Session session = sessionFactory.getCurrentSession();
        
        Query<Product> query = session.createQuery(
            "FROM Product p WHERE p.categoryId = :categoryId AND p.status = :status ORDER BY p.createTime DESC", 
            Product.class);
        
        query.setParameter("categoryId", categoryId);
        query.setParameter("status", Product.ProductStatus.ACTIVE);
        
        // 啟用查詢緩存
        query.setCacheable(true);
        
        // 指定緩存區(qū)域
        query.setCacheRegion("productsByCategory");
        
        return query.getResultList();
    }
    
    /**
     * 價(jià)格區(qū)間查詢，使用查詢緩存
     */
    public List<Product> findProductsByPriceRange(BigDecimal minPrice, BigDecimal maxPrice) {
        Session session = sessionFactory.getCurrentSession();
        
        Query<Product> query = session.createQuery(
            "FROM Product p WHERE p.price BETWEEN :minPrice AND :maxPrice " +
            "AND p.status = :status ORDER BY p.price ASC", 
            Product.class);
        
        query.setParameter("minPrice", minPrice);
        query.setParameter("maxPrice", maxPrice);
        query.setParameter("status", Product.ProductStatus.ACTIVE);
        
        // 啟用查詢緩存
        query.setCacheable(true);
        query.setCacheRegion("productsByPriceRange");
        
        return query.getResultList();
    }
    
    /**
     * 獲取熱門產(chǎn)品，適合查詢緩存
     */
    public List<Product> getPopularProducts(int limit) {
        Session session = sessionFactory.getCurrentSession();
        
        Query<Product> query = session.createQuery(
            "FROM Product p WHERE p.status = :status ORDER BY p.createTime DESC", 
            Product.class);
        
        query.setParameter("status", Product.ProductStatus.ACTIVE);
        query.setMaxResults(limit);
        
        // 啟用查詢緩存，熱門產(chǎn)品查詢頻率高
        query.setCacheable(true);
        query.setCacheRegion("popularProducts");
        
        return query.getResultList();
    }
}

/**
 * 復(fù)雜查詢緩存服務(wù)
 */
@Service
@Transactional(readOnly = true)
public class AdvancedQueryService {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 分類統(tǒng)計(jì)查詢，使用聚合緩存
     */
    public List<CategoryStatistics> getCategoryStatistics() {
        Session session = sessionFactory.getCurrentSession();
        
        Query<CategoryStatistics> query = session.createQuery(
            "SELECT new com.example.dto.CategoryStatistics(" +
            "p.categoryId, COUNT(p), AVG(p.price), MAX(p.price), MIN(p.price)) " +
            "FROM Product p WHERE p.status = :status " +
            "GROUP BY p.categoryId ORDER BY COUNT(p) DESC", 
            CategoryStatistics.class);
        
        query.setParameter("status", Product.ProductStatus.ACTIVE);
        
        // 統(tǒng)計(jì)查詢適合緩存，計(jì)算復(fù)雜但變化不頻繁
        query.setCacheable(true);
        query.setCacheRegion("categoryStatistics");
        
        return query.getResultList();
    }
    
    /**
     * 關(guān)聯(lián)查詢緩存示例
     */
    public List<Product> findProductsWithCategoryInfo(String categoryName) {
        Session session = sessionFactory.getCurrentSession();
        
        Query<Product> query = session.createQuery(
            "SELECT p FROM Product p JOIN Category c ON p.categoryId = c.id " +
            "WHERE c.name = :categoryName AND p.status = :status " +
            "ORDER BY p.createTime DESC", 
            Product.class);
        
        query.setParameter("categoryName", categoryName);
        query.setParameter("status", Product.ProductStatus.ACTIVE);
        
        // 關(guān)聯(lián)查詢緩存，確保Category實(shí)體也支持二級(jí)緩存
        query.setCacheable(true);
        query.setCacheRegion("productsWithCategory");
        
        return query.getResultList();
    }
    
    /**
     * 分頁(yè)查詢緩存處理
     */
    public Page<Product> findProductsPaged(int pageNumber, int pageSize, Long categoryId) {
        Session session = sessionFactory.getCurrentSession();
        
        // 查詢總數(shù)
        Query<Long> countQuery = session.createQuery(
            "SELECT COUNT(p) FROM Product p WHERE p.categoryId = :categoryId AND p.status = :status", 
            Long.class);
        countQuery.setParameter("categoryId", categoryId);
        countQuery.setParameter("status", Product.ProductStatus.ACTIVE);
        countQuery.setCacheable(true);
        countQuery.setCacheRegion("productCount");
        
        Long totalCount = countQuery.getSingleResult();
        
        // 分頁(yè)查詢數(shù)據(jù)
        Query<Product> dataQuery = session.createQuery(
            "FROM Product p WHERE p.categoryId = :categoryId AND p.status = :status ORDER BY p.createTime DESC", 
            Product.class);
        dataQuery.setParameter("categoryId", categoryId);
        dataQuery.setParameter("status", Product.ProductStatus.ACTIVE);
        dataQuery.setFirstResult(pageNumber * pageSize);
        dataQuery.setMaxResults(pageSize);
        
        // 分頁(yè)查詢也可以緩存
        dataQuery.setCacheable(true);
        dataQuery.setCacheRegion("productsPaged");
        
        List<Product> products = dataQuery.getResultList();
        
        return new Page<>(products, pageNumber, pageSize, totalCount);
    }
}

/**
 * Criteria查詢緩存服務(wù)
 */
@Service
@Transactional(readOnly = true)
public class CriteriaQueryService {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 使用Criteria構(gòu)建緩存查詢
     */
    public List<Product> findProductsByCriteria(ProductSearchCriteria criteria) {
        Session session = sessionFactory.getCurrentSession();
        CriteriaBuilder cb = session.getCriteriaBuilder();
        CriteriaQuery<Product> cq = cb.createQuery(Product.class);
        Root<Product> root = cq.from(Product.class);
        
        // 構(gòu)建查詢條件
        Predicate predicate = cb.conjunction();
        
        if (criteria.getCategoryId() != null) {
            predicate = cb.and(predicate, cb.equal(root.get("categoryId"), criteria.getCategoryId()));
        }
        
        if (criteria.getMinPrice() != null) {
            predicate = cb.and(predicate, cb.greaterThanOrEqualTo(root.get("price"), criteria.getMinPrice()));
        }
        
        if (criteria.getMaxPrice() != null) {
            predicate = cb.and(predicate, cb.lessThanOrEqualTo(root.get("price"), criteria.getMaxPrice()));
        }
        
        predicate = cb.and(predicate, cb.equal(root.get("status"), Product.ProductStatus.ACTIVE));
        
        cq.where(predicate);
        cq.orderBy(cb.desc(root.get("createTime")));
        
        TypedQuery<Product> query = session.createQuery(cq);
        
        // 啟用Criteria查詢緩存
        query.setCacheable(true);
        query.setCacheRegion("criteriaProductSearch");
        
        return query.getResultList();
    }
    
    /**
     * 動(dòng)態(tài)統(tǒng)計(jì)查詢緩存
     */
    public ProductSummary getProductSummaryByCriteria(Long categoryId) {
        Session session = sessionFactory.getCurrentSession();
        CriteriaBuilder cb = session.getCriteriaBuilder();
        CriteriaQuery<Object[]> cq = cb.createQuery(Object[].class);
        Root<Product> root = cq.from(Product.class);
        
        // 構(gòu)建多字段聚合查詢
        cq.multiselect(
            cb.count(root),
            cb.avg(root.get("price")),
            cb.max(root.get("price")),
            cb.min(root.get("price"))
        );
        
        Predicate predicate = cb.and(
            cb.equal(root.get("categoryId"), categoryId),
            cb.equal(root.get("status"), Product.ProductStatus.ACTIVE)
        );
        
        cq.where(predicate);
        
        TypedQuery<Object[]> query = session.createQuery(cq);
        
        // 統(tǒng)計(jì)查詢緩存
        query.setCacheable(true);
        query.setCacheRegion("productSummary");
        
        Object[] result = query.getSingleResult();
        
        return new ProductSummary(
            ((Long) result[0]).intValue(),
            (Double) result[1],
            (BigDecimal) result[2],
            (BigDecimal) result[3]
        );
    }
}

/**
 * 查詢條件封裝類
 */
public class ProductSearchCriteria {
    private Long categoryId;
    private BigDecimal minPrice;
    private BigDecimal maxPrice;
    private String nameKeyword;
    private Product.ProductStatus status;
    
    // 構(gòu)造函數(shù)
    public ProductSearchCriteria() {
        this.status = Product.ProductStatus.ACTIVE;
    }
    
    /**
     * 生成緩存鍵值的輔助方法
     */
    public String generateCacheKey() {
        StringBuilder keyBuilder = new StringBuilder();
        keyBuilder.append("category:").append(categoryId != null ? categoryId : "all");
        keyBuilder.append("_price:").append(minPrice != null ? minPrice : "0");
        keyBuilder.append("-").append(maxPrice != null ? maxPrice : "unlimited");
        keyBuilder.append("_keyword:").append(nameKeyword != null ? nameKeyword : "none");
        keyBuilder.append("_status:").append(status);
        
        return keyBuilder.toString();
    }
    
    // getter和setter方法省略
}

/**
 * 產(chǎn)品摘要信息類
 */
public class ProductSummary {
    private int totalCount;
    private double averagePrice;
    private BigDecimal maxPrice;
    private BigDecimal minPrice;
    
    public ProductSummary(int totalCount, double averagePrice, 
                         BigDecimal maxPrice, BigDecimal minPrice) {
        this.totalCount = totalCount;
        this.averagePrice = averagePrice;
        this.maxPrice = maxPrice;
        this.minPrice = minPrice;
    }
    
    // getter和setter方法省略
}

/**
 * 產(chǎn)品管理服務(wù)，展示緩存失效處理
 */
@Service
@Transactional
public class ProductManagementService {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 創(chuàng)建產(chǎn)品，觸發(fā)查詢緩存失效
     */
    public Product createProduct(Product product) {
        Session session = sessionFactory.getCurrentSession();
        
        // 保存操作會(huì)自動(dòng)觸發(fā)相關(guān)查詢緩存失效
        session.save(product);
        
        // 可以手動(dòng)清理特定的查詢緩存區(qū)域
        sessionFactory.getCache().evictQueryRegion("productsByCategory");
        sessionFactory.getCache().evictQueryRegion("categoryStatistics");
        
        return product;
    }
    
    /**
     * 更新產(chǎn)品信息
     */
    public Product updateProduct(Product product) {
        Session session = sessionFactory.getCurrentSession();
        
        // 獲取更新前的產(chǎn)品信息，用于判斷哪些緩存需要清理
        Product existingProduct = session.get(Product.class, product.getId());
        
        // 執(zhí)行更新操作
        session.merge(product);
        
        // 根據(jù)更新內(nèi)容決定緩存清理策略
        if (!existingProduct.getCategoryId().equals(product.getCategoryId())) {
            // 分類發(fā)生變化，清理分類相關(guān)緩存
            sessionFactory.getCache().evictQueryRegion("productsByCategory");
            sessionFactory.getCache().evictQueryRegion("categoryStatistics");
        }
        
        if (!existingProduct.getPrice().equals(product.getPrice())) {
            // 價(jià)格發(fā)生變化，清理價(jià)格相關(guān)緩存
            sessionFactory.getCache().evictQueryRegion("productsByPriceRange");
        }
        
        return product;
    }
    
    /**
     * 批量更新操作的緩存處理
     */
    public void batchUpdateProductStatus(List<Long> productIds, Product.ProductStatus newStatus) {
        Session session = sessionFactory.getCurrentSession();
        
        // 執(zhí)行批量更新
        Query updateQuery = session.createQuery(
            "UPDATE Product p SET p.status = :newStatus WHERE p.id IN :ids");
        updateQuery.setParameter("newStatus", newStatus);
        updateQuery.setParameter("ids", productIds);
        
        int updatedCount = updateQuery.executeUpdate();
        
        // 批量操作后清理相關(guān)查詢緩存
        if (updatedCount > 0) {
            sessionFactory.getCache().evictQueryRegions();
        }
    }
}

/**
 * 查詢緩存監(jiān)控服務(wù)
 */
@Service
public class QueryCacheMonitorService {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 生成查詢緩存性能報(bào)告
     */
    public QueryCacheReport generateCacheReport() {
        Statistics stats = sessionFactory.getStatistics();
        
        QueryCacheReport report = new QueryCacheReport();
        
        // 查詢緩存命中統(tǒng)計(jì)
        report.setQueryCacheHitCount(stats.getQueryCacheHitCount());
        report.setQueryCacheMissCount(stats.getQueryCacheMissCount());
        report.setQueryCachePutCount(stats.getQueryCachePutCount());
        
        // 計(jì)算命中率
        long totalQueryRequests = stats.getQueryCacheHitCount() + stats.getQueryCacheMissCount();
        if (totalQueryRequests > 0) {
            double hitRatio = (double) stats.getQueryCacheHitCount() / totalQueryRequests;
            report.setHitRatio(hitRatio);
        }
        
        // 二級(jí)緩存統(tǒng)計(jì)
        report.setSecondLevelCacheHitCount(stats.getSecondLevelCacheHitCount());
        report.setSecondLevelCacheMissCount(stats.getSecondLevelCacheMissCount());
        
        // 查詢執(zhí)行統(tǒng)計(jì)
        report.setQueryExecutionCount(stats.getQueryExecutionCount());
        report.setQueryExecutionMaxTime(stats.getQueryExecutionMaxTime());
        
        return report;
    }
    
    /**
     * 清理指定查詢緩存區(qū)域
     */
    public void evictQueryCache(String regionName) {
        if (regionName != null && !regionName.isEmpty()) {
            sessionFactory.getCache().evictQueryRegion(regionName);
        } else {
            sessionFactory.getCache().evictDefaultQueryRegion();
        }
    }
    
    /**
     * 獲取緩存區(qū)域信息
     */
    public Map<String, CacheRegionInfo> getCacheRegionInfo() {
        Statistics stats = sessionFactory.getStatistics();
        Map<String, CacheRegionInfo> regionInfoMap = new HashMap<>();
        
        String[] regionNames = stats.getSecondLevelCacheRegionNames();
        for (String regionName : regionNames) {
            SecondLevelCacheStatistics regionStats = stats.getSecondLevelCacheStatistics(regionName);
            
            CacheRegionInfo info = new CacheRegionInfo();
            info.setRegionName(regionName);
            info.setHitCount(regionStats.getHitCount());
            info.setMissCount(regionStats.getMissCount());
            info.setPutCount(regionStats.getPutCount());
            info.setElementCountInMemory(regionStats.getElementCountInMemory());
            info.setSizeInMemory(regionStats.getSizeInMemory());
            
            regionInfoMap.put(regionName, info);
        }
        
        return regionInfoMap;
    }
}

/**
 * 查詢緩存報(bào)告類
 */
public class QueryCacheReport {
    private long queryCacheHitCount;
    private long queryCacheMissCount;
    private long queryCachePutCount;
    private double hitRatio;
    private long secondLevelCacheHitCount;
    private long secondLevelCacheMissCount;
    private long queryExecutionCount;
    private long queryExecutionMaxTime;
    
    // getter和setter方法省略
    
    @Override
    public String toString() {
        return String.format(
            "Query Cache Report:\n" +
            "Hit: %d, Miss: %d, Put: %d\n" +
            "Hit Ratio: %.2f%%\n" +
            "Query Execution Count: %d, Max Time: %d ms\n" +
            "Second Level Cache Hit: %d, Miss: %d",
            queryCacheHitCount, queryCacheMissCount, queryCachePutCount,
            hitRatio * 100, queryExecutionCount, queryExecutionMaxTime,
            secondLevelCacheHitCount, secondLevelCacheMissCount
        );
    }
}