一站式开发助手：基于Java实现Mybatis SQL日志到MySQL可执行语句的智能转换工具与实践应用详解

引言

在Java开发中，Mybatis作为一款优秀的ORM框架被广泛使用。然而，开发人员在调试过程中经常会遇到这样的困扰：Mybatis输出的SQL日志将SQL语句模板和参数分开显示，无法直接复制到MySQL客户端执行。本文将详细介绍如何使用Java开发一个工具，实现一键将Mybatis日志转换为可直接在MySQL中执行的完整SQL语句，大幅提升开发调试效率。

Mybatis SQL日志格式解析

Mybatis在执行SQL时通常会输出两行关键日志：

DEBUG [main] - ==>  Preparing: select * from user where id = ? and name like ? 
DEBUG [main] - ==> Parameters: 1(Integer), %John%(String)

这种分离式的日志格式虽然清晰地展示了SQL结构和参数值，但对开发者来说，需要手动将参数填入SQL语句才能在数据库客户端中执行，既耗时又容易出错。特别是在参数较多或包含特殊字符的情况下，手动替换的工作量更大。

核心实现思路

我们的转换工具需要完成以下主要任务：

1. 解析Mybatis日志，提取SQL模板和参数信息

2. 根据参数类型进行适当的格式化处理

3. 将格式化后的参数替换到SQL模板的占位符中

4. 处理特殊情况，如LIKE条件、引号转义等

核心实现分析

1. 解析Mybatis日志

首先，我们使用正则表达式来从Mybatis日志中提取SQL模板和参数信息：

private static final Pattern PREPARING_PATTERN = Pattern.compile(".*Preparing:\\s+(.*)");
private static final Pattern PARAMETERS_PATTERN = Pattern.compile(".*Parameters:\\s+(.*)");

这两个正则表达式分别用于匹配Mybatis日志中的SQL模板行和参数行。

2. 参数解析与格式化

解析参数是整个转换过程中最复杂的部分。我们需要考虑：

o 提取每个参数及其类型信息

o 根据参数类型进行适当的格式化（如为字符串添加引号）

o 处理特殊情况（如NULL值、布尔值等）

private static Object parseParameter(String paramStr) {
    if (paramStr.equalsIgnoreCase("null")) {
        return "NULL";
    }
    
    int typeIndex = paramStr.lastIndexOf('(');
    if (typeIndex <= 0) {
        return paramStr; // 没有类型信息
    }
    
    String value = paramStr.substring(0, typeIndex).trim();
    String type = paramStr.substring(typeIndex + 1, paramStr.length() - 1).trim().toLowerCase();
    
    switch (type) {
        case "string":
        case "varchar":
        case "char":
            return "'" + value.replace("'", "\\'") + "'";
        case "date":
        case "time":
        case "timestamp":
        case "datetime":
            return "'" + value + "'";
        case "boolean":
            return Boolean.parseBoolean(value) ? "1" : "0";
        default:
            return value; // 数字和其他类型
    }
}

3. 占位符替换

在提取和格式化参数后，我们需要将它们替换到SQL模板的占位符位置：

private static String replacePlaceholders(String sqlTemplate, List<Object> params) {
    StringBuilder result = new StringBuilder();
    int paramIndex = 0;
    
    for (int i = 0; i < sqlTemplate.length(); i++) {
        char c = sqlTemplate.charAt(i);
        
        if (c == '?' && paramIndex < params.size()) {
            // 检查是否是LIKE子句的一部分
            boolean isInLikeClause = isInLikeClause(sqlTemplate, i);
            Object param = params.get(paramIndex++);
            
            // 特殊处理LIKE模式
            if (isInLikeClause && param instanceof String) {
                // ... LIKE处理逻辑 ...
            } else {
                result.append(param);
            }
        } else {
            result.append(c);
        }
    }
    
    return result.toString();
}

4. 特殊情况处理

LIKE条件是SQL中的一个特殊情况，我们需要额外处理：

private static boolean isInLikeClause(String sql, int position) {
    String beforePosition = sql.substring(0, position).toUpperCase();
    int likePos = beforePosition.lastIndexOf("LIKE");
    if (likePos == -1) return false;
    
    // 检查LIKE和?之间是否有除空格以外的内容
    String between = beforePosition.substring(likePos + 4).trim();
    return between.isEmpty();
}

测试结果与验证

为了验证转换器的有效性，我们设计了12个测试用例，覆盖了各种常见的SQL场景：

让我们以简化的方式展示几个代表性测试用例的结果：

测试用例1：基本SELECT查询

输入:
  ==> Preparing: SELECT * FROM users WHERE id = ?
  ==> Parameters: 123(Integer)
预期: SELECT * FROM users WHERE id = 123
实际: SELECT * FROM users WHERE id = 123
结果: 通过

测试用例3：LIKE操作符

输入:
  ==> Preparing: SELECT * FROM users WHERE name LIKE ?
  ==> Parameters: %John%(String)
预期: SELECT * FROM users WHERE name LIKE '%John%'
实际: SELECT * FROM users WHERE name LIKE '%John%'
结果: 通过

测试用例7：INSERT语句

输入:
  ==> Preparing: INSERT INTO users (name, email, created_at) VALUES (?, ?, ?)
  ==> Parameters: John Doe(String), john@example.com(String), 2023-03-15(Date)
预期: INSERT INTO users (name, email, created_at) VALUES ('John Doe', 'john@example.com', '2023-03-15')
实际: INSERT INTO users (name, email, created_at) VALUES ('John Doe', 'john@example.com', '2023-03-15')
结果: 通过

测试用例10：转义字符串参数中的引号

输入:
  ==> Preparing: SELECT * FROM users WHERE name = ?
  ==> Parameters: O'Reilly(String)
预期: SELECT * FROM users WHERE name = 'O\'Reilly'
实际: SELECT * FROM users WHERE name = 'O\'Reilly'
结果: 通过

实际应用场景

1. 集成到开发工具

可以将此转换器集成到IDE插件中，实现在开发环境中直接选中Mybatis日志，右键转换为可执行SQL。

2. 命令行工具

作为命令行工具，开发人员可以直接传入日志文件，快速获取可执行SQL，例如：

$ java -jar mybatis-converter.jar mybatis-log.txt > executable-sql.sql

3. 日志分析工具

集成到日志分析工具中，可以帮助开发团队分析生产环境的SQL日志，找出高频SQL或性能问题。

4. Web界面工具

也可以构建一个简单的Web界面，提供文本框粘贴Mybatis日志，点击按钮即可获得转换结果。

工具价值与效益

本工具带来的主要价值包括：

1. 提升效率：开发人员不再需要手动替换SQL参数，大幅减少调试时间

2. 减少错误：避免手动替换过程中的错误，特别是在处理复杂SQL和特殊字符时

3. 方便协作：可以轻松将完整SQL分享给DBA或团队成员，便于排查问题

4. 性能分析：快速将SQL转换为可执行形式，方便使用EXPLAIN分析执行计划

5. 批量处理：支持批量转换整个日志文件，适用于大规模日志分析场景

进阶功能与优化方向

该工具还有多个可扩展和优化的方向：

1. 支持更多数据库方言：扩展支持Oracle、PostgreSQL、SQL Server等数据库

2. SQL格式化：增加SQL格式化功能，使结果更易读

3. 参数类型扩展：支持更多复杂的参数类型，如数组、JSON等

4. 性能优化：优化大文件处理能力，支持流式处理

5. 与CI/CD集成：集成到持续集成/持续部署流程，用于自动化SQL审查

完整代码

Mybatis SQL到MySQL可执行语句转换器

import java.util.*;
import java.util.regex.*;
import java.nio.file.*;
import java.io.IOException;

public class MybatisToMySQLConverter {
    private static final Pattern PREPARING_PATTERN = Pattern.compile(".*Preparing:\\s+(.*)");
    private static final Pattern PARAMETERS_PATTERN = Pattern.compile(".*Parameters:\\s+(.*)");
    
    /**
     * 将Mybatis的SQL日志转换为可执行的MySQL语句
     * @param preparingLine 包含SQL模板的日志行
     * @param parametersLine 包含参数的日志行
     * @return 可执行的MySQL语句
     */
    public static String convert(String preparingLine, String parametersLine) {
        // 提取SQL模板
        Matcher prepMatcher = PREPARING_PATTERN.matcher(preparingLine);
        if (!prepMatcher.find()) {
            throw new IllegalArgumentException("无效的Mybatis准备日志格式: " + preparingLine);
        }
        String sqlTemplate = prepMatcher.group(1);
        
        // 提取参数
        Matcher paramMatcher = PARAMETERS_PATTERN.matcher(parametersLine);
        if (!paramMatcher.find()) {
            throw new IllegalArgumentException("无效的Mybatis参数日志格式: " + parametersLine);
        }
        String paramsStr = paramMatcher.group(1);
        
        // 解析参数并替换占位符
        return replacePlaceholders(sqlTemplate, parseParameters(paramsStr));
    }
    
    /**
     * 解析参数字符串为参数列表
     * @param paramsStr 参数字符串
     * @return 解析后的参数列表
     */
    private static List<Object> parseParameters(String paramsStr) {
        if (paramsStr.trim().isEmpty()) {
            return Collections.emptyList();
        }
        
        List<Object> params = new ArrayList<>();
        StringBuilder currentParam = new StringBuilder();
        boolean inParentheses = false;
        
        for (char c : paramsStr.toCharArray()) {
            if (c == '(') {
                inParentheses = true;
                currentParam.append(c);
            } else if (c == ')') {
                inParentheses = false;
                currentParam.append(c);
            } else if (c == ',' && !inParentheses) {
                // 在逗号处分割，但仅当不在括号内时
                params.add(parseParameter(currentParam.toString().trim()));
                currentParam = new StringBuilder();
            } else {
                currentParam.append(c);
            }
        }
        
        // 添加最后一个参数
        if (currentParam.length() > 0) {
            params.add(parseParameter(currentParam.toString().trim()));
        }
        
        return params;
    }
    
    /**
     * 根据参数类型解析单个参数
     * @param paramStr 参数字符串
     * @return 格式化后的参数值
     */
    private static Object parseParameter(String paramStr) {
        if (paramStr.equalsIgnoreCase("null")) {
            return "NULL";
        }
        
        int typeIndex = paramStr.lastIndexOf('(');
        if (typeIndex <= 0) {
            return paramStr; // 没有类型信息
        }
        
        String value = paramStr.substring(0, typeIndex).trim();
        String type = paramStr.substring(typeIndex + 1, paramStr.length() - 1).trim().toLowerCase();
        
        switch (type) {
            case "string":
            case "varchar":
            case "char":
                return "'" + value.replace("'", "\\'") + "'";
            case "date":
            case "time":
            case "timestamp":
            case "datetime":
                return "'" + value + "'";
            case "boolean":
                return Boolean.parseBoolean(value) ? "1" : "0";
            default:
                return value; // 数字和其他类型
        }
    }
    
    /**
     * 替换SQL模板中的占位符
     * @param sqlTemplate SQL模板
     * @param params 参数列表
     * @return 替换后的SQL语句
     */
    private static String replacePlaceholders(String sqlTemplate, List<Object> params) {
        StringBuilder result = new StringBuilder();
        int paramIndex = 0;
        
        for (int i = 0; i < sqlTemplate.length(); i++) {
            char c = sqlTemplate.charAt(i);
            
            if (c == '?' && paramIndex < params.size()) {
                // 检查是否是LIKE子句的一部分
                boolean isInLikeClause = isInLikeClause(sqlTemplate, i);
                Object param = params.get(paramIndex++);
                
                // 特殊处理LIKE模式
                if (isInLikeClause && param instanceof String) {
                    String strParam = (String) param;
                    if (strParam.startsWith("'%") || strParam.endsWith("%'")) {
                        // 已经有引号和%模式，按原样使用
                        result.append(strParam);
                    } else if (strParam.startsWith("'") && strParam.endsWith("'")) {
                        // 有引号但没有%模式
                        result.append(strParam);
                    } else {
                        // 按原样添加（应该已经格式化正确）
                        result.append(param);
                    }
                } else {
                    result.append(param);
                }
            } else {
                result.append(c);
            }
        }
        
        return result.toString();
    }
    
    /**
     * 判断是否在LIKE子句中
     * @param sql SQL语句
     * @param position 位置
     * @return 是否在LIKE子句中
     */
    private static boolean isInLikeClause(String sql, int position) {
        String beforePosition = sql.substring(0, position).toUpperCase();
        int likePos = beforePosition.lastIndexOf("LIKE");
        if (likePos == -1) return false;
        
        // 检查LIKE和?之间是否有除空格以外的内容
        String between = beforePosition.substring(likePos + 4).trim();
        return between.isEmpty();
    }
    
    /**
     * 批量转换Mybatis日志
     * @param mybatisLogs Mybatis日志内容
     * @return 转换后的可执行SQL语句
     */
    public static String convertMybatisLogs(String mybatisLogs) {
        String[] lines = mybatisLogs.split("\n");
        StringBuilder result = new StringBuilder();
        
        for (int i = 0; i < lines.length - 1 i string line='lines[i].trim();' string nextline='lines[i' 1.trim if line.containspreparing: nextline.containsparameters: result.appendconvertline nextline.append\n i return result.tostring mybatis param filepath return sql throws ioexception public static string convertlogfilestring filepath throws ioexception string logcontent='new' stringfiles.readallbytespaths.getfilepath return convertmybatislogslogcontent param args public static void mainstring args if args.length> 0) {
            // 命令行模式：从文件读取日志
            try {
                String output = convertLogFile(args[0]);
                System.out.println(output);
            } catch (IOException e) {
                System.err.println("无法读取文件: " + e.getMessage());
            }
        } else {
            // 测试模式：运行测试用例
            runTests();
        }
    }
    
    /**
     * 运行测试用例
     */
    private static void runTests() {
        System.out.println("=== Mybatis到MySQL转换器测试用例 ===\n");
        
        // 测试用例1：基本SELECT查询
        runTest(
            "==> Preparing: SELECT * FROM users WHERE id = ?",
            "==> Parameters: 123(Integer)",
            "SELECT * FROM users WHERE id = 123"
        );
        
        // 测试用例2：多参数
        runTest(
            "==> Preparing: SELECT * FROM users WHERE id = ? AND name = ?",
            "==> Parameters: 123(Integer), John(String)",
            "SELECT * FROM users WHERE id = 123 AND name = 'John'"
        );
        
        // 测试用例3：LIKE操作符
        runTest(
            "==> Preparing: SELECT * FROM users WHERE name LIKE ?",
            "==> Parameters: %John%(String)",
            "SELECT * FROM users WHERE name LIKE '%John%'"
        );
        
        // 测试用例4：NULL参数
        runTest(
            "==> Preparing: SELECT * FROM users WHERE updated_at IS ?",
            "==> Parameters: null",
            "SELECT * FROM users WHERE updated_at IS NULL"
        );
        
        // 测试用例5：日期参数
        runTest(
            "==> Preparing: SELECT * FROM users WHERE created_at > ?",
            "==> Parameters: 2023-01-01(Date)",
            "SELECT * FROM users WHERE created_at > '2023-01-01'"
        );
        
        // 测试用例6：带有多种参数类型的复杂查询
        runTest(
            "==> Preparing: SELECT u.*, r.name FROM users u JOIN roles r ON u.role_id = r.id WHERE u.active = ? AND u.created_at > ? AND u.name LIKE ?",
            "==> Parameters: true(Boolean), 2023-01-01(Date), %admin%(String)",
            "SELECT u.*, r.name FROM users u JOIN roles r ON u.role_id = r.id WHERE u.active = 1 AND u.created_at > '2023-01-01' AND u.name LIKE '%admin%'"
        );
        
        // 测试用例7：INSERT语句
        runTest(
            "==> Preparing: INSERT INTO users (name, email, created_at) VALUES (?, ?, ?)",
            "==> Parameters: John Doe(String), john@example.com(String), 2023-03-15(Date)",
            "INSERT INTO users (name, email, created_at) VALUES ('John Doe', 'john@example.com', '2023-03-15')"
        );
        
        // 测试用例8：UPDATE语句
        runTest(
            "==> Preparing: UPDATE users SET name = ?, updated_at = ? WHERE id = ?",
            "==> Parameters: Jane Doe(String), 2023-03-16(Date), 123(Integer)",
            "UPDATE users SET name = 'Jane Doe', updated_at = '2023-03-16' WHERE id = 123"
        );
        
        // 测试用例9：DELETE语句
        runTest(
            "==> Preparing: DELETE FROM users WHERE id = ?",
            "==> Parameters: 123(Integer)",
            "DELETE FROM users WHERE id = 123"
        );
        
        // 测试用例10：转义字符串参数中的引号
        runTest(
            "==> Preparing: SELECT * FROM users WHERE name = ?",
            "==> Parameters: O'Reilly(String)",
            "SELECT * FROM users WHERE name = 'O\\'Reilly'"
        );
        
        // 测试用例11：多个LIKE条件
        runTest(
            "==> Preparing: SELECT * FROM users WHERE first_name LIKE ? OR last_name LIKE ?",
            "==> Parameters: %John%(String), %Doe%(String)",
            "SELECT * FROM users WHERE first_name LIKE '%John%' OR last_name LIKE '%Doe%'"
        );
        
        // 测试用例12：批量转换测试
        String batchInput = "==> Preparing: SELECT * FROM users WHERE id = ?\n" +
                           "==> Parameters: 123(Integer)\n" +
                           "==> Preparing: UPDATE users SET name = ? WHERE id = ?\n" +
                           "==> Parameters: John(String), 123(Integer)";
        
        String expectedBatchOutput = "SELECT * FROM users WHERE id = 123;\n" +
                                    "UPDATE users SET name = 'John' WHERE id = 123;\n";
        
        String actualBatchOutput = convertMybatisLogs(batchInput);
        System.out.println("\n测试用例12：批量转换");
        System.out.println("输入:\n" + batchInput);
        System.out.println("\n预期输出:\n" + expectedBatchOutput);
        System.out.println("\n实际输出:\n" + actualBatchOutput);
        System.out.println("结果: " + (expectedBatchOutput.equals(actualBatchOutput) ? "通过" : "失败"));
    }
    
    /**
     * 运行单个测试用例
     */
    private static void runTest(String preparingLine, String parametersLine, String expectedOutput) {
        try {
            String actualOutput = convert(preparingLine, parametersLine);
            boolean pass = expectedOutput.equals(actualOutput);
            
            System.out.println("输入:");
            System.out.println("  " + preparingLine);
            System.out.println("  " + parametersLine);
            System.out.println("预期: " + expectedOutput);
            System.out.println("实际: " + actualOutput);
            System.out.println("结果: " + (pass ? "通过" : "失败") + "\n");
        } catch (Exception e) {
            System.out.println("输入:");
            System.out.println("  " + preparingLine);
            System.out.println("  " + parametersLine);
            System.out.println("异常: " + e.getMessage());
            System.out.println("结果: 失败\n");
        }
    }
}

总结

本文介绍了一个基于Java实现的Mybatis SQL日志到MySQL可执行语句的转换工具。通过精确的参数解析和占位符替换，该工具能够准确地将Mybatis日志转换为可直接在MySQL中执行的SQL语句，大幅提升开发效率和调试体验。测试结果表明，该工具能够成功处理各种常见的SQL场景，包括基本查询、复杂条件、特殊字符等情况。

作为开发助手，这个工具不仅简化了日常开发工作，还为团队协作和问题排查提供了便利。随着功能的不断完善，它有望成为Java开发者工具箱中的重要一环。

Java实现Mybatis日志转MySQL可执行SQL的智能转换工具

一站式开发助手：基于Java实现Mybatis SQL日志到MySQL可执行语句的智能转换工具与实践应用详解

引言

Mybatis SQL日志格式解析

核心实现思路

核心实现分析

1. 解析Mybatis日志

2. 参数解析与格式化

3. 占位符替换

4. 特殊情况处理

测试结果与验证

测试用例1：基本SELECT查询

测试用例3：LIKE操作符

测试用例7：INSERT语句

测试用例10：转义字符串参数中的引号

实际应用场景

1. 集成到开发工具

2. 命令行工具

3. 日志分析工具

4. Web界面工具

工具价值与效益

进阶功能与优化方向

完整代码

Mybatis SQL到MySQL可执行语句转换器

总结

相关推荐

Linux环境中查看Oracle错误和警告日志信息

絮语----工作四年的碎碎念

SQL 中的 (+)用法

oracle常见问题处理

MYSQL经典面试题汇总

医院信息系统突发应急演练记录

Windows 11:已知问题和已解决问题列表(更新时间:2022年1月)

最全面的IBMS系统集成系统技术规格书，赶紧收藏起来!

苹果停止更新Windows版QuickTime!

Navicat Data Modeler使用教程十二:配置