SpringBoot中捕获Flyway日志至字符串且保留spring.log记录的技术问题

针对你需要在多线程处理数百个Schema时，同时捕获Flyway所有日志到字符串、并保留spring.log输出的需求，推荐以下两种可行方案：

方案一：基于Logback自定义Appender + MDC（推荐） #

该方案能完整捕获Flyway框架内部的所有日志输出，同时天然支持多线程隔离。

1. 自定义Logback日志捕获Appender #

这个Appender会将日志同时输出到spring.log，并按Schema维度收集到内存缓存：

import ch.qos.logback.core.AppenderBase;
import ch.qos.logback.classic.spi.ILoggingEvent;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class SchemaLogCaptureAppender extends AppenderBase<ILoggingEvent> {
    // 线程安全的缓存，key为Schema名称，value为对应日志内容
    private static final Map<String, StringBuffer> SCHEMA_LOG_CACHE = new ConcurrentHashMap<>();

    @Override
    protected void append(ILoggingEvent event) {
        // 从MDC获取当前线程绑定的Schema标识
        String schema = event.getMDCPropertyMap().get("flyway_schema");
        if (schema == null) {
            // 非Flyway任务日志，跳过收集
            return;
        }

        // 格式化日志行
        String logLine = getLayout().doLayout(event);
        // 写入缓存，不存在则初始化缓冲区
        SCHEMA_LOG_CACHE.computeIfAbsent(schema, k -> new StringBuffer()).append(logLine);
    }

    // 获取指定Schema的日志内容
    public static String getSchemaLog(String schema) {
        StringBuffer logBuffer = SCHEMA_LOG_CACHE.get(schema);
        return logBuffer == null ? "" : logBuffer.toString();
    }

    // 清理指定Schema的日志缓存，释放内存
    public static void clearSchemaLog(String schema) {
        SCHEMA_LOG_CACHE.remove(schema);
    }
}

2. 配置Logback（logback-spring.xml） #

保留原有spring.log输出的同时，添加自定义Appender：

<configuration>
    <!-- 原有输出到spring.log的Appender，保持你的原有配置 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/spring.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
        <!-- 滚动策略等其他配置保持不变 -->
    </appender>

    <!-- 自定义日志捕获Appender -->
    <appender name="SCHEMA_CAPTURE" class="com.yourpackage.SchemaLogCaptureAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 根Logger同时关联两个Appender -->
    <root level="info">
        <appender-ref ref="FILE"/>
        <appender-ref ref="SCHEMA_CAPTURE"/>
    </root>

    <!-- 确保Flyway的日志能被捕获，设置合适级别 -->
    <logger name="org.flywaydb" level="info"/>
</configuration>

3. 修改FlywayService适配多线程 #

在每个线程任务中绑定MDC标识，执行后获取并清理日志：

import lombok.extern.slf4j.Slf4j;
import org.flywaydb.core.Flyway;
import org.flywaydb.core.api.MigrationInfo;
import org.flywaydb.core.api.MigrationInfoService;
import org.flywaydb.core.api.MigrationVersion;
import org.flywaydb.core.api.configuration.FluentConfiguration;
import org.slf4j.MDC;

import java.util.Properties;

@Slf4j
public class FlywayService {

    private final Flyway flyway;
    private final String schema;

    public FlywayService(Properties props, String dbServer, String schema, String user, String password) {
        this.schema = schema.toUpperCase();
        FluentConfiguration flywayConfig = Flyway.configure();
        flywayConfig.configuration(props);

        flywayConfig.dataSource("jdbc:oracle:thin:@" + dbServer, user, password);
        flywayConfig.schemas(this.schema);
        flyway = flywayConfig.load();
    }

    public void runInfo() {
        // 绑定当前Schema到MDC，实现日志隔离
        MDC.put("flyway_schema", schema);
        try {
            MigrationInfoService info = flyway.info();
            MigrationInfo current = info.current();
            MigrationVersion currentSchemaVersion = current == null ? MigrationVersion.EMPTY : current.getVersion();

            MigrationVersion schemaVersionToOutput = currentSchemaVersion == null ? MigrationVersion.EMPTY : currentSchemaVersion;
            StringBuffer buffer = new StringBuffer();
            buffer.append("Schema version: ")
                    .append(schemaVersionToOutput).append("\n")
                    .append(org.flywaydb.core.internal.info.MigrationInfoDumper.dumpToAsciiTable(info.all()));

            log.info(buffer.toString());
        } finally {
            // 清理MDC，避免线程池复用导致日志串扰
            MDC.remove("flyway_schema");
        }
    }

    // 执行迁移并返回捕获的日志
    public String runMigrateAndGetLog() {
        MDC.put("flyway_schema", schema);
        try {
            flyway.migrate();
            return SchemaLogCaptureAppender.getSchemaLog(schema);
        } finally {
            MDC.remove("flyway_schema");
            SchemaLogCaptureAppender.clearSchemaLog(schema);
        }
    }
}

4. 多线程执行示例 #

使用线程池批量处理Schema：

import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FlywayBatchTask {
    public static void main(String[] args) {
        // 根据服务器配置调整线程池大小
        ExecutorService executor = Executors.newFixedThreadPool(10);

        // 模拟待处理的数百个Schema
        String[] schemas = {"SCHEMA_001", "SCHEMA_002", "SCHEMA_003", ...};
        Properties flywayProps = new Properties();
        // 加载Flyway配置（如flyway.baselineOnMigrate等）

        for (String schema : schemas) {
            executor.submit(() -> {
                FlywayService service = new FlywayService(flywayProps, "db-host:1521/ORCL", schema, "db-user", "db-pass");
                service.runInfo();
                String migrationLog = service.runMigrateAndGetLog();
                // 后续处理日志，比如存入数据库、生成迁移报告等
                System.out.println("Schema " + schema + " 迁移日志已捕获，长度：" + migrationLog.length());
            });
        }

        executor.shutdown();
    }
}

方案二：基于ThreadLocal的独立日志缓冲区 #

如果不想修改Logback配置，可使用ThreadLocal存储单线程日志，但仅能捕获你主动调用日志方法的内容，无法捕获Flyway框架内部日志。

1. 自定义ThreadLocal日志工具类 #

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.StringJoiner;

public class ThreadLocalLogger {
    private static final ThreadLocal<StringJoiner> LOG_BUFFER = ThreadLocal.withInitial(() -> new StringJoiner("\n"));
    private final Logger delegate;

    private ThreadLocalLogger(Class<?> clazz) {
        this.delegate = LoggerFactory.getLogger(clazz);
    }

    public static ThreadLocalLogger getLogger(Class<?> clazz) {
        return new ThreadLocalLogger(clazz);
    }

    // 实现info级别的日志输出，同时写入缓冲区
    public void info(String msg) {
        delegate.info(msg);
        LOG_BUFFER.get().add(msg);
    }

    // 实现其他日志级别（debug/warn/error）及带参数的日志方法，逻辑同上
    public void error(String msg, Throwable t) {
        delegate.error(msg, t);
        LOG_BUFFER.get().add(msg + "\n" + t.getMessage());
    }

    // 获取当前线程的日志内容
    public static String getCurrentThreadLog() {
        return LOG_BUFFER.get().toString();
    }

    // 清理当前线程的日志缓冲区
    public static void clearCurrentThreadLog() {
        LOG_BUFFER.remove();
    }
}

2. 修改FlywayService使用自定义日志 #

public class FlywayService {

    private final Flyway flyway;
    private final String schema;
    private final ThreadLocalLogger log;

    public FlywayService(Properties props, String dbServer, String schema, String user, String password) {
        this.schema = schema.toUpperCase();
        this.log = ThreadLocalLogger.getLogger(FlywayService.class);
        FluentConfiguration flywayConfig = Flyway.configure();
        flywayConfig.configuration(props);

        flywayConfig.dataSource("jdbc:oracle:thin:@" + dbServer, user, password);
        flywayConfig.schemas(this.schema);
        flyway = flywayConfig.load();
    }

    public void runInfo() {
        try {
            MigrationInfoService info = flyway.info();
            MigrationInfo current = info.current();
            MigrationVersion currentSchemaVersion = current == null ? MigrationVersion.EMPTY : current.getVersion();

            MigrationVersion schemaVersionToOutput = currentSchemaVersion == null ? MigrationVersion.EMPTY : currentSchemaVersion;
            StringBuffer buffer = new StringBuffer();
            buffer.append("Schema version: ")
                    .append(schemaVersionToOutput).append("\n")
                    .append(org.flywaydb.core.internal.info.MigrationInfoDumper.dumpToAsciiTable(info.all()));

            log.info(buffer.toString());
        } catch (Exception e) {
            log.error("Schema信息查询失败", e);
        }
    }

    public String runMigrateAndGetLog() {
        try {
            flyway.migrate();
            return ThreadLocalLogger.getCurrentThreadLog();
        } catch (Exception e) {
            log.error("Schema迁移失败", e);
            return ThreadLocalLogger.getCurrentThreadLog();
        } finally {
            ThreadLocalLogger.clearCurrentThreadLog();
        }
    }
}

关键注意事项 #

1. 方案优先级：优先选择方案一，因为它能完整捕获Flyway内部的所有迁移日志（如脚本执行、版本校验等），方案二仅能捕获业务代码中主动输出的日志。
2. 内存管理：处理数百个Schema时，方案一的缓存需定期清理，避免内存溢出；方案二的ThreadLocal必须在任务结束后调用clear方法，防止线程池复用导致的内存泄漏。
3. 日志级别：需确保Logback中org.flywaydb的日志级别设置为info或更低，才能捕获完整的迁移日志。

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