百度360必应搜狗淘宝本站头条
php redisredis 命令redis 锁redis 主从redis 删除
当前位置：网站首页 > 技术教程 > 正文

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

mhr18 2025-03-07 21:47 19 浏览 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开发者工具箱中的重要一环。

相关推荐

B站收藏视频失效?mybili 收藏夹备份神器完整部署指南

本内容来源于@什么值得买APP，观点仅代表作者本人｜作者：羊刀仙很多B站用户都有过类似经历：自己精心收藏的视频突然“消失”，点开一看不是“已被删除”，就是“因UP主设置不可见”。而B站并不会主动通知...

中间件推荐初始化配置

Redis推荐初始化配置bind0.0.0.0protected-modeyesport6379tcp-backlog511timeout300tcp-keepalive300...

Redis中缓存穿透问题与解决方法

缓存穿透问题概述在Redis作为缓存使用时，缓存穿透是常见问题。正常查询流程是先从Redis缓存获取数据，若有则直接使用；若没有则去数据库查询，查到后存入缓存。但当请求的数据在缓存和数据库中都...

后端开发必看!Redis 哨兵机制如何保障系统高可用?

你是否曾在项目中遇到过Redis主服务器突然宕机，导致整个业务系统出现数据读取异常、响应延迟甚至服务中断的情况？面对这样的突发状况，作为互联网大厂的后端开发人员，如何快速恢复服务、保障系统的高可用...

Redis合集-大Key处理建议

以下是Redis大Key问题的全流程解决方案，涵盖检测、处理、优化及预防策略，结合代码示例和最佳实践：一、大Key的定义与风险1.大Key判定标准数据类型大Key阈值风险场景S...

深入解析跳跃表:Redis里的&quot;老六&quot;数据结构，专治各种不服

大家好，我是你们的码农段子手，今天要给大家讲一个Redis世界里最会"跳科目三"的数据结构——跳跃表（SkipList）。这货表面上是个青铜，实际上是个王者，连红黑树见了都要喊声大哥。...

Redis 中 AOF 持久化技术原理全解析，看完你就懂了!

你在使用Redis的过程中，有没有担心过数据丢失的问题？尤其是在服务器突然宕机、意外断电等情况发生时，那些还没来得及持久化的数据，是不是让你夜不能寐？别担心，Redis的AOF持久化技术就是...

Redis合集-必备的几款运维工具

Redis在应用Redis时，经常会面临的运维工作，包括Redis的运行状态监控，数据迁移，主从集群、切片集群的部署和运维。接下来，从这三个方面，介绍一些工具。先来学习下监控Redis实时...

别再纠结线程池大小 + 线程数量了，没有固定公式的!

我们在百度上能很轻易地搜索到以下线程池设置大小的理论：在一台服务器上我们按照以下设置CPU密集型的程序-核心数+1I/O密集型的程序-核心数*2你不会真的按照这个理论来设置线程池的...

网络编程—IO多路复用详解

假如你想了解IO多路复用，那本文或许可以帮助你本文的最大目的就是想要把select、epoll在执行过程中干了什么叙述出来，所以具体的代码不会涉及，毕竟不同语言的接口有所区别。基础知识IO多路复用涉及...

5分钟学会C/C++多线程编程进程和线程

前言对线程有基本的理解简单的C++面向过程编程能力创造单个简单的线程。创造单个带参数的线程。如何等待线程结束。创造多个线程，并使用互斥量来防止资源抢占。会使用之后，直接跳到“汇总”，复制模板来用就行...

尽情阅读，技术进阶，详解mmap的原理

1.一句话概括mmapmmap的作用，在应用这一层，是让你把文件的某一段，当作内存一样来访问。将文件映射到物理内存，将进程虚拟空间映射到那块内存。这样，进程不仅能像访问内存一样读写文件，多个进程...

C++11多线程知识点总结

一、多线程的基本概念1、进程与线程的区别和联系进程：进程是一个动态的过程，是一个活动的实体。简单来说，一个应用程序的运行就可以被看做是一个进程；线程：是运行中的实际的任务执行者。可以说，进程中包含了多...

微服务高可用的2个关键技巧，你一定用得上

概述上一篇文章讲了一个朋友公司使用SpringCloud架构遇到问题的一个真实案例，虽然不是什么大的技术问题，但如果对一些东西理解的不深刻，还真会犯一些错误。这篇文章我们来聊聊在微服务架构中，到底如...

Java线程间如何共享与传递数据

1、背景在日常SpringBoot应用或者Java应用开发中，使用多线程编程有很多好处，比如可以同时处理多个任务，提高程序的并发性；可以充分利用计算机的多核处理器，使得程序能够更好地利用计算机的资源，...

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

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