<!-- Spring Boot Cache Starter -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<!-- 如果使用Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- 如果使用caffeine -->
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

@SpringBootApplication
@EnableCaching
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

spring:
  cache:
    type: caffeine
    caffeine:
      spec: maximumSize=500,expireAfterWrite=60s
    # 或者分開配置
    cache-names: users,products
    caffeine.spec: # 全局默認配置
      maximumSize=1000,
      expireAfterAccess=30m

@Configuration  // 標記這是一個Spring配置類
public class CacheConfig {

    /**
     * 創(chuàng)建并配置Caffeine緩存管理器
     *
     * @return CacheManager 實例，用于管理應用中所有緩存
     *
     * 主要配置參數(shù)說明：
     * - initialCapacity: 初始緩存空間大?。ㄌ嵘跏夹阅埽?
     * - maximumSize: 緩存最大容量（基于條目數(shù)）
     * - expireAfterWrite: 寫入后過期時間（數(shù)據(jù)一致性優(yōu)先場景）
     * - recordStats: 開啟統(tǒng)計功能（用于監(jiān)控和調優(yōu)）
     */
    @Bean
    public CacheManager cacheManager() {
        // 創(chuàng)建Caffeine緩存管理器實例
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();

        // 配置Caffeine緩存參數(shù)
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .initialCapacity(100)      // 初始容量100個條目
                .maximumSize(1000)          // 最大緩存1000個條目，超過后按LRU淘汰
                .expireAfterWrite(10, TimeUnit.MINUTES)  // 寫入10分鐘后過期
                .recordStats());           // 啟用緩存統(tǒng)計（命中率等）

        return cacheManager;
    }

    /**
     * 創(chuàng)建短期緩存實例（獨立于主緩存管理器）
     *
     * @return Cache 實例，適用于高頻訪問的臨時數(shù)據(jù)
     *
     * 典型使用場景：
     * - 高頻訪問的臨時數(shù)據(jù)
     * - 需要快速失效的驗證碼等
     * - 與其他緩存不同生命周期的數(shù)據(jù)
     */
    @Bean(name = "shortTermCache")  // 指定Bean名稱便于按名稱注入
    public Cache shortTermCache() {
        return Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.MINUTES)  // 1分鐘過期（短期存儲）
                .maximumSize(100)                       // 最大100個條目
                .build();                               // 構建Cache實例
    }
}

/**
 * 根據(jù)ID獲取用戶信息（帶緩存）
 * @param id 用戶ID
 * @return 用戶對象，如果不存在返回null
 * 
 * @Cacheable 參數(shù)說明：
 * - value/cacheNames: 指定緩存名稱（對應Caffeine配置）
 * - key: 緩存鍵，使用SpEL表達式（#參數(shù)名引用方法參數(shù)）
 * - unless: 條件表達式，當結果滿足條件時不緩存
 */
@Cacheable(value = "users", key = "#id", unless = "#result == null")
public User getUserById(Long id) {
    log.info("執(zhí)行數(shù)據(jù)庫查詢，用戶ID: {}", id);
    return userRepository.findById(id).orElse(null);
}

/**
 * 更新用戶信息（同時更新緩存）
 * @param user 用戶對象
 * @return 更新后的用戶對象
 * 
 * @CachePut 特點：
 * - 總是執(zhí)行方法體
 * - 用返回值更新緩存
 * - 適用于"先寫后讀"場景
 */
@CachePut(value = "users", key = "#user.id")
public User updateUser(User user) {
    log.info("更新用戶數(shù)據(jù): {}", user.getId());
    return userRepository.save(user);
}

/**
 * 刪除用戶（同時移除緩存）
 * @param id 用戶ID
 * 
 * @CacheEvict 參數(shù)說明：
 * - beforeInvocation: 是否在方法執(zhí)行前清除緩存（默認false）
 * - allEntries: 是否清空整個緩存區(qū)域（慎用）
 */
@CacheEvict(value = "users", key = "#id")
public void deleteUser(Long id) {
    log.info("刪除用戶: {}", id);
    userRepository.deleteById(id);
}

/**
* 更新用戶狀態(tài)（復雜緩存操作）
* @param userId 用戶ID
* @param status 新狀態(tài)
*
* 典型場景：
* - 更新用戶緩存
* - 同時失效用戶列表緩存
    */
    @Caching(
    put = @CachePut(value = "users", key = "#userId"),
    evict = @CacheEvict(value = "userList", allEntries = true)
    )
    public void updateUserStatus(Long userId, UserStatus status) {
    log.info("更新用戶{}狀態(tài)為{}", userId, status);
    userRepository.updateStatus(userId, status);
    }

/**
 * 獲取用戶詳情（帶條件緩存）
 * @param id 用戶ID
 * 
 * 緩存條件說明：
 * - condition: 只有id>1000時才走緩存
 * - unless: 結果中status=DELETED時不緩存
 */
@Cacheable(value = "users", 
           key = "#id",
           condition = "#id > 1000",
           unless = "#result != null && #result.status == T(com.example.UserStatus).DELETED")
public User getUserDetail(Long id) {
    log.info("查詢用戶詳情: {}", id);
    return userRepository.findDetailById(id);
}

/**
 * 獲取用戶訂單列表（異步緩存）
 * @param userId 用戶ID
 * 
 * @sync = true 表示：
 * - 多線程并發(fā)時，只有一個線程會執(zhí)行加載
 * - 其他線程等待結果
 */
@Cacheable(value = "orders", key = "#userId", sync = true)
public List<Order> getUserOrders(Long userId) {
    log.info("加載用戶{}訂單數(shù)據(jù)...", userId);
    return orderService.getOrdersByUser(userId);
}

/**
 * 查詢用戶（防穿透處理）
 * @param name 用戶名
 * 
 * 特殊處理：
 * - 對null結果也進行緩存（特殊標記對象）
 * - 設置較短過期時間（配置文件中定義）
 */
@Cacheable(value = "usersByName", 
           key = "#name",
           unless = "#result == null || #result == T(com.example.CacheConstants).NULL_OBJECT")
public User getUserByName(String name) {
    User user = userRepository.findByName(name);
    return user != null ? user : CacheConstants.NULL_OBJECT;
}

/**
 * 獲取用戶在某系統(tǒng)的權限列表
 * @param userId 用戶ID 
 * @param systemCode 系統(tǒng)編碼（如："OA", "CRM"等）
 * @return 權限字符串集合
 * 
 * 緩存Key設計說明：
 * 1. 使用復合Key結構：`用戶ID_系統(tǒng)編碼`（如：123_OA）
 * 2. 優(yōu)點：
 *    - 避免不同系統(tǒng)權限緩存沖突
 *    - 支持按用戶+系統(tǒng)維度獨立管理緩存
 * 3. 緩存條件：僅當結果非空時緩存
 */
@Cacheable(value = "userPermissions", 
           key = "#userId + '_' + #systemCode",
           unless = "#result == null || #result.isEmpty()")
public Set<String> getUserSystemPermissions(Long userId, String systemCode) {
    log.debug("查詢用戶[{}]在系統(tǒng)[{}]的權限", userId, systemCode);
    return permissionService.findPermissions(userId, systemCode);
}

/**
 * 獲取用戶角色列表（帶枚舉參數(shù)的Key示例）
 * @param userId 用戶ID
 * @param roleType 角色類型枚舉
 * 
 * 枚舉類型處理技巧：
 * 1. 調用枚舉的name()方法轉換為字符串
 * 2. 最終Key格式：`userId:roleType`（如：123:ADMIN）
 */
@Cacheable(value = "userRoles", 
           key = "#userId + ':' + #roleType.name()")
public List<Role> getUserRoles(Long userId, RoleType roleType) {
    return roleService.findByUserAndType(userId, roleType);
}