百度360必应搜狗淘宝本站头条
外键约束 oracle唯一索引 oracleoracle的row numberoracle in 表变量oracle导出dmp导出
当前位置：网站首页 > 技术资源 > 正文

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

moboyou 2025-03-31 15:25 6 浏览

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

相关推荐

声学EI要完稿?十步速写法

【推荐会议】国际声学与振动会议（ICAV）会议号：CFP23112A截稿时间：2025年4月20日召开时间/地点：2025年8月15-17日·新加坡论文集上线：会后3个月提交EiComp...

结构力学!EI会议图表规范秘籍

推荐会议：国际结构与材料工程进展大会（ISME2026）会议编号：EI#73521截稿时间：2026年3月10日召开时间/地点：2026年8月15-17日·德国柏林论文集上线：会后4...

傅里叶级数物理意义的直观理解:利用傅里叶级数逼近方波信号

上篇文章将向大家介绍频谱的概念，对傅里叶级数、傅里叶积分、傅里叶变换进行了数学的推导，并解释了它们各自的物理意义。推导过程见我的上一篇文章：频谱分析——频谱概念（傅里叶变换、级数、积分及物理意义）如下...

通过对航空发动机整机振动进行分析，有何控制方法?

前言针对航空发动机整机振动问题的复杂性和多样性，以整机振动的振源分析为出发点，总结国内外关于转子系统故障、气流激振、轴承故障、齿轮故障和结构局部共振等引起的整机振动的研究情况。结合航空发动机整机结构动...

MATLIB中使用PCA

主成分分析PCA（PrincipalComponentsAnalysis），奇异值分解SVD(Singularvaluedecomposition)是两种常用的降维方法降维致力于解决三类问题：降维...

数据处理|软件:让科研更简单2

书接上回，继续介绍免费的数据处理软件。eGPS一款热图绘制专用软件，热图就是用颜色代表数字,让数据呈现更直观,对比更明显。优点：小巧方便，基本功能齐全，包括数据转换、聚类分析、颜色调整等等缺点：常见的...

电力系统常用的通讯协议及其在Speedgoat系统中的实现

在电力系统中，IEC61850协议、DNP3协议、ModbusTCP广泛应用于远程终端设备（RTU）、智能电子设备（IED）交互以及监控和数据采集（SCADA）系统。一、IEC61850协议IE...

电子工程师的常用仿真软件

不知道从事电子行业的工程师，有没有使用模拟仿真工具，仿真软件网上又有很多，初学者，可能只知道Multisim和Proteus。一般Multisim适合在学习模拟电路和电路分析原理课程时使用，便于理解电...

技术论文|异结构混沌系统的组合同步控制及电路实现

欢迎引用[1]李贤丽,马赛,樊争先,王壮,马文峥,于婷婷.异结构混沌系统的组合同步控制及电路实现[J].自动化与仪器仪表,2022,No.276(10):80-84.DOI:10.14016/j.cn...

现场︱某110KV主变事故过程仿真分析

三峡电力职业学院、河南省电力公司洛阳供电公司的研究人员李莉、任幼逢、徐金雄、王磊，在2016年第6期《电气技术》杂志上撰文，针对某110KV变电站主变差动保护跳闸事故，结合事故相关检测数据，通过MAT...

光伏发电系统篇:单级式并网系统实时仿真

在全球积极推动清洁能源转型的大背景下，光伏发电作为重要的可再生能源利用方式，得到了广泛关注和迅猛发展。目前常用的光伏并网及光伏电站主要拓扑结构有单级式和双级式。相较于传统的多级式系统，单级式光伏发电并...

光伏发电系统篇:三电平并网逆变器实时仿真

一、三电平并网逆变器在能源转型加速的当下，分布式能源接入电网需求大增。三电平并网逆变器凭借低谐波、高功率密度等优势，有效提升电能转换效率，于新能源并网发电中担当关键角色。常见的三电平电路拓扑结构包括二...

自制3.5KW大功率逆变器，很简单，看过这个电路原理就懂了

前言拿下8000元奖金的项目，是什么水平？本项目经过联合湖南科技大学光伏逆变以及电力电子研究生团队共同探讨方案。项目成本：1200元，获得奖金：8000元！参加赛事：立创开源硬件平台_星火计划·外包赛...

圈内分享:电容式加速度计接口电路非线性建模与仿真设计

摘要：非线性是Sigma-Delta（ΣΔ）加速度计系统的关键指标之一。基于一个五阶ΣΔ加速度计结构，分析了其主要的非线性模块，在MATLAB中建立了整体结构的行为级模型，并利用根轨迹法进行了稳...

基于Matlab/Simulink建立一种Thevenin/RC电池模块仿真模型

本文以锂电池数学模型为基础，在Matlab/Simulink的仿真系统中，建立了一种Thevenin/RC电池模块仿真模型，通过实际工况试验，测试精度在允许误差范围内，为电池SOC/SOH研究提供了极...

一周热门
最近发表
标签列表
蜀ICP备2024111239号-28