Java实现Mybatis日志转MySQL可执行SQL的智能转换工具
一站式开发助手：基于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.sql3. 日志分析工具
集成到日志分析工具中，可以帮助开发团队分析生产环境的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开发者工具箱中的重要一环。