第150集怎么产生1条binlogJava实战

/**
 * binlog生成配置类
 * @author 运维实战
 */
@Configuration
@EnableConfigurationProperties(BinlogGenerationProperties.class)
public class BinlogGenerationConfig {
    
    @Autowired
    private BinlogGenerationProperties properties;
    
    /**
     * binlog生成服务
     * @return binlog生成服务
     */
    @Bean
    public BinlogGenerationService binlogGenerationService() {
        return new BinlogGenerationService();
    }
    
    /**
     * binlog监控服务
     * @return binlog监控服务
     */
    @Bean
    public BinlogMonitorService binlogMonitorService() {
        return new BinlogMonitorService();
    }
    
    /**
     * binlog优化服务
     * @return binlog优化服务
     */
    @Bean
    public BinlogOptimizeService binlogOptimizeService() {
        return new BinlogOptimizeService();
    }
    
    private static final Logger logger = LoggerFactory.getLogger(BinlogGenerationConfig.class);
}

/**
 * binlog生成属性配置
 * @author 运维实战
 */
@Data
@ConfigurationProperties(prefix = "mysql.binlog.generation")
public class BinlogGenerationProperties {
    
    /**
     * 是否启用binlog生成优化
     */
    private boolean enableBinlogOptimization = true;
    
    /**
     * 单条binlog生成策略
     */
    private String singleBinlogStrategy = "TRANSACTIONAL";
    
    /**
     * 事务超时时间（毫秒）
     */
    private long transactionTimeoutMs = 5000;
    
    /**
     * 是否启用批量操作合并
     */
    private boolean enableBatchOperationMerge = true;
    
    /**
     * 批量操作合并阈值
     */
    private int batchOperationMergeThreshold = 100;
    
    /**
     * 是否启用DDL操作优化
     */
    private boolean enableDDLOptimization = true;
    
    /**
     * 是否启用存储过程优化
     */
    private boolean enableStoredProcedureOptimization = true;
    
    /**
     * 是否启用监控
     */
    private boolean enableMonitor = true;
    
    /**
     * 监控间隔（毫秒）
     */
    private long monitorInterval = 30000;
    
    /**
     * 是否启用告警
     */
    private boolean enableAlert = true;
    
    /**
     * binlog数量告警阈值
     */
    private int binlogCountAlertThreshold = 10;
}

/**
 * 基础binlog生成服务
 * @author 运维实战
 */
@Service
public class BinlogGenerationService {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Autowired
    private BinlogGenerationProperties properties;
    
    @Autowired
    private BinlogMonitorService binlogMonitorService;
    
    @Autowired
    private BinlogOptimizeService binlogOptimizeService;
    
    private static final Logger logger = LoggerFactory.getLogger(BinlogGenerationService.class);
    
    /**
     * 产生1条binlog的插入操作
     * @param tableName 表名
     * @param data 数据
     * @return 插入结果
     */
    public BinlogGenerationResult generateSingleBinlogInsert(String tableName, Map<String, Object> data) {
        logger.info("开始产生1条binlog的插入操作，表名: {}", tableName);
        
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("INSERT");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 获取binlog生成策略
            BinlogGenerationStrategy strategy = binlogOptimizeService.getStrategy("INSERT", 1);
            
            // 执行单条binlog插入
            result = executeSingleBinlogInsert(tableName, data, strategy);
            
            // 记录binlog生成指标
            binlogMonitorService.recordBinlogGeneration(tableName, "INSERT", 1, result.getSuccess());
            
            logger.info("产生1条binlog的插入操作完成，表名: {}, 成功: {}, 耗时: {}ms", 
                tableName, result.getSuccess(), result.getDuration());
            
            return result;
            
        } catch (Exception e) {
            logger.error("产生1条binlog的插入操作异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("产生1条binlog的插入操作异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 产生1条binlog的更新操作
     * @param tableName 表名
     * @param data 数据
     * @param whereCondition 条件
     * @return 更新结果
     */
    public BinlogGenerationResult generateSingleBinlogUpdate(String tableName, Map<String, Object> data, Map<String, Object> whereCondition) {
        logger.info("开始产生1条binlog的更新操作，表名: {}", tableName);
        
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("UPDATE");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 获取binlog生成策略
            BinlogGenerationStrategy strategy = binlogOptimizeService.getStrategy("UPDATE", 1);
            
            // 执行单条binlog更新
            result = executeSingleBinlogUpdate(tableName, data, whereCondition, strategy);
            
            // 记录binlog生成指标
            binlogMonitorService.recordBinlogGeneration(tableName, "UPDATE", 1, result.getSuccess());
            
            logger.info("产生1条binlog的更新操作完成，表名: {}, 成功: {}, 耗时: {}ms", 
                tableName, result.getSuccess(), result.getDuration());
            
            return result;
            
        } catch (Exception e) {
            logger.error("产生1条binlog的更新操作异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("产生1条binlog的更新操作异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 产生1条binlog的删除操作
     * @param tableName 表名
     * @param whereCondition 条件
     * @return 删除结果
     */
    public BinlogGenerationResult generateSingleBinlogDelete(String tableName, Map<String, Object> whereCondition) {
        logger.info("开始产生1条binlog的删除操作，表名: {}", tableName);
        
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("DELETE");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 获取binlog生成策略
            BinlogGenerationStrategy strategy = binlogOptimizeService.getStrategy("DELETE", 1);
            
            // 执行单条binlog删除
            result = executeSingleBinlogDelete(tableName, whereCondition, strategy);
            
            // 记录binlog生成指标
            binlogMonitorService.recordBinlogGeneration(tableName, "DELETE", 1, result.getSuccess());
            
            logger.info("产生1条binlog的删除操作完成，表名: {}, 成功: {}, 耗时: {}ms", 
                tableName, result.getSuccess(), result.getDuration());
            
            return result;
            
        } catch (Exception e) {
            logger.error("产生1条binlog的删除操作异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("产生1条binlog的删除操作异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 通过事务产生1条binlog
     * @param operations 操作列表
     * @return 事务结果
     */
    public BinlogGenerationResult generateSingleBinlogByTransaction(List<DatabaseOperation> operations) {
        logger.info("开始通过事务产生1条binlog，操作数量: {}", operations.size());
        
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setOperationType("TRANSACTION");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 获取binlog生成策略
            BinlogGenerationStrategy strategy = binlogOptimizeService.getStrategy("TRANSACTION", operations.size());
            
            // 执行事务操作
            result = executeTransactionalOperation(operations, strategy);
            
            // 记录binlog生成指标
            binlogMonitorService.recordBinlogGeneration("TRANSACTION", "TRANSACTION", 1, result.getSuccess());
            
            logger.info("通过事务产生1条binlog完成，操作数量: {}, 成功: {}, 耗时: {}ms", 
                operations.size(), result.getSuccess(), result.getDuration());
            
            return result;
            
        } catch (Exception e) {
            logger.error("通过事务产生1条binlog异常", e);
            result.setSuccess(false);
            result.setError("通过事务产生1条binlog异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行单条binlog插入
     * @param tableName 表名
     * @param data 数据
     * @param strategy 策略
     * @return 插入结果
     */
    private BinlogGenerationResult executeSingleBinlogInsert(String tableName, Map<String, Object> data, BinlogGenerationStrategy strategy) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("INSERT");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            if (properties.isEnableBinlogOptimization() && "TRANSACTIONAL".equals(strategy.getStrategy())) {
                // 使用事务确保单条binlog
                result = executeTransactionalInsert(tableName, data);
            } else {
                // 使用普通插入
                result = executeNormalInsert(tableName, data);
            }
            
            result.setEndTime(System.currentTimeMillis());
            return result;
            
        } catch (Exception e) {
            logger.error("执行单条binlog插入异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("执行单条binlog插入异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行事务插入
     * @param tableName 表名
     * @param data 数据
     * @return 插入结果
     */
    private BinlogGenerationResult executeTransactionalInsert(String tableName, Map<String, Object> data) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("INSERT");
        result.setStartTime(System.currentTimeMillis());
        
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.setTimeout((int) (properties.getTransactionTimeoutMs() / 1000));
        
        try {
            Boolean success = transactionTemplate.execute(status -> {
                try {
                    // 构建插入SQL
                    String sql = buildInsertSQL(tableName, data);
                    
                    // 执行插入
                    int rowsAffected = jdbcTemplate.update(sql, data.values().toArray());
                    
                    return rowsAffected > 0;
                    
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw new RuntimeException("事务插入失败", e);
                }
            });
            
            result.setSuccess(success);
            result.setRowsAffected(success ? 1 : 0);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("事务插入异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("事务插入异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行普通插入
     * @param tableName 表名
     * @param data 数据
     * @return 插入结果
     */
    private BinlogGenerationResult executeNormalInsert(String tableName, Map<String, Object> data) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("INSERT");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 构建插入SQL
            String sql = buildInsertSQL(tableName, data);
            
            // 执行插入
            int rowsAffected = jdbcTemplate.update(sql, data.values().toArray());
            
            result.setSuccess(rowsAffected > 0);
            result.setRowsAffected(rowsAffected);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("普通插入异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("普通插入异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行单条binlog更新
     * @param tableName 表名
     * @param data 数据
     * @param whereCondition 条件
     * @param strategy 策略
     * @return 更新结果
     */
    private BinlogGenerationResult executeSingleBinlogUpdate(String tableName, Map<String, Object> data, Map<String, Object> whereCondition, BinlogGenerationStrategy strategy) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("UPDATE");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            if (properties.isEnableBinlogOptimization() && "TRANSACTIONAL".equals(strategy.getStrategy())) {
                // 使用事务确保单条binlog
                result = executeTransactionalUpdate(tableName, data, whereCondition);
            } else {
                // 使用普通更新
                result = executeNormalUpdate(tableName, data, whereCondition);
            }
            
            result.setEndTime(System.currentTimeMillis());
            return result;
            
        } catch (Exception e) {
            logger.error("执行单条binlog更新异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("执行单条binlog更新异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行事务更新
     * @param tableName 表名
     * @param data 数据
     * @param whereCondition 条件
     * @return 更新结果
     */
    private BinlogGenerationResult executeTransactionalUpdate(String tableName, Map<String, Object> data, Map<String, Object> whereCondition) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("UPDATE");
        result.setStartTime(System.currentTimeMillis());
        
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.setTimeout((int) (properties.getTransactionTimeoutMs() / 1000));
        
        try {
            Integer rowsAffected = transactionTemplate.execute(status -> {
                try {
                    // 构建更新SQL
                    String sql = buildUpdateSQL(tableName, data, whereCondition);
                    
                    // 执行更新
                    int affected = jdbcTemplate.update(sql, data.values().toArray());
                    
                    return affected;
                    
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw new RuntimeException("事务更新失败", e);
                }
            });
            
            result.setSuccess(rowsAffected > 0);
            result.setRowsAffected(rowsAffected);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("事务更新异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("事务更新异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行普通更新
     * @param tableName 表名
     * @param data 数据
     * @param whereCondition 条件
     * @return 更新结果
     */
    private BinlogGenerationResult executeNormalUpdate(String tableName, Map<String, Object> data, Map<String, Object> whereCondition) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("UPDATE");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 构建更新SQL
            String sql = buildUpdateSQL(tableName, data, whereCondition);
            
            // 执行更新
            int rowsAffected = jdbcTemplate.update(sql, data.values().toArray());
            
            result.setSuccess(rowsAffected > 0);
            result.setRowsAffected(rowsAffected);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("普通更新异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("普通更新异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行单条binlog删除
     * @param tableName 表名
     * @param whereCondition 条件
     * @param strategy 策略
     * @return 删除结果
     */
    private BinlogGenerationResult executeSingleBinlogDelete(String tableName, Map<String, Object> whereCondition, BinlogGenerationStrategy strategy) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("DELETE");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            if (properties.isEnableBinlogOptimization() && "TRANSACTIONAL".equals(strategy.getStrategy())) {
                // 使用事务确保单条binlog
                result = executeTransactionalDelete(tableName, whereCondition);
            } else {
                // 使用普通删除
                result = executeNormalDelete(tableName, whereCondition);
            }
            
            result.setEndTime(System.currentTimeMillis());
            return result;
            
        } catch (Exception e) {
            logger.error("执行单条binlog删除异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("执行单条binlog删除异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行事务删除
     * @param tableName 表名
     * @param whereCondition 条件
     * @return 删除结果
     */
    private BinlogGenerationResult executeTransactionalDelete(String tableName, Map<String, Object> whereCondition) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("DELETE");
        result.setStartTime(System.currentTimeMillis());
        
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.setTimeout((int) (properties.getTransactionTimeoutMs() / 1000));
        
        try {
            Integer rowsAffected = transactionTemplate.execute(status -> {
                try {
                    // 构建删除SQL
                    String sql = buildDeleteSQL(tableName, whereCondition);
                    
                    // 执行删除
                    int affected = jdbcTemplate.update(sql, whereCondition.values().toArray());
                    
                    return affected;
                    
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw new RuntimeException("事务删除失败", e);
                }
            });
            
            result.setSuccess(rowsAffected > 0);
            result.setRowsAffected(rowsAffected);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("事务删除异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("事务删除异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行普通删除
     * @param tableName 表名
     * @param whereCondition 条件
     * @return 删除结果
     */
    private BinlogGenerationResult executeNormalDelete(String tableName, Map<String, Object> whereCondition) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setTableName(tableName);
        result.setOperationType("DELETE");
        result.setStartTime(System.currentTimeMillis());
        
        try {
            // 构建删除SQL
            String sql = buildDeleteSQL(tableName, whereCondition);
            
            // 执行删除
            int rowsAffected = jdbcTemplate.update(sql, whereCondition.values().toArray());
            
            result.setSuccess(rowsAffected > 0);
            result.setRowsAffected(rowsAffected);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("普通删除异常，表名: {}", tableName, e);
            result.setSuccess(false);
            result.setError("普通删除异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 执行事务操作
     * @param operations 操作列表
     * @param strategy 策略
     * @return 事务结果
     */
    private BinlogGenerationResult executeTransactionalOperation(List<DatabaseOperation> operations, BinlogGenerationStrategy strategy) {
        BinlogGenerationResult result = new BinlogGenerationResult();
        result.setOperationType("TRANSACTION");
        result.setStartTime(System.currentTimeMillis());
        
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.setTimeout((int) (properties.getTransactionTimeoutMs() / 1000));
        
        try {
            Integer totalRowsAffected = transactionTemplate.execute(status -> {
                try {
                    int totalAffected = 0;
                    
                    for (DatabaseOperation operation : operations) {
                        int affected = 0;
                        
                        switch (operation.getType()) {
                            case "INSERT":
                                affected = jdbcTemplate.update(operation.getSql(), operation.getParams());
                                break;
                            case "UPDATE":
                                affected = jdbcTemplate.update(operation.getSql(), operation.getParams());
                                break;
                            case "DELETE":
                                affected = jdbcTemplate.update(operation.getSql(), operation.getParams());
                                break;
                        }
                        
                        totalAffected += affected;
                    }
                    
                    return totalAffected;
                    
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw new RuntimeException("事务操作失败", e);
                }
            });
            
            result.setSuccess(totalRowsAffected > 0);
            result.setRowsAffected(totalRowsAffected);
            result.setEndTime(System.currentTimeMillis());
            
            return result;
            
        } catch (Exception e) {
            logger.error("事务操作异常", e);
            result.setSuccess(false);
            result.setError("事务操作异常: " + e.getMessage());
            result.setEndTime(System.currentTimeMillis());
            return result;
        }
    }
    
    /**
     * 构建插入SQL
     * @param tableName 表名
     * @param data 数据
     * @return SQL语句
     */
    private String buildInsertSQL(String tableName, Map<String, Object> data) {
        StringBuilder sql = new StringBuilder();
        sql.append("INSERT INTO ").append(tableName).append(" (");
        
        // 构建列名
        StringJoiner columns = new StringJoiner(", ");
        for (String column : data.keySet()) {
            columns.add(column);
        }
        sql.append(columns.toString()).append(") VALUES (");
        
        // 构建占位符
        StringJoiner placeholders = new StringJoiner(", ");
        for (int i = 0; i < data.size(); i++) {
            placeholders.add("?");
        }
        sql.append(placeholders.toString()).append(")");
        
        return sql.toString();
    }
    
    /**
     * 构建更新SQL
     * @param tableName 表名
     * @param data 数据
     * @param whereCondition 条件
     * @return SQL语句
     */
    private String buildUpdateSQL(String tableName, Map<String, Object> data, Map<String, Object> whereCondition) {
        StringBuilder sql = new StringBuilder();
        sql.append("UPDATE ").append(tableName).append(" SET ");
        
        // 构建SET子句
        StringJoiner setClause = new StringJoiner(", ");
        for (String column : data.keySet()) {
            setClause.add(column + " = ?");
        }
        sql.append(setClause.toString());
        
        // 构建WHERE子句
        if (!whereCondition.isEmpty()) {
            sql.append(" WHERE ");
            StringJoiner whereClause = new StringJoiner(" AND ");
            for (String column : whereCondition.keySet()) {
                whereClause.add(column + " = ?");
            }
            sql.append(whereClause.toString());
        }
        
        return sql.toString();
    }
    
    /**
     * 构建删除SQL
     * @param tableName 表名
     * @param whereCondition 条件
     * @return SQL语句
     */
    private String buildDeleteSQL(String tableName, Map<String, Object> whereCondition) {
        StringBuilder sql = new StringBuilder();
        sql.append("DELETE FROM ").append(tableName);
        
        // 构建WHERE子句
        if (!whereCondition.isEmpty()) {
            sql.append(" WHERE ");
            StringJoiner whereClause = new StringJoiner(" AND ");
            for (String column : whereCondition.keySet()) {
                whereClause.add(column + " = ?");
            }
            sql.append(whereClause.toString());
        }
        
        return sql.toString();
    }
    
    @Autowired
    private PlatformTransactionManager transactionManager;
}

/**
 * binlog生成结果类
 * @author 运维实战
 */
@Data
public class BinlogGenerationResult {
    
    private boolean success;
    private String tableName;
    private String operationType;
    private int rowsAffected;
    private String error;
    private long startTime;
    private long endTime;
    
    public BinlogGenerationResult() {
        this.success = false;
        this.rowsAffected = 0;
    }
    
    /**
     * 获取处理耗时
     * @return 处理耗时（毫秒）
     */
    public long getDuration() {
        return endTime - startTime;
    }
    
    /**
     * 是否成功
     * @return 是否成功
     */
    public boolean isSuccess() {
        return success;
    }
}

/**
 * binlog生成策略类
 * @author 运维实战
 */
@Data
public class BinlogGenerationStrategy {
    
    private String strategy;
    private String description;
    private int operationCount;
    private long estimatedBinlogCount;
    private long estimatedDuration;
    private long timestamp;
    
    public BinlogGenerationStrategy() {
        this.timestamp = System.currentTimeMillis();
    }
    
    /**
     * 获取binlog减少率
     * @return binlog减少率
     */
    public double getBinlogReductionRate() {
        if (operationCount == 0) return 0.0;
        return (double) (operationCount - estimatedBinlogCount) / operationCount * 100;
    }
}

/**
 * 数据库操作类
 * @author 运维实战
 */
@Data
public class DatabaseOperation {
    
    private String type;
    private String sql;
    private Object[] params;
    
    public DatabaseOperation() {}
    
    public DatabaseOperation(String type, String sql, Object[] params) {
        this.type = type;
        this.sql = sql;
        this.params = params;
    }
}

/**
 * binlog监控服务
 * @author 运维实战
 */
@Service
public class BinlogMonitorService {
    
    private final AtomicLong totalBinlogGenerations = new AtomicLong(0);
    private final AtomicLong totalSuccessfulGenerations = new AtomicLong(0);
    private final AtomicLong totalFailedGenerations = new AtomicLong(0);
    private final AtomicLong totalBinlogCount = new AtomicLong(0);
    
    private long lastResetTime = System.currentTimeMillis();
    private final long resetInterval = 300000; // 5分钟重置一次
    
    private static final Logger logger = LoggerFactory.getLogger(BinlogMonitorService.class);
    
    /**
     * 记录binlog生成
     * @param tableName 表名
     * @param operationType 操作类型
     * @param binlogCount binlog数量
     * @param success 是否成功
     */
    public void recordBinlogGeneration(String tableName, String operationType, int binlogCount, boolean success) {
        totalBinlogGenerations.incrementAndGet();
        totalBinlogCount.addAndGet(binlogCount);
        
        if (success) {
            totalSuccessfulGenerations.incrementAndGet();
        } else {
            totalFailedGenerations.incrementAndGet();
        }
        
        logger.debug("记录binlog生成: 表名={}, 操作类型={}, binlog数量={}, 成功={}", 
            tableName, operationType, binlogCount, success);
    }
    
    /**
     * 获取监控指标
     * @return 监控指标
     */
    public BinlogMetrics getMetrics() {
        // 检查是否需要重置
        if (System.currentTimeMillis() - lastResetTime > resetInterval) {
            resetMetrics();
        }
        
        BinlogMetrics metrics = new BinlogMetrics();
        metrics.setTotalBinlogGenerations(totalBinlogGenerations.get());
        metrics.setTotalSuccessfulGenerations(totalSuccessfulGenerations.get());
        metrics.setTotalFailedGenerations(totalFailedGenerations.get());
        metrics.setTotalBinlogCount(totalBinlogCount.get());
        metrics.setTimestamp(System.currentTimeMillis());
        
        return metrics;
    }
    
    /**
     * 重置指标
     */
    private void resetMetrics() {
        totalBinlogGenerations.set(0);
        totalSuccessfulGenerations.set(0);
        totalFailedGenerations.set(0);
        totalBinlogCount.set(0);
        lastResetTime = System.currentTimeMillis();
        
        logger.info("binlog监控指标重置");
    }
    
    /**
     * 定期监控binlog状态
     */
    @Scheduled(fixedRate = 30000) // 每30秒监控一次
    public void monitorBinlogStatus() {
        try {
            BinlogMetrics metrics = getMetrics();
            
            logger.info("binlog监控: 总生成次数={}, 成功次数={}, 失败次数={}, 总binlog数量={}, 成功率={}%, 平均binlog数量={}", 
                metrics.getTotalBinlogGenerations(), metrics.getTotalSuccessfulGenerations(), 
                metrics.getTotalFailedGenerations(), metrics.getTotalBinlogCount(),
                String.format("%.2f", metrics.getSuccessRate()), 
                String.format("%.2f", metrics.getAverageBinlogCount()));
            
            // 检查异常情况
            if (metrics.getSuccessRate() < 90) {
                logger.warn("binlog生成成功率过低: {}%", String.format("%.2f", metrics.getSuccessRate()));
            }
            
            if (metrics.getAverageBinlogCount() > 5) {
                logger.warn("平均binlog数量过多: {}", String.format("%.2f", metrics.getAverageBinlogCount()));
            }
            
        } catch (Exception e) {
            logger.error("binlog状态监控失败", e);
        }
    }
}

/**
 * binlog指标类
 * @author 运维实战
 */
@Data
public class BinlogMetrics {
    
    private long totalBinlogGenerations;
    private long totalSuccessfulGenerations;
    private long totalFailedGenerations;
    private long totalBinlogCount;
    private long timestamp;
    
    public BinlogMetrics() {
        this.timestamp = System.currentTimeMillis();
    }
    
    /**
     * 获取成功率
     * @return 成功率
     */
    public double getSuccessRate() {
        if (totalBinlogGenerations == 0) return 0.0;
        return (double) totalSuccessfulGenerations / totalBinlogGenerations * 100;
    }
    
    /**
     * 获取失败率
     * @return 失败率
     */
    public double getFailureRate() {
        if (totalBinlogGenerations == 0) return 0.0;
        return (double) totalFailedGenerations / totalBinlogGenerations * 100;
    }
    
    /**
     * 获取平均binlog数量
     * @return 平均binlog数量
     */
    public double getAverageBinlogCount() {
        if (totalBinlogGenerations == 0) return 0.0;
        return (double) totalBinlogCount / totalBinlogGenerations;
    }
    
    /**
     * 是否健康
     * @return 是否健康
     */
    public boolean isHealthy() {
        return getSuccessRate() > 90 && getAverageBinlogCount() <= 5;
    }
}

/**
 * binlog优化服务
 * @author 运维实战
 */
@Service
public class BinlogOptimizeService {
    
    @Autowired
    private BinlogGenerationProperties properties;
    
    private static final Logger logger = LoggerFactory.getLogger(BinlogOptimizeService.class);
    
    /**
     * 获取binlog生成策略
     * @param operationType 操作类型
     * @param operationCount 操作数量
     * @return binlog生成策略
     */
    public BinlogGenerationStrategy getStrategy(String operationType, int operationCount) {
        logger.info("获取binlog生成策略，操作类型: {}, 操作数量: {}", operationType, operationCount);
        
        BinlogGenerationStrategy strategy = new BinlogGenerationStrategy();
        strategy.setOperationCount(operationCount);
        strategy.setTimestamp(System.currentTimeMillis());
        
        // 根据操作类型和数量选择策略
        if ("TRANSACTION".equals(operationType)) {
            strategy.setStrategy("TRANSACTIONAL");
            strategy.setDescription("事务操作，确保产生1条binlog");
            strategy.setEstimatedBinlogCount(1);
            strategy.setEstimatedDuration(operationCount * 100);
        } else if (operationCount == 1) {
            strategy.setStrategy("SINGLE_OPERATION");
            strategy.setDescription("单条操作，产生1条binlog");
            strategy.setEstimatedBinlogCount(1);
            strategy.setEstimatedDuration(50);
        } else if (operationCount <= 10) {
            strategy.setStrategy("SMALL_BATCH");
            strategy.setDescription("小批量操作，可能产生多条binlog");
            strategy.setEstimatedBinlogCount(operationCount);
            strategy.setEstimatedDuration(operationCount * 80);
        } else if (operationCount <= 100) {
            strategy.setStrategy("MEDIUM_BATCH");
            strategy.setDescription("中批量操作，建议使用事务合并");
            strategy.setEstimatedBinlogCount(operationCount);
            strategy.setEstimatedDuration(operationCount * 60);
        } else {
            strategy.setStrategy("LARGE_BATCH");
            strategy.setDescription("大批量操作，强烈建议使用事务合并");
            strategy.setEstimatedBinlogCount(operationCount);
            strategy.setEstimatedDuration(operationCount * 40);
        }
        
        logger.info("binlog生成策略确定: 策略={}, 操作数量={}, 预计binlog数量={}, binlog减少率={}%", 
            strategy.getStrategy(), operationCount, strategy.getEstimatedBinlogCount(),
            String.format("%.2f", strategy.getBinlogReductionRate()));
        
        return strategy;
    }
    
    /**
     * 计算最优binlog生成策略
     * @param operationType 操作类型
     * @param operationCount 操作数量
     * @return 最优策略
     */
    public BinlogGenerationStrategy calculateOptimalStrategy(String operationType, int operationCount) {
        BinlogGenerationStrategy strategy = getStrategy(operationType, operationCount);
        
        // 根据配置优化策略
        if (properties.isEnableBinlogOptimization() && operationCount > 1) {
            if (properties.isEnableBatchOperationMerge() && operationCount >= properties.getBatchOperationMergeThreshold()) {
                strategy.setStrategy("BATCH_MERGE");
                strategy.setDescription("批量操作合并，减少binlog数量");
                strategy.setEstimatedBinlogCount(1);
            }
        }
        
        return strategy;
    }
    
    /**
     * 获取binlog优化建议
     * @param operationType 操作类型
     * @param operationCount 操作数量
     * @return 优化建议
     */
    public BinlogOptimizationAdvice getOptimizationAdvice(String operationType, int operationCount) {
        BinlogOptimizationAdvice advice = new BinlogOptimizationAdvice();
        advice.setOperationType(operationType);
        advice.setOperationCount(operationCount);
        advice.setTimestamp(System.currentTimeMillis());
        
        if (operationCount == 1) {
            advice.setAdvice("SINGLE_OPERATION");
            advice.setDescription("单条操作，无需优化");
            advice.setRecommendedBinlogCount(1);
        } else if (operationCount <= 10) {
            advice.setAdvice("SMALL_BATCH");
            advice.setDescription("小批量操作，建议使用事务");
            advice.setRecommendedBinlogCount(1);
        } else if (operationCount <= 100) {
            advice.setAdvice("MEDIUM_BATCH");
            advice.setDescription("中批量操作，强烈建议使用事务");
            advice.setRecommendedBinlogCount(1);
        } else {
            advice.setAdvice("LARGE_BATCH");
            advice.setDescription("大批量操作，必须使用事务");
            advice.setRecommendedBinlogCount(1);
        }
        
        return advice;
    }
}

/**
 * binlog优化建议类
 * @author 运维实战
 */
@Data
public class BinlogOptimizationAdvice {
    
    private String operationType;
    private int operationCount;
    private String advice;
    private String description;
    private int recommendedBinlogCount;
    private long timestamp;
    
    public BinlogOptimizationAdvice() {
        this.timestamp = System.currentTimeMillis();
    }
    
    /**
     * 获取binlog减少数
     * @return binlog减少数
     */
    public int getBinlogReduction() {
        return Math.max(0, operationCount - recommendedBinlogCount);
    }
    
    /**
     * 获取binlog减少率
     * @return binlog减少率
     */
    public double getBinlogReductionRate() {
        if (operationCount == 0) return 0.0;
        return (double) getBinlogReduction() / operationCount * 100;
    }
}

/**
 * binlog生成REST控制器
 * @author 运维实战
 */
@RestController
@RequestMapping("/api/mysql/binlog/generation")
public class BinlogGenerationController {
    
    @Autowired
    private BinlogGenerationService binlogGenerationService;
    
    @Autowired
    private BinlogMonitorService binlogMonitorService;
    
    @Autowired
    private BinlogOptimizeService binlogOptimizeService;
    
    private static final Logger logger = LoggerFactory.getLogger(BinlogGenerationController.class);
    
    /**
     * 产生1条binlog的插入操作
     * @param request 插入请求
     * @return 插入结果
     */
    @PostMapping("/insert")
    public ResponseEntity<BinlogGenerationResult> generateSingleBinlogInsert(@RequestBody BinlogInsertRequest request) {
        try {
            logger.info("接收到产生1条binlog的插入请求，表名: {}", request.getTableName());
            
            BinlogGenerationResult result = binlogGenerationService.generateSingleBinlogInsert(
                request.getTableName(), request.getData());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            logger.error("产生1条binlog的插入操作失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 产生1条binlog的更新操作
     * @param request 更新请求
     * @return 更新结果
     */
    @PostMapping("/update")
    public ResponseEntity<BinlogGenerationResult> generateSingleBinlogUpdate(@RequestBody BinlogUpdateRequest request) {
        try {
            logger.info("接收到产生1条binlog的更新请求，表名: {}", request.getTableName());
            
            BinlogGenerationResult result = binlogGenerationService.generateSingleBinlogUpdate(
                request.getTableName(), request.getData(), request.getWhereCondition());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            logger.error("产生1条binlog的更新操作失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 产生1条binlog的删除操作
     * @param request 删除请求
     * @return 删除结果
     */
    @PostMapping("/delete")
    public ResponseEntity<BinlogGenerationResult> generateSingleBinlogDelete(@RequestBody BinlogDeleteRequest request) {
        try {
            logger.info("接收到产生1条binlog的删除请求，表名: {}", request.getTableName());
            
            BinlogGenerationResult result = binlogGenerationService.generateSingleBinlogDelete(
                request.getTableName(), request.getWhereCondition());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            logger.error("产生1条binlog的删除操作失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 通过事务产生1条binlog
     * @param request 事务请求
     * @return 事务结果
     */
    @PostMapping("/transaction")
    public ResponseEntity<BinlogGenerationResult> generateSingleBinlogByTransaction(@RequestBody BinlogTransactionRequest request) {
        try {
            logger.info("接收到通过事务产生1条binlog的请求，操作数量: {}", request.getOperations().size());
            
            BinlogGenerationResult result = binlogGenerationService.generateSingleBinlogByTransaction(
                request.getOperations());
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            logger.error("通过事务产生1条binlog失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 获取binlog生成策略
     * @param operationType 操作类型
     * @param operationCount 操作数量
     * @return binlog生成策略
     */
    @GetMapping("/strategy/{operationType}/{operationCount}")
    public ResponseEntity<BinlogGenerationStrategy> getBinlogGenerationStrategy(
            @PathVariable String operationType, @PathVariable int operationCount) {
        try {
            BinlogGenerationStrategy strategy = binlogOptimizeService.getStrategy(operationType, operationCount);
            return ResponseEntity.ok(strategy);
        } catch (Exception e) {
            logger.error("获取binlog生成策略失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 获取binlog优化建议
     * @param operationType 操作类型
     * @param operationCount 操作数量
     * @return binlog优化建议
     */
    @GetMapping("/advice/{operationType}/{operationCount}")
    public ResponseEntity<BinlogOptimizationAdvice> getBinlogOptimizationAdvice(
            @PathVariable String operationType, @PathVariable int operationCount) {
        try {
            BinlogOptimizationAdvice advice = binlogOptimizeService.getOptimizationAdvice(operationType, operationCount);
            return ResponseEntity.ok(advice);
        } catch (Exception e) {
            logger.error("获取binlog优化建议失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    
    /**
     * 获取binlog监控指标
     * @return binlog监控指标
     */
    @GetMapping("/metrics")
    public ResponseEntity<BinlogMetrics> getBinlogMetrics() {
        try {
            BinlogMetrics metrics = binlogMonitorService.getMetrics();
            return ResponseEntity.ok(metrics);
        } catch (Exception e) {
            logger.error("获取binlog监控指标失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
}

/**
 * binlog插入请求类
 * @author 运维实战
 */
@Data
public class BinlogInsertRequest {
    
    private String tableName;
    private Map<String, Object> data;
    
    public BinlogInsertRequest() {}
    
    public BinlogInsertRequest(String tableName, Map<String, Object> data) {
        this.tableName = tableName;
        this.data = data;
    }
}

/**
 * binlog更新请求类
 * @author 运维实战
 */
@Data
public class BinlogUpdateRequest {
    
    private String tableName;
    private Map<String, Object> data;
    private Map<String, Object> whereCondition;
    
    public BinlogUpdateRequest() {}
    
    public BinlogUpdateRequest(String tableName, Map<String, Object> data, Map<String, Object> whereCondition) {
        this.tableName = tableName;
        this.data = data;
        this.whereCondition = whereCondition;
    }
}

/**
 * binlog删除请求类
 * @author 运维实战
 */
@Data
public class BinlogDeleteRequest {
    
    private String tableName;
    private Map<String, Object> whereCondition;
    
    public BinlogDeleteRequest() {}
    
    public BinlogDeleteRequest(String tableName, Map<String, Object> whereCondition) {
        this.tableName = tableName;
        this.whereCondition = whereCondition;
    }
}

/**
 * binlog事务请求类
 * @author 运维实战
 */
@Data
public class BinlogTransactionRequest {
    
    private List<DatabaseOperation> operations;
    
    public BinlogTransactionRequest() {}
    
    public BinlogTransactionRequest(List<DatabaseOperation> operations) {
        this.operations = operations;
    }
}

/**
 * binlog生成注解
 * @author 运维实战
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface BinlogGeneration {
    
    /**
     * 表名
     */
    String tableName() default "";
    
    /**
     * 操作类型
     */
    String operationType() default "INSERT";
    
    /**
     * 是否启用binlog优化
     */
    boolean enableBinlogOptimization() default true;
    
    /**
     * 是否启用事务
     */
    boolean enableTransaction() default true;
    
    /**
     * 事务超时时间（毫秒）
     */
    long transactionTimeoutMs() default 5000;
    
    /**
     * 操作失败时的消息
     */
    String message() default "binlog生成操作失败，请稍后重试";
    
    /**
     * 操作失败时的HTTP状态码
     */
    int statusCode() default 500;
}

/**
 * binlog生成AOP切面
 * @author 运维实战
 */
@Aspect
@Component
public class BinlogGenerationAspect {
    
    @Autowired
    private BinlogGenerationService binlogGenerationService;
    
    @Autowired
    private BinlogMonitorService binlogMonitorService;
    
    @Autowired
    private BinlogOptimizeService binlogOptimizeService;
    
    private static final Logger logger = LoggerFactory.getLogger(BinlogGenerationAspect.class);
    
    /**
     * binlog生成切点
     */
    @Pointcut("@annotation(binlogGeneration)")
    public void binlogGenerationPointcut(BinlogGeneration binlogGeneration) {}
    
    /**
     * binlog生成环绕通知
     * @param joinPoint 连接点
     * @param binlogGeneration binlog生成注解
     * @return 执行结果
     * @throws Throwable 异常
     */
    @Around("binlogGenerationPointcut(binlogGeneration)")
    public Object around(ProceedingJoinPoint joinPoint, BinlogGeneration binlogGeneration) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        
        try {
            // 获取方法参数
            Object[] args = joinPoint.getArgs();
            
            // 查找数据参数
            Map<String, Object> data = findData(args);
            String tableName = binlogGeneration.tableName();
            String operationType = binlogGeneration.operationType();
            
            if (data != null && !data.isEmpty()) {
                // 获取binlog生成策略
                BinlogGenerationStrategy strategy = binlogOptimizeService.getStrategy(operationType, 1);
                
                logger.info("binlog生成操作开始: method={}, tableName={}, operationType={}, strategy={}", 
                    methodName, tableName, operationType, strategy.getStrategy());
                
                // 记录binlog生成指标
                binlogMonitorService.recordBinlogGeneration(tableName, operationType, 1, true);
            }
            
            // 执行原方法
            return joinPoint.proceed();
            
        } catch (Exception e) {
            logger.error("binlog生成操作处理异常: method={}", methodName, e);
            throw new BinlogGenerationException(binlogGeneration.message(), binlogGeneration.statusCode());
        }
    }
    
    /**
     * 查找数据参数
     * @param args 方法参数
     * @return 数据
     */
    private Map<String, Object> findData(Object[] args) {
        for (Object arg : args) {
            if (arg instanceof Map) {
                @SuppressWarnings("unchecked")
                Map<String, Object> map = (Map<String, Object>) arg;
                return map;
            }
        }
        return null;
    }
}