前序

@Test
@DisplayName("测试在事务内的缓存行为")
public void testCacheBehaviorInTransaction() {
    // 准备测试数据
    Category category = createTestCategory("tc-001", "测试类别");
    Product product = createTestProduct("tp-001", "测试商品", new BigDecimal("199.99"), "tc-001");

    // 1. 第一次查询 - 从数据库加载并缓存
    QueryResult<Product> firstQuery = measureQueryTime(() -> 
        sqlClient.findById(ProductFetcher.$.allScalarFields().category(
            CategoryFetcher.$.name()
        ), "tp-001")
    );

    // 2. 更新商品价格
    Product updatedProduct = ProductDraft.$.produce(draftObj -> {
        draftObj.setId("tp-001");
        // 保留其他属性，仅修改价格
        draftObj.setPrice(new BigDecimal("299.99"));
    });
    sqlClient.save(updatedProduct);

    // 3. 更新后立即查询 - 验证事务内一致性
    Product immediateProduct = sqlClient.findById(
        ProductFetcher.$.name().price(), 
        "tp-001"
    );
    assertThat(immediateProduct.price()).isEqualTo(new BigDecimal("299.99"));

    // 4. 第二次完整查询 - 测试缓存效率
    QueryResult<Product> secondQuery = measureQueryTime(() -> 
        sqlClient.findById(ProductFetcher.$.allScalarFields().category(
            CategoryFetcher.$.name()
        ), "tp-001")
    );

    // 打印性能对比
    System.out.println("First query: " + firstQuery.getExecutionTimeNs() / 1_000_000 + "ms");
    System.out.println("Second query: " + secondQuery.getExecutionTimeNs() / 1_000_000 + "ms");
}

@Test
@DisplayName("测试事务隔离级别对缓存效果的影响")
public void testTransactionIsolationWithCache() throws Exception {
    // 准备测试数据
    Category category = createTestCategory("tc-002", "电子设备");
    Product product = createTestProduct("tp-002", "智能手表", new BigDecimal("1299.99"), "tc-002");

    // 模拟两个并发事务
    CountDownLatch latch1 = new CountDownLatch(1); // 控制事务顺序
    CountDownLatch latch2 = new CountDownLatch(1);

    // 事务1: 更新商品价格
    ExecutorService executor = Executors.newFixedThreadPool(2);
    executor.submit(() -> {
        executeTransaction1("tp-002", latch1, latch2); // 更新价格为1499.99
    });

    // 事务2: 读取商品价格
    List<BigDecimal> priceInTransaction2 = new ArrayList<>();
    executor.submit(() -> {
        BigDecimal price = executeTransaction2("tp-002", latch1, latch2);
        priceInTransaction2.add(price);
    });

    // 等待两个事务完成
    executor.shutdown();
    executor.awaitTermination(10, TimeUnit.SECONDS);

    // 验证最终价格
    Product finalProduct = sqlClient.findById(ProductFetcher.$.price(), "tp-002");
    BigDecimal transaction2Price = priceInTransaction2.isEmpty() ? null : priceInTransaction2.get(0);

    System.out.println("Final price: " + finalProduct.price());
    System.out.println("Price seen in transaction 2: " + transaction2Price);
}

@Test
@DisplayName("测试批量操作中的缓存效率")
public void testCacheEfficiencyInBulkOperations() {
    // 创建测试类别和商品
    Category category = createTestCategory("tc-003", "家用电器");
    for (int i = 0; i < 10; i++) {
        createTestProduct(
            "tp-bulk-" + i, 
            "家电产品" + i, 
            new BigDecimal("1000").add(new BigDecimal(i * 100)), 
            "tc-003"
        );
    }

    // 首次批量查询 - 无缓存
    long start1 = System.nanoTime();
    for (int i = 0; i < 10; i++) {
        Product product = sqlClient.findById(
            ProductFetcher.$.name().price().category(CategoryFetcher.$.name()),
            "tp-bulk-" + i
        );
    }
    long firstBatchTime = System.nanoTime() - start1;

    // 再次批量查询 - 有缓存
    long start2 = System.nanoTime();
    for (int i = 0; i < 10; i++) {
        Product product = sqlClient.findById(
            ProductFetcher.$.name().price().category(CategoryFetcher.$.name()),
            "tp-bulk-" + i
        );
    }
    long secondBatchTime = System.nanoTime() - start2;

    // 输出性能对比
    System.out.println("首次查询: " + firstBatchTime / 1_000_000 + "ms");
    System.out.println("二次查询: " + secondBatchTime / 1_000_000 + "ms");
    System.out.println("性能提升: " + (double)firstBatchTime / secondBatchTime + "倍");
}

@Transactional
public Order createOrder(String productId, int quantity, String userId) {
    // 查询商品
    Product product = sqlClient.findById(Product.class, productId);
    if (product == null || product.stock() < quantity) {
        throw new InsufficientStockException("库存不足");
    }

    // 减少库存
    Product updatedProduct = ProductDraft.$.produce(draft -> {
        draft.setId(productId);
        draft.setStock(product.stock() - quantity);
    });
    sqlClient.save(updatedProduct);

    // 创建订单
    Order draft = OrderDraft.$.produce(draft -> {
        draft.setId(UUID.randomUUID().toString());
        draft.setProductId(productId);
        draft.setQuantity(quantity);
        draft.setUserId(userId);
        draft.setTotalPrice(product.price().multiply(new BigDecimal(quantity)));
        draft.setStatus("CREATED");
        draft.setCreatedTime(LocalDateTime.now());
    });

    return sqlClient.save(draft).getModifiedEntity();
}

@Test
@DisplayName("测试事务的原子性")
@Transactional
public void testTransactionAtomicity() {
    // 准备测试数据
    final String CATEGORY_ID = "tx-basic-01";
    final String PRODUCT_ID = "tx-prod-01";

    try {
        // 清理可能的测试残留数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);

        // 验证清理成功，初始状态没有数据
        assertThat(sqlClient.findById(Product.class, PRODUCT_ID)).isNull();
        assertThat(sqlClient.findById(Category.class, CATEGORY_ID)).isNull();

        // 使用assertThrows捕获预期的异常
        assertThrows(RuntimeException.class, () -> {
            // 在当前事务中创建类别和商品
            System.out.println("创建类别: " + CATEGORY_ID);
            Category category = createTestCategory(CATEGORY_ID, "原子性测试类别");

            System.out.println("创建商品: " + PRODUCT_ID);
            Product product = createTestProduct(PRODUCT_ID, "原子性测试商品", 
                              new BigDecimal("199.99"), CATEGORY_ID);

            // 验证数据在事务中已创建
            Category checkCategory = sqlClient.findById(Category.class, CATEGORY_ID);
            Product checkProduct = sqlClient.findById(Product.class, PRODUCT_ID);

            assertThat(checkCategory).isNotNull();
            assertThat(checkProduct).isNotNull();

            // 故意抛出异常，应该触发整个事务回滚
            throw new RuntimeException("故意抛出异常以测试事务原子性");
        });

    } finally {
        // 确保测试后清理数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);
    }
}

@Test
@DisplayName("验证事务的原子性回滚")
public void testTransactionAtomicityVerification() {
    // 准备测试数据
    final String CATEGORY_ID = "tx-basic-01";
    final String PRODUCT_ID = "tx-prod-01";

    try {
        // 预期情况：上一个测试抛出异常后应该回滚事务
        // 所以此处的数据应该不存在
        Product product = sqlClient.findById(Product.class, PRODUCT_ID);
        Category category = sqlClient.findById(Category.class, CATEGORY_ID);

        // 验证数据不存在，说明事务回滚成功，符合原子性
        assertThat(product).isNull();
        assertThat(category).isNull();

    } finally {
        // 确保测试后清理数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);
    }
}

@Test
@DisplayName("测试事务的一致性")
public void testTransactionConsistency() {
    // 准备测试数据
    final String CATEGORY_ID = "tx-basic-02";
    final String PRODUCT_ID = "tx-prod-02";

    try {
        // 创建类别
        Category category = createTestCategory(CATEGORY_ID, "一致性测试类别");

        // 使用编程式事务更新商品
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);

        // 1. 创建商品
        transactionTemplate.execute(status -> {
            createTestProduct(PRODUCT_ID, "一致性测试商品", new BigDecimal("299.99"), CATEGORY_ID);
            return null;
        });

        // 2. 验证商品存在且价格正确
        Product product = sqlClient.findById(ProductFetcher.$.price().stock(), PRODUCT_ID);
        assertThat(product).isNotNull();
        assertThat(product.price()).isEqualTo(new BigDecimal("299.99"));
        assertThat(product.stock()).isEqualTo(100);

        // 3. 在事务中更新商品价格和库存
        transactionTemplate.execute(status -> {
            // 读取当前商品
            Product currentProduct = sqlClient.findById(Product.class, PRODUCT_ID);

            // 创建更新对象 - 减少库存并更新价格
            Product updatedProduct = ProductDraft.$.produce(draft -> {
                draft.setId(PRODUCT_ID);
                draft.setPrice(new BigDecimal("249.99"));
                draft.setStock(80);
            });

            // 执行更新
            sqlClient.save(updatedProduct);
            return null;
        });

        // 4. 验证更新后数据的一致性
        Product updatedProduct = sqlClient.findById(ProductFetcher.$.price().stock(), PRODUCT_ID);
        assertThat(updatedProduct.price()).isEqualTo(new BigDecimal("249.99"));
        assertThat(updatedProduct.stock()).isEqualTo(80);

    } finally {
        // 清理测试数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);
    }
}

@Test
@DisplayName("测试事务的隔离性 - READ_COMMITTED")
public void testTransactionIsolation_ReadCommitted() throws Exception {
    // 准备测试数据
    final String CATEGORY_ID = "tx-basic-03";
    final String PRODUCT_ID = "tx-prod-03";
    final BigDecimal INITIAL_PRICE = new BigDecimal("399.99");

    try {
        // 创建类别和商品
        Category category = createTestCategory(CATEGORY_ID, "隔离性测试类别");
        Product product = createTestProduct(PRODUCT_ID, "隔离性测试商品", INITIAL_PRICE, CATEGORY_ID);

        // 使用CountDownLatch确保两个事务按正确顺序执行
        CountDownLatch latch1 = new CountDownLatch(1);
        CountDownLatch latch2 = new CountDownLatch(1);

        // 存储事务中观察到的价格
        List<BigDecimal> pricesInTransaction1 = new ArrayList<>();
        List<BigDecimal> pricesInTransaction2 = new ArrayList<>();

        // 创建两个执行线程
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 第一个事务：长事务，在提交前读取两次
        executor.submit(() -> {
            DefaultTransactionDefinition def = new DefaultTransactionDefinition();
            def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
            def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);

            TransactionStatus status = transactionManager.getTransaction(def);
            try {
                // 第一次读取
                Product p1 = sqlClient.findById(ProductFetcher.$.price(), PRODUCT_ID);
                pricesInTransaction1.add(p1.price());

                // 通知事务2可以开始
                latch1.countDown();

                // 等待事务2执行完毕
                latch2.await(5, TimeUnit.SECONDS);

                // 第二次读取 - 在READ_COMMITTED下，应该能看到事务2已提交的更改
                Product p2 = sqlClient.findById(ProductFetcher.$.price(), PRODUCT_ID);
                pricesInTransaction1.add(p2.price());

                // 提交事务
                transactionManager.commit(status);
            } catch (Exception e) {
                transactionManager.rollback(status);
                e.printStackTrace();
            }
        });

        // 第二个事务：短事务，更新价格并提交
        executor.submit(() -> {
            try {
                // 等待事务1执行第一次读取
                latch1.await(5, TimeUnit.SECONDS);

                DefaultTransactionDefinition def = new DefaultTransactionDefinition();
                def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

                TransactionStatus status = transactionManager.getTransaction(def);
                try {
                    // 读取当前价格
                    Product p = sqlClient.findById(ProductFetcher.$.price(), PRODUCT_ID);
                    pricesInTransaction2.add(p.price());

                    // 更新价格
                    Product updatedProduct = ProductDraft.$.produce(draft -> {
                        draft.setId(PRODUCT_ID);
                        draft.setPrice(new BigDecimal("499.99"));
                    });
                    sqlClient.save(updatedProduct);

                    // 提交事务
                    transactionManager.commit(status);

                    // 通知事务1继续执行
                    latch2.countDown();
                } catch (Exception e) {
                    transactionManager.rollback(status);
                    e.printStackTrace();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        // 等待所有任务完成
        executor.shutdown();
        executor.awaitTermination(10, TimeUnit.SECONDS);

        // 验证结果
        assertThat(pricesInTransaction1).hasSize(2);
        assertThat(pricesInTransaction2).hasSize(1);

        // 在READ_COMMITTED隔离级别下:
        // 1. 事务1的第一次读取应该看到初始价格
        assertThat(pricesInTransaction1.get(0)).isEqualTo(INITIAL_PRICE);

        // 2. 事务2应该看到初始价格
        assertThat(pricesInTransaction2.get(0)).isEqualTo(INITIAL_PRICE);

        // 3. 事务1的第二次读取应该看到事务2提交的新价格
        assertThat(pricesInTransaction1.get(1)).isEqualTo(new BigDecimal("499.99"));

    } finally {
        // 清理测试数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);
    }
}

@Test
@DisplayName("测试事务的持久性")
public void testTransactionDurability() {
    // 准备测试数据
    final String CATEGORY_ID = "tx-basic-05";
    final String PRODUCT_ID = "tx-prod-05";

    try {
        // 清理可能的测试残留数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);

        // 第一阶段：在事务中创建数据
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.execute(status -> {
            // 创建类别
            System.out.println("创建类别: " + CATEGORY_ID);
            Category category = createTestCategory(CATEGORY_ID, "持久性测试类别");

            // 创建商品
            System.out.println("创建商品: " + PRODUCT_ID);
            Product product = createTestProduct(PRODUCT_ID, "持久性测试商品", new BigDecimal("399.99"), CATEGORY_ID);

            System.out.println("提交事务");
            return null; // 此处返回null表示事务正常提交
        });

        // 第二阶段：验证数据持久化到数据库
        System.out.println("验证数据持久性");

        // 模拟应用重启后数据持久存在
        System.out.println("模拟应用重启后数据持久存在");

        // 以新事务查询，验证数据持久存在
        Product product = transactionTemplate.execute(status -> {
            return sqlClient.findById(Product.class, PRODUCT_ID);
        });

        Category category = transactionTemplate.execute(status -> {
            return sqlClient.findById(Category.class, CATEGORY_ID);
        });

        // 验证数据持久化正确
        assertThat(product).isNotNull();
        assertThat(product.name()).isEqualTo("持久性测试商品");
        assertThat(product.price()).isEqualTo(new BigDecimal("399.99"));
        assertThat(category).isNotNull();
        assertThat(category.name()).isEqualTo("持久性测试类别");

    } finally {
        // 清理测试数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);
    }
}

@Test
@DisplayName("测试不同的事务传播行为")
public void testTransactionPropagationBehaviors() {
    // 准备测试数据
    final String CATEGORY_ID = "tx-basic-04";
    final String PRODUCT_ID = "tx-prod-04";

    try {
        // 创建类别
        createTestCategory(CATEGORY_ID, "传播行为测试类别");

        // 1. 测试REQUIRED传播行为（默认行为）
        executeRequiredTransaction(PRODUCT_ID, CATEGORY_ID);

        // 验证商品已创建
        Product product = sqlClient.findById(ProductFetcher.$.name().price(), PRODUCT_ID);
        assertThat(product).isNotNull();
        assertThat(product.name()).isEqualTo("传播行为测试商品");

        // 2. 测试REQUIRES_NEW传播行为
        final BigDecimal NEW_PRICE = new BigDecimal("399.99");
        updateWithRequiresNewTransaction(PRODUCT_ID, NEW_PRICE);

        // 验证价格已更新
        product = sqlClient.findById(ProductFetcher.$.price(), PRODUCT_ID);
        assertThat(product.price()).isEqualTo(NEW_PRICE);

    } finally {
        // 清理测试数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);
    }
}

/**
 * 使用REQUIRED传播行为的事务方法
 */
@Transactional(propagation = Propagation.REQUIRED)
public void executeRequiredTransaction(String productId, String categoryId) {
    // 创建商品
    createTestProduct(productId, "传播行为测试商品", new BigDecimal("299.99"), categoryId);

    // 内部调用其他方法 - 应该使用当前事务
    validateProductCreation(productId, "传播行为测试商品");
}

/**
 * 内部验证方法 - 默认使用当前事务
 */
@Transactional(propagation = Propagation.REQUIRED)
public void validateProductCreation(String productId, String expectedName) {
    // 在当前事务中验证产品创建
    Product product = sqlClient.findById(ProductFetcher.$.name(), productId);
    assertThat(product).isNotNull();
    assertThat(product.name()).isEqualTo(expectedName);
}

/**
 * 使用REQUIRES_NEW传播行为的事务方法
 */
@Transactional(propagation = Propagation.REQUIRED)
public void updateWithRequiresNewTransaction(String productId, BigDecimal newPrice) {
    // 在当前事务中读取价格
    Product product = sqlClient.findById(ProductFetcher.$.price(), productId);
    System.out.println("当前事务中的价格: " + product.price());

    // 在新事务中更新价格 - 使用REQUIRES_NEW创建独立事务
    updatePriceInNewTransaction(productId, newPrice);

    // 此处在当前事务中可能看不到新事务中的更新，取决于隔离级别
}

/**
 * 使用REQUIRES_NEW创建独立事务
 */
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updatePriceInNewTransaction(String productId, BigDecimal newPrice) {
    // 更新商品价格
    Product updatedProduct = ProductDraft.$.produce(draft -> {
        draft.setId(productId);
        draft.setPrice(newPrice);
    });
    sqlClient.save(updatedProduct);
}

@Test
@DisplayName("测试事务超时设置")
public void testTransactionTimeout() {
    // 准备测试数据
    final String CATEGORY_ID = "tx-basic-06";
    final String PRODUCT_ID = "tx-prod-06";

    try {
        // 清理可能的测试残留数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);

        // 创建类别（事务外）
        System.out.println("创建类别: " + CATEGORY_ID);
        Category category = createTestCategory(CATEGORY_ID, "超时测试类别");

        // 演示如何配置事务超时
        System.out.println("演示事务超时配置");

        // 1. 使用TransactionTemplate
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.setTimeout(30); // 设置30秒超时
        System.out.println("TransactionTemplate已配置30秒超时");

        // 2. 使用TransactionDefinition
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setTimeout(10); // 设置10秒超时
        System.out.println("TransactionDefinition已配置10秒超时");

        // 3. 使用@Transactional注解（这里只是说明，不实际执行）
        System.out.println("@Transactional也可以设置超时: @Transactional(timeout = 30)");

        // 执行一个简单的事务，不实际测试超时
        TransactionStatus status = transactionManager.getTransaction(def);
        try {
            // 创建商品
            System.out.println("在配置了超时的事务中创建商品: " + PRODUCT_ID);
            Product product = createTestProduct(PRODUCT_ID, "超时测试商品", new BigDecimal("599.99"), CATEGORY_ID);

            // 正常提交事务
            System.out.println("提交事务");
            transactionManager.commit(status);

            // 验证商品已创建
            Product createdProduct = sqlClient.findById(Product.class, PRODUCT_ID);
            assertThat(createdProduct).isNotNull();
            assertThat(createdProduct.name()).isEqualTo("超时测试商品");

            System.out.println("商品创建成功，超时设置演示完毕");
        } catch (Exception e) {
            // 如果发生异常，回滚事务
            System.out.println("发生异常，回滚事务: " + e.getMessage());
            transactionManager.rollback(status);
            throw e;
        }

    } finally {
        // 清理测试数据
        cleanupTestData(PRODUCT_ID, CATEGORY_ID);
    }
}

@Transactional(readOnly = true)
public List<Product> findProductsByCategory(String categoryId) {
    return sqlClient.createQuery(ProductTable.$)
        .where(ProductTable.$.categoryId().eq(categoryId))
        .select(ProductTable.$)
        .execute();
}

@Service
public class ProductService {

    @Autowired
    private JSqlClient sqlClient;

    @Transactional
    public Product createProduct(ProductInput input, String categoryId) {
        // 验证类别存在
        Category category = sqlClient.findById(Category.class, categoryId);
        if (category == null) {
            throw new EntityNotFoundException("类别不存在: " + categoryId);
        }

        // 创建商品
        Product draft = ProductDraft.$.produce(p -> {
            p.setId(UUID.randomUUID().toString());
            p.setName(input.getName());
            p.setPrice(input.getPrice());
            p.setStock(input.getStock());
            p.setActive(true);
            p.setDescription(input.getDescription());
            p.setCategoryId(categoryId);
            p.setCreatedTime(LocalDateTime.now());
        });

        return sqlClient.save(draft).getModifiedEntity();
    }

    @Transactional(readOnly = true)
    public List<Product> findActiveProducts() {
        return sqlClient.createQuery(ProductTable.$)
            .where(ProductTable.$.active().eq(true))
            .select(ProductTable.$)
            .execute();
    }
}

@Service
public class InventoryService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    @Autowired
    private JSqlClient sqlClient;

    public void processInventoryAdjustments(List<InventoryAdjustment> adjustments) {
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);

        for (InventoryAdjustment adjustment : adjustments) {
            // 为每个库存调整创建单独的事务
            transactionTemplate.execute(status -> {
                try {
                    Product product = sqlClient.findById(Product.class, adjustment.getProductId());
                    if (product == null) {
                        // 忽略不存在的商品
                        return null;
                    }

                    // 更新库存
                    Product updatedProduct = ProductDraft.$.produce(draft -> {
                        draft.setId(product.id());
                        draft.setStock(product.stock() + adjustment.getQuantityChange());
                        draft.setModifiedTime(LocalDateTime.now());
                    });

                    sqlClient.save(updatedProduct);
                    return null;
                } catch (Exception e) {
                    // 记录错误并标记当前事务回滚
                    status.setRollbackOnly();
                    logInventoryError(adjustment, e);
                    return null;
                }
            });
        }
    }

    private void logInventoryError(InventoryAdjustment adjustment, Exception e) {
        // 记录错误日志
        System.err.println("调整库存时发生错误: " + adjustment.getProductId() + ", " + e.getMessage());
    }
}

// 伪代码：传统ORM框架中的缓存管理
@Service
public class ProductService {
    @Autowired
    private ProductRepository repository;

    @Autowired
    private CacheManager cacheManager;

    @Cacheable(key = "product:{#id}")
    public Product getProduct(String id) {
        return repository.findById(id).orElse(null);
    }

    @Transactional
    @CacheEvict(key = "product:{#product.id}")
    public void updateProduct(Product product) {
        // 尝试更新缓存
        try {
            repository.save(product);
            // 此时若事务回滚，缓存已被清除，造成不一致
            // 如果产品有关联对象，相关缓存可能未被清除
        } catch (Exception e) {
            // 处理异常，但缓存可能已被清除
            throw e;
        }
    }

    // 更复杂的场景：关联缓存
    @Cacheable(key = "product-with-details:{#id}")
    public ProductDetails getProductWithDetails(String id) {
        // 包含多层关联的查询
        // 如果任何关联对象更新，此缓存需要手动清除
    }
}

// L1缓存示例 - 同一事务内的读取一致性保证
@Transactional
public void updateProductPrice(String productId, BigDecimal newPrice) {
    // 第一次查询 - 从数据库加载
    Product product = sqlClient.findById(ProductFetcher.$.allScalarFields(), productId);
    BigDecimal oldPrice = product.price();

    // 更新价格
    Product updated = ProductDraft.$.produce(product, draft -> {
        draft.setPrice(newPrice);
    });
    sqlClient.save(updated);

    // 再次查询同一产品 - 从L1缓存获取，看到更新后的价格
    Product refreshed = sqlClient.findById(ProductFetcher.$.price(), productId);

    // 记录价格变更日志
    logPriceChange(productId, oldPrice, refreshed.price());

    // 在整个事务中，保证数据一致性，不会出现第二次查询看到旧价格的情况
}

// 配置L2缓存 - 使用Caffeine作为缓存实现
@Bean
public JSqlClient sqlClient(DataSource dataSource) {
    return JSqlClient.newBuilder()
        .setDataSource(dataSource)
        .setCacheFactory(
            new CacheFactory() {
                @Override
                public <K, V> Cache<K, V> createObjectCache(ImmutableType type) {
                    // 为不同实体类型配置不同的缓存策略
                    if (type.getName().equals("org.ljma.jimmer.samples.entity.Product")) {
                        // 产品对象缓存 - 较短的过期时间，因为价格可能频繁变化
                        return new CaffeineCache<>(
                            Caffeine.newBuilder()
                                .maximumSize(10_000)
                                .expireAfterWrite(Duration.ofMinutes(5))
                                .recordStats() // 启用统计
                                .build()
                        );
                    } else if (type.getName().equals("org.ljma.jimmer.samples.entity.Category")) {
                        // 类别对象缓存 - 较长的过期时间，因为类别不频繁更新
                        return new CaffeineCache<>(
                            Caffeine.newBuilder()
                                .maximumSize(1_000)
                                .expireAfterWrite(Duration.ofHours(1))
                                .build()
                        );
                    }

                    // 其他实体使用默认缓存配置
                    return new CaffeineCache<>(
                        Caffeine.newBuilder()
                            .maximumSize(5_000)
                            .expireAfterWrite(Duration.ofMinutes(30))
                            .build()
                    );
                }

                // 关联ID缓存配置
                @Override
                public <K, V> Cache<K, V> createAssociatedIdCache(ImmutableProp prop) {
                    // 为关联关系配置缓存
                    if (prop.getName().equals("category") && 
                        prop.getDeclaringType().getName().equals("org.ljma.jimmer.samples.entity.Product")) {
                        // 产品类别关系缓存
                        return new CaffeineCache<>(
                            Caffeine.newBuilder()
                                .maximumSize(10_000)
                                .expireAfterWrite(Duration.ofMinutes(10))
                                .build()
                        );
                    }

                    // 默认关联缓存配置
                    return new CaffeineCache<>(
                        Caffeine.newBuilder()
                            .maximumSize(20_000)
                            .expireAfterWrite(Duration.ofMinutes(20))
                            .build()
                    );
                }

                // 其他缓存工厂方法...
            }
        )
        .build();
}

@Test
@DisplayName("测试缓存自动失效 - 实体更新后")
public void testCacheInvalidationAfterUpdate() {
    // 第一次查询 - 加载并缓存
    Product originalProduct = sqlClient.findById(ProductFetcher.$.allScalarFields(), PRODUCT_ID_1);
    assertThat(originalProduct).isNotNull();
    assertThat(originalProduct.name()).isEqualTo("智能手机");
    BigDecimal originalPrice = originalProduct.price();

    // 更新产品价格
    BigDecimal newPrice = originalPrice.add(new BigDecimal("500.00"));
    Product updatedDraft = ProductDraft.$.produce(draft -> {
        draft.setId(PRODUCT_ID_1);
        draft.setPrice(newPrice);
    });
    sqlClient.save(updatedDraft);

    // 再次查询 - 应获取新价格（缓存已自动失效）
    Product updatedProduct = sqlClient.findById(ProductFetcher.$.price(), PRODUCT_ID_1);
    assertThat(updatedProduct).isNotNull();
    assertThat(updatedProduct.price()).isEqualTo(newPrice);
}

// 配置L3缓存 - 使用Redis作为分布式缓存
@Bean
public JSqlClient sqlClient(DataSource dataSource, StringRedisTemplate redisTemplate) {
    return JSqlClient.newBuilder()
        .setDataSource(dataSource)
        .setCacheFactory(
            new CacheFactory() {
                @Override
                public <K, V> Cache<K, V> createObjectCache(ImmutableType type) {
                    // 创建多级缓存，结合本地和分布式缓存的优势
                    return new MultiLevelCache<>(
                        // L2: 本地Caffeine缓存，低延迟
                        new CaffeineCache<>(
                            Caffeine.newBuilder()
                                .maximumSize(1_000)
                                .expireAfterWrite(Duration.ofMinutes(5))
                                .build()
                        ),
                        // L3: Redis分布式缓存，集群共享
                        new RedisCache<>(
                            redisTemplate,
                            // 缓存键前缀，避免冲突
                            "entity:" + type.getName() + ":",
                            // 过期时间
                            Duration.ofMinutes(30)
                        )
                    );
                }

                // 其他缓存工厂方法...
            }
        )
        .build();
}

@Test
@DisplayName("测试缓存命中与未命中情况")
public void testCacheHitAndMiss() {
    // 第一次查询 - 缓存未命中
    QueryResult<Product> firstQuery = measureQueryTime(() -> 
        sqlClient.findById(ProductFetcher.$.name().price(), PRODUCT_ID_1)
    );

    Product product = firstQuery.getResult();
    assertThat(product).isNotNull();
    assertThat(product.name()).isEqualTo("智能手机");

    // 第二次查询同一ID - 缓存命中
    QueryResult<Product> secondQuery = measureQueryTime(() -> 
        sqlClient.findById(ProductFetcher.$.name().price(), PRODUCT_ID_1)
    );

    // 打印查询时间
    System.out.println("First query time (cache miss): " + firstQuery.getExecutionTimeNs() + " ns");
    System.out.println("Second query time (cache hit): " + secondQuery.getExecutionTimeNs() + " ns");
}

@Configuration
public class JimmerConfiguration {

    @Bean
    public JSqlClient sqlClient(DataSource dataSource) {
        return JSqlClient.newBuilder()
            .setDataSource(dataSource)
            .setCacheFactory(createCacheFactory())
            .build();
    }

    private CacheFactory createCacheFactory() {
        return new CacheFactory() {
            // 对象缓存 - 缓存完整实体
            @Override
            public <K, V> Cache<K, V> createObjectCache(ImmutableType type) {
                String typeName = type.getName();

                // 根据实体类型设置不同的缓存策略
                if (typeName.endsWith("Product")) {
                    return createProductCache();
                } else if (typeName.endsWith("Category")) {
                    return createCategoryCache();
                } else if (typeName.endsWith("Inventory")) {
                    return createInventoryCache();
                }

                // 默认缓存策略
                return createDefaultCache();
            }

            // 关联ID缓存 - 缓存多对一关联关系
            @Override
            public <K, V> Cache<K, V> createAssociatedIdCache(ImmutableProp prop) {
                // 可以根据属性名称和拥有者类型定制策略
                String propName = prop.getName();
                String ownerType = prop.getDeclaringType().getName();

                if (propName.equals("category") && ownerType.endsWith("Product")) {
                    // 产品-类别关联的特殊缓存策略
                    return new CaffeineCache<>(
                        Caffeine.newBuilder()
                            .maximumSize(20_000)
                            .expireAfterWrite(Duration.ofMinutes(30))
                            .build()
                    );
                }

                // 其它关联关系的默认策略
                return createDefaultAssociationCache();
            }

            // 关联ID列表缓存 - 缓存一对多关联关系
            @Override
            public <K, V> Cache<K, V> createAssociatedIdListCache(ImmutableProp prop) {
                String propName = prop.getName();

                if (propName.equals("products")) {
                    // 类别-产品一对多关系缓存
                    return new CaffeineCache<>(
                        Caffeine.newBuilder()
                            .maximumSize(5_000)
                            .expireAfterWrite(Duration.ofMinutes(15))
                            .build()
                    );
                }

                return createDefaultCollectionCache();
            }

            // 辅助方法 - 创建不同类型的缓存...
            private <K, V> Cache<K, V> createProductCache() {
                // 产品实体缓存 - 使用较短的过期时间
                return new CaffeineCache<>(
                    Caffeine.newBuilder()
                        .maximumSize(50_000)
                        .expireAfterWrite(Duration.ofMinutes(10))
                        .build()
                );
            }

            private <K, V> Cache<K, V> createCategoryCache() {
                // 类别实体缓存 - 更长的过期时间，因为类别很少变化
                return new CaffeineCache<>(
                    Caffeine.newBuilder()
                        .maximumSize(1_000)
                        .expireAfterWrite(Duration.ofHours(2))
                        .build()
                );
            }

            private <K, V> Cache<K, V> createInventoryCache() {
                // 库存实体 - 极短的过期时间，或返回null禁用缓存
                return null; // 返回null表示不缓存此类型
            }

            // 默认缓存策略
            private <K, V> Cache<K, V> createDefaultCache() {
                return new CaffeineCache<>(
                    Caffeine.newBuilder()
                        .maximumSize(10_000)
                        .expireAfterWrite(Duration.ofMinutes(30))
                        .build()
                );
            }

            // 其他辅助方法...
        };
    }
}