/**
 * 使用基本JDBC批處理示例
 */
public void basicJdbcBatch(Connection connection, List<Employee> employees) throws SQLException {
    String sql = "INSERT INTO employees (id, name, salary, department_id) VALUES (?, ?, ?, ?)";
    try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
        // 關(guān)閉自動提交，提高批處理效率
        connection.setAutoCommit(false);
        for (Employee employee : employees) {
            pstmt.setLong(1, employee.getId());
            pstmt.setString(2, employee.getName());
            pstmt.setDouble(3, employee.getSalary());
            pstmt.setLong(4, employee.getDepartmentId());
            // 將語句添加到批處理
            pstmt.addBatch();
        }
        // 執(zhí)行批處理
        int[] updateCounts = pstmt.executeBatch();
        // 提交事務(wù)
        connection.commit();
    }
}

/**
 * Hibernate批處理優(yōu)化配置與實現(xiàn)
 */
// 配置批處理大?。ㄔ趐ersistence.xml或hibernate.cfg.xml中）
// <property name="hibernate.jdbc.batch_size" value="50" />
// <property name="hibernate.order_inserts" value="true" />
// <property name="hibernate.order_updates" value="true" />
@Service
@Transactional
public class EmployeeBatchService {
    private final SessionFactory sessionFactory;
    public EmployeeBatchService(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
    public void batchInsertEmployees(List<Employee> employees) {
        Session session = sessionFactory.getCurrentSession();
        final int batchSize = 50;
        for (int i = 0; i < employees.size(); i++) {
            session.persist(employees.get(i));
            // 每處理batchSize條數(shù)據(jù)，刷新會話并清除緩存
            if (i > 0 && i % batchSize == 0) {
                session.flush();
                session.clear();
            }
        }
    }
}

/**
 * JPA批處理實現(xiàn)示例
 */
@Service
@Transactional
public class ProductBatchService {
    @PersistenceContext
    private EntityManager entityManager;
    public void batchUpdateProducts(List<Product> products) {
        final int batchSize = 30;
        for (int i = 0; i < products.size(); i++) {
            // 合并更新后的實體
            entityManager.merge(products.get(i));
            // 階段性刷新和清理持久化上下文
            if (i > 0 && i % batchSize == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
    }
    // 使用JPA 2.1批量更新功能
    public int updateProductPrices(String category, double increasePercentage) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaUpdate<Product> update = cb.createCriteriaUpdate(Product.class);
        Root<Product> root = update.from(Product.class);
        // 設(shè)置更新表達式：price = price * (1 + increasePercentage)
        update.set(root.get("price"), 
                  cb.prod(root.get("price"), 
                         cb.sum(1.0, increasePercentage)));
        // 添加條件：category = :category
        update.where(cb.equal(root.get("category"), category));
        // 執(zhí)行批量更新并返回影響的行數(shù)
        return entityManager.createQuery(update).executeUpdate();
    }
}

/**
 * 批量插入優(yōu)化示例
 */
@Service
public class DataImportService {
    private final JdbcTemplate jdbcTemplate;
    public DataImportService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    @Transactional
    public void importCustomers(List<Customer> customers) {
        jdbcTemplate.batchUpdate(
            "INSERT INTO customers (id, name, email, created_date) VALUES (?, ?, ?, ?)",
            new BatchPreparedStatementSetter() {
                @Override
                public void setValues(PreparedStatement ps, int i) throws SQLException {
                    Customer customer = customers.get(i);
                    ps.setLong(1, customer.getId());
                    ps.setString(2, customer.getName());
                    ps.setString(3, customer.getEmail());
                    ps.setTimestamp(4, new Timestamp(customer.getCreatedDate().getTime()));
                }
                @Override
                public int getBatchSize() {
                    return customers.size();
                }
            }
        );
    }
    // 使用并行處理優(yōu)化大批量插入
    public void importLargeDataSet(List<Customer> customers) {
        final int batchSize = 1000;
        // 將數(shù)據(jù)分割成多個批次
        List<List<Customer>> batches = new ArrayList<>();
        for (int i = 0; i < customers.size(); i += batchSize) {
            batches.add(customers.subList(i, 
                        Math.min(i + batchSize, customers.size())));
        }
        // 并行處理每個批次
        batches.parallelStream().forEach(batch -> {
            importCustomers(batch);
        });
    }
}

/**
 * 批量更新與刪除策略示例
 */
@Service
@Transactional
public class InventoryService {
    @PersistenceContext
    private EntityManager entityManager;
    // 使用JPQL進行批量更新
    public int deactivateExpiredProducts(Date expirationDate) {
        String jpql = "UPDATE Product p SET p.active = false " +
                     "WHERE p.expirationDate < :expirationDate";
        return entityManager.createQuery(jpql)
                .setParameter("expirationDate", expirationDate)
                .executeUpdate();
    }
    // 使用原生SQL進行高性能批量刪除
    public int purgeOldTransactions(Date cutoffDate) {
        // 注意：直接執(zhí)行SQL繞過了ORM緩存，需要注意緩存一致性
        String sql = "DELETE FROM transactions WHERE transaction_date < ?";
        Query query = entityManager.createNativeQuery(sql)
                .setParameter(1, cutoffDate);
        // 清除一級緩存以避免緩存不一致
        entityManager.flush();
        entityManager.clear();
        return query.executeUpdate();
    }
    // 批量處理已加載實體
    public void updateProductInventory(List<ProductInventory> inventories) {
        Session session = entityManager.unwrap(Session.class);
        final int batchSize = 50;
        for (int i = 0; i < inventories.size(); i++) {
            ProductInventory inventory = inventories.get(i);
            // 更新庫存
            inventory.setQuantity(inventory.getQuantity() - inventory.getReserved());
            inventory.setReserved(0);
            inventory.setLastUpdated(new Date());
            session.update(inventory);
            if (i > 0 && i % batchSize == 0) {
                session.flush();
                session.clear();
            }
        }
    }
}

/**
 * 批量讀取優(yōu)化示例
 */
@Service
public class ReportService {
    @PersistenceContext
    private EntityManager entityManager;
    // 使用分頁查詢處理大數(shù)據(jù)集
    public void processLargeDataSet(Consumer<List<Order>> processor) {
        final int pageSize = 500;
        int pageNum = 0;
        List<Order> orders;
        do {
            // 執(zhí)行分頁查詢
            TypedQuery<Order> query = entityManager.createQuery(
                    "SELECT o FROM Order o WHERE o.status = :status ORDER BY o.id", 
                    Order.class);
            query.setParameter("status", OrderStatus.COMPLETED);
            query.setFirstResult(pageNum * pageSize);
            query.setMaxResults(pageSize);
            orders = query.getResultList();
            // 處理當前頁數(shù)據(jù)
            if (!orders.isEmpty()) {
                processor.accept(orders);
            }
            // 清除一級緩存，防止內(nèi)存泄漏
            entityManager.clear();
            pageNum++;
        } while (!orders.isEmpty());
    }
    // 優(yōu)化一對多關(guān)系查詢
    public List<Department> getDepartmentsWithEmployees() {
        // 使用JOIN FETCH避免N+1查詢問題
        String jpql = "SELECT DISTINCT d FROM Department d " +
                     "LEFT JOIN FETCH d.employees " +
                     "ORDER BY d.name";
        return entityManager.createQuery(jpql, Department.class).getResultList();
    }
    // 使用投影優(yōu)化只需部分字段的查詢
    public List<OrderSummary> getOrderSummaries(Date startDate, Date endDate) {
        String jpql = "SELECT NEW com.example.OrderSummary(o.id, o.orderDate, " +
                     "o.customer.name, o.totalAmount) " +
                     "FROM Order o " +
                     "WHERE o.orderDate BETWEEN :startDate AND :endDate";
        return entityManager.createQuery(jpql, OrderSummary.class)
                .setParameter("startDate", startDate)
                .setParameter("endDate", endDate)
                .getResultList();
    }
}

/**
 * 性能監(jiān)控與調(diào)優(yōu)示例
 */
@Configuration
public class BatchPerformanceConfig {
    // 配置Hibernate統(tǒng)計信息收集
    @Bean
    public Statistics hibernateStatistics(EntityManagerFactory emf) {
        SessionFactory sessionFactory = emf.unwrap(SessionFactory.class);
        Statistics statistics = sessionFactory.getStatistics();
        statistics.setStatisticsEnabled(true);
        return statistics;
    }
}
@Service
public class PerformanceMonitorService {
    private final Statistics hibernateStatistics;
    public PerformanceMonitorService(Statistics hibernateStatistics) {
        this.hibernateStatistics = hibernateStatistics;
    }
    // 分析批處理性能
    public BatchPerformanceReport analyzeBatchPerformance() {
        BatchPerformanceReport report = new BatchPerformanceReport();
        // 收集Hibernate統(tǒng)計信息
        report.setEntityInsertCount(hibernateStatistics.getEntityInsertCount());
        report.setEntityUpdateCount(hibernateStatistics.getEntityUpdateCount());
        report.setEntityDeleteCount(hibernateStatistics.getEntityDeleteCount());
        report.setQueryExecutionCount(hibernateStatistics.getQueryExecutionCount());
        report.setQueryExecutionMaxTime(hibernateStatistics.getQueryExecutionMaxTime());
        report.setQueryCachePutCount(hibernateStatistics.getQueryCachePutCount());
        report.setQueryCacheHitCount(hibernateStatistics.getQueryCacheHitCount());
        // 計算關(guān)鍵性能指標
        report.setAverageQueryTime(calculateAverageQueryTime());
        report.setEffectiveBatchSize(calculateEffectiveBatchSize());
        // 生成優(yōu)化建議
        report.setOptimizationSuggestions(generateOptimizationSuggestions(report));
        return report;
    }
    // 性能優(yōu)化測試
    public void runPerformanceBenchmark() {
        // 測試不同批處理大小
        Map<Integer, Long> batchSizeResults = new HashMap<>();
        for (int batchSize : Arrays.asList(10, 20, 50, 100, 200)) {
            hibernateStatistics.clear();
            long startTime = System.currentTimeMillis();
            // 執(zhí)行測試批處理操作
            // ...
            long duration = System.currentTimeMillis() - startTime;
            batchSizeResults.put(batchSize, duration);
        }
        // 分析并找出最佳批處理大小
        Integer optimalBatchSize = batchSizeResults.entrySet().stream()
                .min(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey)
                .orElse(50);
        // 更新系統(tǒng)配置為最佳批處理大小
        // ...
    }
}