// 按數(shù)量淘汰（保留最近使用的1000個）
Caffeine.newBuilder().maximumSize(1000)

// 按時間淘汰（數(shù)據(jù)保存1小時）
Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.HOURS)

// 創(chuàng)建緩存（相當于準備一個儲物柜）
Cache<String, User> cache = Caffeine.newBuilder()
    .maximumSize(100)  // 最多存100個用戶
    .expireAfterWrite(10, TimeUnit.MINUTES) // 10分鐘不用就清理
    .build();

// 存數(shù)據(jù)（往柜子里放東西）
cache.put("user101", new User("張三"));

// 取數(shù)據(jù)（從柜子拿東西）
User user = cache.getIfPresent("user101");

// 取不到時自動加載（柜子沒有就去倉庫找）
User user = cache.get("user101", key -> userDao.getUser(key));

@Override
public Order getOrderById(Integer id) {
    String key = CacheConstant.ORDER + id;
    return (Order) orderCache.get(key, k -> {
        // 先查詢 Redis
        Object obj = redisTemplate.opsForValue().get(key);
        if (obj != null) {
            log.info("get data from redis");
            if (obj instanceof Order) {
                return (Order) obj;
            } else {
                log.warn("Unexpected type from Redis, expected Order but got {}", obj.getClass());
            }
        }

        // Redis沒有或類型不匹配則查詢 DB
        log.info("get data from database");
        Order myOrder = orderMapper.getOrderById(id);
        redisTemplate.opsForValue().set(key, myOrder, 120, TimeUnit.SECONDS);
        return myOrder;
    });
}

@Cacheable(value = "users", key = "#userId")  
public User getUserById(Long userId) {
    // 如果緩存中沒有，才執(zhí)行此方法
    return userRepository.findById(userId).orElse(null);
}

@CachePut(value = "users", key = "#user.id")  
public User updateUser(User user) {
    return userRepository.save(user); // 更新數(shù)據(jù)庫后，自動更新緩存
}

@CacheEvict(value = "users", key = "#userId")  
public void deleteUser(Long userId) {
    userRepository.deleteById(userId); // 刪除數(shù)據(jù)庫數(shù)據(jù)后，自動刪除緩存
}

@Cacheable(value = "order", key = "#id")
@Override
public Order getOrderById(Integer id) {
    String key = CacheConstant.ORDER + id;
    // 先查詢 Redis
    Object obj = redisTemplate.opsForValue().get(key);
    if (obj != null) {
        log.info("get data from redis");
        if (obj instanceof Order) {
            return (Order) obj;
        } else {
            log.warn("Unexpected type from Redis, expected Order but got {}", obj.getClass());
        }
    }

    // Redis沒有或類型不匹配則查詢 DB
    log.info("get data from database");
    Order myOrder = orderMapper.getOrderById(id);
    redisTemplate.opsForValue().set(key, myOrder, 120, TimeUnit.SECONDS);
    return myOrder;
}

@Override
@CachePut(cacheNames = "order",key = "#order.id")
public Order updateOrder(Order order) {
    log.info("update order data");
    orderMapper.updateOrderById(order);
    //修改 Redis
    redisTemplate.opsForValue().set(CacheConstant.ORDER + order.getId(),
                                    order, 120, TimeUnit.SECONDS);

    return order;
}

@Override
@CacheEvict(cacheNames = "order",key = "#id")
public void deleteOrderById(Integer id) {
    log.info("delete order");
    orderMapper.deleteOrderById(id);
    redisTemplate.delete(CacheConstant.ORDER + id);
}

/**
 * 雙緩存注解，用于標記需要使用雙緩存（通常為本地緩存和遠程緩存）的方法
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DoubleCache {
    /**
     * 指定緩存的名稱
     * @return 緩存名稱
     */
    String cacheName();

    /**
     * 指定緩存的鍵，支持Spring EL表達式
     * @return 緩存鍵
     */
    String key(); //支持springEl表達式

    /**
     * 指定二級緩存的超時時間，單位默認根據(jù)實現(xiàn)確定（通常為秒）
     * 默認值為120
     * @return 二級緩存超時時間
     */
    long l2TimeOut() default 120;

    /**
     * 指定緩存類型
     * 默認值為 CacheType.FULL
     * @return 緩存類型
     */
    CacheType type() default CacheType.FULL;
}

public enum CacheType {
    FULL,   //存取
    PUT,    //只存
    DELETE  //刪除
}

public class SpelExpressionUtils {

    /**
     * 解析 SpEL 表達式并替換變量
     * @param elString 表達式（如 "user.name"）
     * @param map 變量鍵值對
     * @return 解析后的字符串
     */
    public static String parse(String elString, TreeMap<String, Object> map) {
        // 將輸入的表達式包裝為 SpEL 表達式格式
        elString = String.format("#{%s}", elString);
        // 創(chuàng)建 SpEL 表達式解析器
        ExpressionParser parser = new SpelExpressionParser();
        // 創(chuàng)建標準的評估上下文，用于存儲變量
        EvaluationContext context = new StandardEvaluationContext();
        // 將傳入的變量鍵值對設置到評估上下文中
        map.forEach(context::setVariable);
        // 使用解析器解析表達式，使用模板解析上下文
        Expression expression = parser.parseExpression(elString, new TemplateParserContext());
        // 在指定上下文中計算表達式的值，并將結果轉換為字符串返回
        return expression.getValue(context, String.class);
    }
}

@Slf4j
@Component
@Aspect
@AllArgsConstructor
public class CacheAspect {

    private final Cache<String, Object> cache;
    private final RedisTemplate<String, Object> redisTemplate;

    /**
     * 定義切點，匹配使用了 @DoubleCache 注解的方法
     */
    @Pointcut("@annotation(com.example.redis_caffeine.annonation.DoubleCache)")
    public void cacheAspect() {}

    /**
     * 環(huán)繞通知，處理緩存的讀寫、更新和刪除操作
     * 
     * @param point 切入點對象，包含方法執(zhí)行的相關信息
     * @return 方法執(zhí)行的返回結果
     * @throws Throwable 方法執(zhí)行過程中可能拋出的異常
     */
    @Around("cacheAspect()")
    public Object doAround(ProceedingJoinPoint point) throws Throwable {
        try {
            // 獲取方法簽名和方法對象
            MethodSignature signature = (MethodSignature) point.getSignature();
            Method method = signature.getMethod();

            // 解析參數(shù)，將參數(shù)名和參數(shù)值存入 TreeMap 中
            String[] paramNames = signature.getParameterNames();
            Object[] args = point.getArgs();
            TreeMap<String, Object> treeMap = new TreeMap<>();
            for (int i = 0; i < paramNames.length; i++) {
                treeMap.put(paramNames[i], args[i]);
            }

            // 獲取方法上的 @DoubleCache 注解
            DoubleCache annotation = method.getAnnotation(DoubleCache.class);
            // 解析 SpEL 表達式，得到最終的 key 片段
            String elResult = SpelExpressionUtils.parse(annotation.key(), treeMap);
            // 拼接完整的緩存 key
            String realKey = annotation.cacheName() + CacheConstant.ORDER + elResult;

            // 處理強制更新操作
            if (annotation.type() == CacheType.PUT) {
                // 執(zhí)行目標方法
                Object object = point.proceed();
                // 將結果存入 Redis，并設置過期時間
                redisTemplate.opsForValue().set(realKey, object, annotation.l2TimeOut(), TimeUnit.SECONDS);
                // 將結果存入 Caffeine 緩存
                cache.put(realKey, object);
                return object;
            }

            // 處理刪除操作
            if (annotation.type() == CacheType.DELETE) {
                // 從 Redis 中刪除緩存
                redisTemplate.delete(realKey);
                // 從 Caffeine 緩存中刪除緩存
                cache.invalidate(realKey);
                return point.proceed();
            }

            // 優(yōu)先從 Caffeine 緩存中獲取數(shù)據(jù)
            Object caffeineCache = cache.getIfPresent(realKey);
            if (caffeineCache != null) {
                log.info("get data from caffeine");
                return caffeineCache;
            }

            // 其次從 Redis 中獲取數(shù)據(jù)
            Object redisCache = redisTemplate.opsForValue().get(realKey);
            if (redisCache != null) {
                log.info("get data from redis");
                // 將從 Redis 中獲取的數(shù)據(jù)存入 Caffeine 緩存
                cache.put(realKey, redisCache);
                return redisCache;
            }

            // 最后查詢數(shù)據(jù)庫
            log.info("get data from database");
            Object object = point.proceed();
            if (object != null) {
                // 將數(shù)據(jù)庫查詢結果存入 Redis，并設置過期時間
                redisTemplate.opsForValue().set(realKey, object, annotation.l2TimeOut(), TimeUnit.SECONDS);
                // 將數(shù)據(jù)庫查詢結果存入 Caffeine 緩存
                cache.put(realKey, object);
            }
            return object;
        } catch (Exception e) {
            // 記錄緩存切面處理過程中的錯誤
            log.error("Cache aspect error", e);
            throw e;
        }
    }
}

/**
* 根據(jù)訂單ID獲取訂單信息
* 使用 @DoubleCache 注解，類型為 FULL，會執(zhí)行完整的緩存操作邏輯
* @param id 訂單ID
* @return 訂單對象
*/
@Override
@DoubleCache(cacheName = "order", key = "#id",
             type = CacheType.FULL)
public Order getOrderById(Integer id) {
    return orderMapper.getOrderById(id);
}

/**
* 更新訂單信息
* 使用 @DoubleCache 注解，類型為 PUT，會執(zhí)行緩存更新操作
* @param order 訂單對象
*/
@Override
@DoubleCache(cacheName = "order", key = "#id",
             type = CacheType.PUT)
public void updateOrder(Order order) {
    orderMapper.updateOrderById(order);
}

/**
* 根據(jù)訂單ID刪除訂單信息
* 使用 @DoubleCache 注解，類型為 DELETE，會執(zhí)行緩存刪除操作
* @param id 訂單ID
*/
@Override
@DoubleCache(cacheName = "order", key = "#id",
             type = CacheType.DELETE)
public void deleteOrderById(Integer id) {
    orderMapper.deleteOrderById(id);
}

@Configuration
@EnableCaching
public class CaffeineConfig {

    //-----------------------------V1------V3-----------------------------------
    @Bean
    public Cache<String, Object> orderCache() {
        return Caffeine.newBuilder()
                .initialCapacity(128)
                .maximumSize(1024)
                .expireAfterWrite(60, TimeUnit.SECONDS)
                .build();
    }

    //-----------------------------V2------------------------------------------
    @Bean
    public CacheManager cacheManager(){
        CaffeineCacheManager cacheManager=new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .initialCapacity(128)
                .maximumSize(1024)
                .expireAfterWrite(60, TimeUnit.SECONDS));
        return cacheManager;
    }
}

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

    RedisTemplate<String, Object> template = new RedisTemplate<>();

    template.setConnectionFactory(factory);

    // 創(chuàng)建 ObjectMapper 實例，用于 JSON 序列化和反序列化
    ObjectMapper objectMapper = new ObjectMapper();
    // 注冊 JavaTimeModule，用于支持 Java 8 日期時間類型的序列化和反序列化
    objectMapper.registerModule(new JavaTimeModule());
    // 禁用將日期寫成時間戳的功能
    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    // 啟用默認類型信息，用于處理多態(tài)類型的序列化和反序列化
    objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(),
                                       ObjectMapper.DefaultTyping.NON_FINAL);

    // 創(chuàng)建 GenericJackson2JsonRedisSerializer 實例，使用配置好的 ObjectMapper
    GenericJackson2JsonRedisSerializer serializer =
        new GenericJackson2JsonRedisSerializer(objectMapper);

    template.setKeySerializer(new StringRedisSerializer());

    template.setValueSerializer(serializer);

    template.setHashKeySerializer(new StringRedisSerializer());

    template.setHashValueSerializer(serializer);


    template.afterPropertiesSet();
    return template;
}