如何用Java基于前后上下文替换SQL文件中的指定内容

我懂你现在的需求——要在SQL文件里精准替换特定上下文里的表名：当遇到INSERT INTO table_name VALUES这种模式时，把中间的table_name转成大写还套上方括号，而且之前用FileInputStream/FileOutputStream的方式效率拉胯，想找更优的实现方案。下面给你几个实用的思路，从简单高效到复杂精准都有：

方案一：Java NIO + 正则表达式（推荐，简单高效） #

Java 11+提供的NIO 2 API（Files.readString/Files.writeString）比传统字节流优化很多，底层自带缓冲区管理，代码也更简洁。结合正则表达式可以精准匹配目标模式：

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SqlTableReplacer {
    public static void main(String[] args) throws Exception {
        // 一次性读取文件内容（小到中等文件适用）
        String sqlContent = Files.readString(Paths.get("your-source.sql"));
        
        // 构建正则：匹配"INSERT INTO 表名 VALUES"，忽略大小写、任意空白符（空格/换行/制表符）
        Pattern targetPattern = Pattern.compile(
            "INSERT\\s+INTO\\s+(\\w+)\\s+VALUES", 
            Pattern.CASE_INSENSITIVE
        );
        Matcher matcher = targetPattern.matcher(sqlContent);
        
        // 执行替换：捕获表名转大写，套上方括号
        StringBuffer resultBuffer = new StringBuffer();
        while (matcher.find()) {
            String upperTableName = matcher.group(1).toUpperCase();
            matcher.appendReplacement(resultBuffer, "INSERT INTO [" + upperTableName + "] VALUES");
        }
        matcher.appendTail(resultBuffer);
        
        // 写入新文件（也可以覆盖原文件，注意备份）
        Files.writeString(Paths.get("your-modified.sql"), resultBuffer.toString());
    }
}

优势： #

• 代码简洁，无需手动管理流的开闭（API内部已处理）
• NIO底层优化了IO操作，比传统字节流效率提升明显
• 正则支持灵活匹配空白符，适配SQL中可能的换行、缩进

方案二：流式处理超大文件（避免内存溢出） #

如果你的SQL文件特别大（比如几个G），一次性读入内存会导致OOM，这时候用Files.lines()流式逐行处理：

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class LargeSqlReplacer {
    public static void main(String[] args) throws Exception {
        Pattern targetPattern = Pattern.compile(
            "INSERT\\s+INTO\\s+(\\w+)\\s+VALUES", 
            Pattern.CASE_INSENSITIVE
        );
        
        // 流式读取每一行，处理后拼接成结果
        String modifiedContent = Files.lines(Paths.get("large-source.sql"))
                .map(line -> {
                    Matcher lineMatcher = targetPattern.matcher(line);
                    // 用lambda实现动态替换
                    return lineMatcher.replaceAll(matchResult -> 
                        "INSERT INTO [" + matchResult.group(1).toUpperCase() + "] VALUES"
                    );
                })
                .collect(Collectors.joining(System.lineSeparator()));
        
        Files.writeString(Paths.get("large-modified.sql"), modifiedContent);
    }
}

优势： #

• 内存占用极低，仅加载当前处理的行
• 同样基于NIO，保持高效IO性能

方案三：用SQL解析器处理复杂SQL场景（精准无误差） #

如果你的SQL文件有复杂语法（比如带schema的表名schema.table、注释换行、特殊字符表名），正则容易出现误匹配，这时候用专业的SQL解析器更可靠，比如JSqlParser：

import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.insert.Insert;

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class ComplexSqlReplacer {
    public static void main(String[] args) throws Exception {
        String sqlContent = Files.readString(Paths.get("complex-source.sql"));
        // 解析所有SQL语句
        List<Statement> statements = CCJSqlParserUtil.parseStatements(sqlContent);
        
        StringBuilder resultBuilder = new StringBuilder();
        for (Statement stmt : statements) {
            if (stmt instanceof Insert insertStmt) {
                // 精准获取INSERT语句的表名，处理后替换
                String originalTable = insertStmt.getTable().getName();
                insertStmt.getTable().setName("[" + originalTable.toUpperCase() + "]");
            }
            resultBuilder.append(stmt.toString()).append(";\n");
        }
        
        Files.writeString(Paths.get("complex-modified.sql"), resultBuilder.toString());
    }
}

优势： #

• 完全遵循SQL语法规则，不会误匹配注释或其他语句中的类似字符串
• 支持各种复杂表名（带schema、特殊字符等）
• 扩展性强，后续可以轻松修改其他SQL元素

内容的提问来源于stack exchange，提问作者Pankaj Rathi