百度360必应搜狗淘宝本站头条
分布式事务框架grpc框架shiro框架java日志框架框架图
当前位置：网站首页 > 技术文章 > 正文

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

ccwgpt 2025-03-10 13:34 45 浏览 0 评论

一站式开发助手：基于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开发者工具箱中的重要一环。

相关推荐

如何使用PIL生成验证码?（pi验证教程）

web项目中遇到使用验证码的情况有很多，进行介绍下使用PIL生成验证码的方法。安装开始安装PIL的过程确实麻烦各种问题层出不绝，不过不断深入后就没有这方面的困扰了：windows安装：直接安装Pil...

Python必学!3步解锁asyncio异步编程 性能直接狂飙10倍!

还在用传统同步代码被IO阻塞卡到崩溃？别当“代码苦行僧”了！Python的asyncio模块堪称异步编程的“开挂神器”，处理高并发任务就像开了涡轮增压！不管是网络爬虫、API接口开发还是文件批量处理，...

Tornado6+APScheduler/Celery打造并发异步动态定时任务轮询服务

定时任务的典型落地场景在各行业中都很普遍，比如支付系统中，支付过程中因为网络或者其他因素导致出现掉单、卡单的情况，账单变成了“单边账”，这种情况对于支付用户来说，毫无疑问是灾难级别的体验，明明自己付了...

Python学习怎么入门?附真实学习方法

Python技术在企业中应用的越来越广泛，因此企业对于Python方面专业人才的需求也越来越大，那对于之前对Python没有任何了解和接触的人而言，想要从零开始学习并不是一件容易的事情，接下来小U就为...

PySpider框架的使用（pyspider 教程）

PysiderPysider是一个国人用Python编写的、带有强大的WebUI的网络爬虫系统，它支持多种数据库、任务监控、项目管理、结果查看、URL去重等强大的功能。安装pip3inst...

大学计算机专业 学习Python学习路线图(最新版)

这是我刚开始学习python时的一套学习路线，从入门到上手。（不敢说精通，哈哈~）希望对大家有帮助哈~大家需要高清得完整python学习路线可以【文末有获取方式】【文末有获取方式】一、Python入门...

阿里巴巴打造的400集Python视频合集免费学起来，学完万物皆可爬

第一阶段Python入门章节1：Python入门章节2：编程基本概念章节3：序列章节4：控制语句章节5：函数章节6：面向对象编程第二阶段Python深入与提高章节1：异常处理章节2：游戏开发-坦克大...

Nginx Gunicorn在服务器中分别起什么作用

大部分人在gunicorn前面部署一层nginx的时候也的确没有想过为什么，他们只是觉得这样显得他们比较专业，而且幻想着加了一层nginx反向代理之后性能会有提升，恕我直言，请你们带上脑子，一个单纯的...

Python培训怎么学?Python基础技术总结!值得一看

Python培训如今越来越被更多人所接受，相比自学参加Python培训的好处也是显而易见，但Python毕竟属于后端编程开发的主流语言，其知识机构还是比较庞大的，那Python培训怎么学?以及Pyth...

使用Tornado部署Flask项目（tornado async）

Tornado不仅仅是一个WEB框架，也可以是一个WEB服务器。在Tornado中我们可以使用wsgi模块下的WSGIContainer类运行其他WSGI应用如：Fask,Bottle,Djang...

Python Web框架哪个好用?（python3 web框架）

　　问：PythonWeb框架哪个好用？　　答：　　1．Django　　Django是Python世界中最出名、最成熟的Web框架。Django功能全面，各模块之间结合紧密，（不讲其他的）Djang...

Vue3.0+Tornado6.1发布订阅模式打造异步非阻塞实时=通信聊天系统

“表达欲”是人类成长史上的强大“源动力”，恩格斯早就直截了当地指出，处在蒙昧时代即低级阶段的人类，“以果实、坚果、根作为食物；音节清晰的语言的产生是这一时期的主要成就”。而在网络时代人们的表达欲往往更...

Python开源项目合集(第三方平台)（python第三方开发工具）

wechat-python-sdk-wechat-python-sdk微信公众平台Python开发包http://wechat-python-sdk.readthedocs.org/，非官方...

IT界10倍高效学习法!用这种方式，一年学完清华大学四年的课程

有没有在某一个瞬间，让你放弃学编程刚开始学python时，我找了几十本国内外的python编程书籍学习后，我还是似懂非懂，那些书里面到处都是抽象的概念，复杂的逻辑，这样的书，对于专业开发者来说，在平常...

如何将Python算法模型注册成Spark UDF函数实现全景模型部署

背景Background对于算法业务团队来说，将训练好的模型部署成服务的业务场景是非常常见的。通常会应用于三个场景：部署到流式程序里，比如风控需要通过流式处理来实时监控。部署到批任务中部署成API服...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表