/**
 * Cache-Aside(Lazy Loading,旁路模式) (最常见)
 * 1. 应用程序直接管理缓存和数据库的交互。
 * 2. 读操作：先查缓存，若缓存命中则返回数据；若未命中，则从数据库查询数据，放入缓存后返回。
 * 3. 写操作：直接更新数据库，然后使缓存中的相关数据失效（删除或更新）。
 * @param productId 产品id
 */
private String cacheAside(String productId) {
    String productInfo = ProductCache.getProductInfo(productId);
    // 不存在，则查询数据库并缓存起来
    if (null == productInfo) {
        productInfo = ProductDao.getProductInfo(productId);
        ProductCache.putProductInfo(productId, productInfo);
    }
    return productInfo;
}


/**
 * Read-Through(读穿透模式)
 * 1.读操作：应用程序直接查询缓存层，若缓存未命中，缓存层自动从数据库加载数据，存入缓存后返回。
 * 2.通常与Cache-Aside类似，应用程序直接更新数据库并失效缓存，但某些实现中缓存层也可以接管写逻辑。
 * @param productId 产品id
 */

private String readThrough(String productId) {
    return ProductCache.getProductInfoReadThrough(productId);
}

/**
 * Write-Through(写穿透模式)
 * 1.写操作：应用程序写入数据时，缓存层先更新缓存，然后同步更新数据库，确保两者一致。
 * 2.读操作：通常与Read-Through结合，缓存层直接返回数据。
 */
private void writeThrough(String productInfo) {
    String productId = ProductDao.putProductInfo(productInfo);
    ProductCache.putProductInfo(productId, productInfo);
}


public static class ProductCache {

    private final static ConcurrentMap<String, String> CACHE = new ConcurrentHashMap<>();

    public static void putProductInfo(String productId, String productInfo) {
        CACHE.computeIfAbsent(productId, (key) -> productInfo);
    }

    /**
     * 从“数据库”中获取产品信息。
     * 为了演示，这里会打印一条消息来表明数据源是数据库。
     * @param productId 产品ID
     * @return 产品信息
     */
    public static String getProductInfo(String productId) {
        System.out.println("--- 正在从数据库加载产品：" + productId + " ---");
        // 模拟网络或数据库延迟
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return ProductDao.getProductInfo(productId);
    }

    /**
     * getProductInfoReadThrough方法封装了整个逻辑：先检查缓存，如果不存在，则调用 ProductDao 来获取数据，并将其存入缓存，最后返回数据
     * @param productId 产品ID
     * @return 产品信息
     */
    public static String getProductInfoReadThrough(String productId) {
        return CACHE.computeIfAbsent(productId, (key) -> ProductDao.getProductInfo(productId));
    }
}

/**
 * 模拟数据访问对象 (DAO)，用于从底层数据源（如数据库）获取数据。
 */
public static class ProductDao {

    private static final Map<String, String> DATABASE = new HashMap<>();

    static {
        // 初始化一些模拟数据
        DATABASE.put("product:1", "这是产品1的详细信息");
        DATABASE.put("product:2", "这是产品2的详细信息");
        DATABASE.put("product:3", "这是产品3的详细信息");
    }

    /**
     * 从“数据库”中获取产品信息。
     * 为了演示，这里会打印一条消息来表明数据源是数据库。
     * @param productId 产品ID
     * @return 产品信息
     */
    public static String getProductInfo(String productId) {
        System.out.println("--- 正在从数据库加载产品：" + productId + " ---");
        // 模拟网络或数据库延迟
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return DATABASE.get(productId);
    }
    /**
     * 往“数据库”中添加产品信息。
     * @param productInfo 产品Info
     * @return 产品ID
     */
    public static String putProductInfo(String productInfo) {
        System.out.println("--- 正在往数据库添加产品：" + productInfo + " ---");

        String productId;
        synchronized (DATABASE) {
            int size = DATABASE.size();
            productId = "product:" + size + 1;
            DATABASE.putIfAbsent(productId, productInfo);
        }
        return productId;
    }

}