/**
 * Hibernate緩存配置示例
 */
@Entity
@Table(name = "user")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "username")
    private String username;
    
    @Column(name = "email")
    private String email;
    
    // 構(gòu)造函數(shù)、getter和setter方法
    public User() {}
    
    public User(String username, String email) {
        this.username = username;
        this.email = email;
    }
    
    // 省略getter和setter方法
}

/**
 * 緩存策略配置
 */
public class CacheConfiguration {
    
    /**
     * 配置SessionFactory with緩存設(shè)置
     */
    public SessionFactory createSessionFactory() {
        Configuration configuration = new Configuration();
        
        // 啟用二級緩存
        configuration.setProperty("hibernate.cache.use_second_level_cache", "true");
        
        // 設(shè)置緩存提供者
        configuration.setProperty("hibernate.cache.region.factory_class", 
            "org.hibernate.cache.ehcache.EhCacheRegionFactory");
        
        // 啟用查詢緩存
        configuration.setProperty("hibernate.cache.use_query_cache", "true");
        
        // 顯示SQL語句用于調(diào)試
        configuration.setProperty("hibernate.show_sql", "true");
        
        return configuration.buildSessionFactory();
    }
}

<!-- ehcache.xml配置文件 -->
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
    
    <!-- 默認緩存配置 -->
    <defaultCache
        maxElementsInMemory="1000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        diskPersistent="false"
        diskExpiryThreadIntervalSeconds="120"/>
    
    <!-- User實體緩存配置 -->
    <cache name="com.example.entity.User"
           maxElementsInMemory="500"
           eternal="false"
           timeToIdleSeconds="600"
           timeToLiveSeconds="1200"
           overflowToDisk="true"/>
    
    <!-- 查詢緩存配置 -->
    <cache name="org.hibernate.cache.internal.StandardQueryCache"
           maxElementsInMemory="100"
           eternal="false"
           timeToLiveSeconds="300"/>
           
</ehcache>

/**
 * 用戶服務(wù)類，演示二級緩存使用
 */
@Service
@Transactional
public class UserService {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 根據(jù)ID查詢用戶，利用二級緩存
     */
    public User findById(Long id) {
        Session session = sessionFactory.getCurrentSession();
        
        // 第一次查詢會從數(shù)據(jù)庫加載并緩存
        User user = session.get(User.class, id);
        
        return user;
    }
    
    /**
     * 批量查詢用戶，展示緩存效果
     */
    public List<User> findUsersByIds(List<Long> ids) {
        Session session = sessionFactory.getCurrentSession();
        List<User> users = new ArrayList<>();
        
        // 循環(huán)查詢，已緩存的數(shù)據(jù)直接從緩存獲取
        for (Long id : ids) {
            User user = session.get(User.class, id);
            if (user != null) {
                users.add(user);
            }
        }
        
        return users;
    }
    
    /**
     * 更新用戶信息，緩存會自動失效
     */
    public void updateUser(User user) {
        Session session = sessionFactory.getCurrentSession();
        
        // 更新操作會導(dǎo)致相關(guān)緩存失效
        session.update(user);
    }
}

/**
 * 查詢緩存使用示例
 */
@Repository
public class UserRepository {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 使用HQL查詢并啟用查詢緩存
     */
    public List<User> findActiveUsers() {
        Session session = sessionFactory.getCurrentSession();
        
        Query<User> query = session.createQuery(
            "FROM User u WHERE u.active = :active", User.class);
        query.setParameter("active", true);
        
        // 啟用查詢緩存
        query.setCacheable(true);
        
        // 設(shè)置緩存區(qū)域（可選）
        query.setCacheRegion("activeUsersQuery");
        
        return query.getResultList();
    }
    
    /**
     * 帶分頁的緩存查詢
     */
    public List<User> findUsersByPage(int page, int size) {
        Session session = sessionFactory.getCurrentSession();
        
        Query<User> query = session.createQuery(
            "FROM User u ORDER BY u.createTime DESC", User.class);
        
        // 設(shè)置分頁參數(shù)
        query.setFirstResult(page * size);
        query.setMaxResults(size);
        
        // 啟用查詢緩存
        query.setCacheable(true);
        
        return query.getResultList();
    }
}

/**
 * 緩存管理服務(wù)
 */
@Service
public class CacheManagementService {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 手動清理實體緩存
     */
    public void evictEntityCache(Class<?> entityClass, Serializable id) {
        SessionFactory sf = sessionFactory;
        
        // 清理指定實體的緩存
        sf.getCache().evictEntity(entityClass, id);
    }
    
    /**
     * 清理整個實體類的緩存
     */
    public void evictEntityRegion(Class<?> entityClass) {
        SessionFactory sf = sessionFactory;
        
        // 清理實體類對應(yīng)的整個緩存區(qū)域
        sf.getCache().evictEntityRegion(entityClass);
    }
    
    /**
     * 清理查詢緩存
     */
    public void evictQueryCache() {
        SessionFactory sf = sessionFactory;
        
        // 清理默認查詢緩存區(qū)域
        sf.getCache().evictDefaultQueryRegion();
    }
    
    /**
     * 獲取緩存統(tǒng)計信息
     */
    public void printCacheStatistics() {
        SessionFactory sf = sessionFactory;
        Statistics statistics = sf.getStatistics();
        
        // 打印緩存命中率統(tǒng)計
        System.out.println("Second Level Cache Hit Ratio: " + 
            statistics.getSecondLevelCacheHitCount() * 1.0 / 
            statistics.getSecondLevelCacheRequestCount());
        
        System.out.println("Query Cache Hit Ratio: " + 
            statistics.getQueryCacheHitCount() * 1.0 / 
            statistics.getQueryCacheRequestCount());
    }
}

/**
 * 緩存性能監(jiān)控工具
 */
@Component
public class CacheMonitor {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    /**
     * 生成緩存性能報告
     */
    public CachePerformanceReport generateReport() {
        Statistics stats = sessionFactory.getStatistics();
        
        CachePerformanceReport report = new CachePerformanceReport();
        
        // 二級緩存統(tǒng)計
        report.setSecondLevelCacheHitCount(stats.getSecondLevelCacheHitCount());
        report.setSecondLevelCacheMissCount(stats.getSecondLevelCacheMissCount());
        report.setSecondLevelCachePutCount(stats.getSecondLevelCachePutCount());
        
        // 計算命中率
        long totalRequests = stats.getSecondLevelCacheHitCount() + 
                           stats.getSecondLevelCacheMissCount();
        if (totalRequests > 0) {
            double hitRatio = (double) stats.getSecondLevelCacheHitCount() / totalRequests;
            report.setHitRatio(hitRatio);
        }
        
        // 查詢緩存統(tǒng)計
        report.setQueryCacheHitCount(stats.getQueryCacheHitCount());
        report.setQueryCacheMissCount(stats.getQueryCacheMissCount());
        
        return report;
    }
    
    /**
     * 緩存性能報告類
     */
    public static class CachePerformanceReport {
        private long secondLevelCacheHitCount;
        private long secondLevelCacheMissCount;
        private long secondLevelCachePutCount;
        private double hitRatio;
        private long queryCacheHitCount;
        private long queryCacheMissCount;
        
        // getter和setter方法省略
        
        @Override
        public String toString() {
            return String.format(
                "Cache Performance Report:\n" +
                "Second Level Cache - Hit: %d, Miss: %d, Put: %d\n" +
                "Hit Ratio: %.2f%%\n" +
                "Query Cache - Hit: %d, Miss: %d",
                secondLevelCacheHitCount, secondLevelCacheMissCount, 
                secondLevelCachePutCount, hitRatio * 100,
                queryCacheHitCount, queryCacheMissCount
            );
        }
    }
}