如何通过LogBack+SLF4J将控制台输出重定向至自定义Appender并发送至Discord？

我来帮你搞定这个问题！之前用Runtime.getRuntime()的思路确实绕远了，其实LogBack本身就提供了足够的能力来捕获包括第三方库、System.out/err在内的所有控制台输出，然后通过自定义Appender发送到Discord。下面是一步步的实现方案：

第一步：统一所有日志到SLF4J/LogBack体系 #

很多第三方库可能用的是log4j、java.util.logging（JUL）甚至直接用System.out/err，所以首先要把这些日志都桥接到SLF4J，让它们走LogBack的流程：

1. 添加必要的依赖（以Maven为例） #

在pom.xml里加入这些依赖，确保所有日志框架都被桥接：

<!-- SLF4J核心API -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.7</version>
</dependency>
<!-- LogBack核心实现 -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.8</version>
</dependency>
<!-- 桥接log4j到SLF4J（如果第三方用log4j） -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>log4j-over-slf4j</artifactId>
    <version>2.0.7</version>
</dependency>
<!-- 桥接JUL到SLF4J（如果第三方用JUL） -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jul-to-slf4j</artifactId>
    <version>2.0.7</version>
</dependency>

2. 初始化JUL桥接 #

在项目启动类的最开始，加入这段代码，确保JUL的日志被转发到SLF4J：

import org.slf4j.bridge.SLF4JBridgeHandler;
import java.util.logging.LogManager;

public class ApplicationStartup {
    public static void main(String[] args) {
        // 移除JUL默认的处理器，避免重复输出
        LogManager.getLogManager().reset();
        SLF4JBridgeHandler.install();
        
        // 你的项目启动逻辑...
    }
}

第二步：捕获System.out和System.err的输出 #

有些库可能直接调用System.out.println()或System.err.println()，这部分也需要重定向到LogBack：

实现日志输出流重定向 #

写一个自定义的OutputStream，把输出转成SLF4J的日志：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class LoggingOutputStream extends ByteArrayOutputStream {
    private final Logger logger;
    private final Level level;
    private final String lineSeparator = System.getProperty("line.separator");

    public LoggingOutputStream(Logger logger, Level level) {
        this.logger = logger;
        this.level = level;
    }

    @Override
    public void flush() throws IOException {
        String content = toString();
        super.reset();
        if (!content.isEmpty() && !content.equals(lineSeparator)) {
            ((ch.qos.logback.classic.Logger) logger).log(null, null, level.toInt(), content, null, null);
        }
    }
}

然后在项目启动时替换System.out/err：

import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;
import java.io.PrintStream;

// 在启动类中添加
System.setOut(new PrintStream(new LoggingOutputStream(LoggerFactory.getLogger("System.out"), Level.INFO), true));
System.setErr(new PrintStream(new LoggingOutputStream(LoggerFactory.getLogger("System.err"), Level.ERROR), true));

第三步：自定义Discord Appender #

现在所有日志都走LogBack了，接下来写一个自定义Appender，把日志发送到Discord的Webhook：

实现DiscordAppender #

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.AppenderBase;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class DiscordAppender extends AppenderBase<ILoggingEvent> {
    // 替换成你的Discord Webhook URL
    private String webhookUrl;
    private final OkHttpClient httpClient = new OkHttpClient();
    private final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void append(ILoggingEvent event) {
        // 构建Discord消息格式
        Map<String, Object> message = new HashMap<>();
        message.put("content", String.format("[%s] %s: %s", 
                event.getLevel(), event.getLoggerName(), event.getFormattedMessage()));
        
        // 异步发送，避免阻塞业务线程
        new Thread(() -> {
            try {
                String json = objectMapper.writeValueAsString(message);
                RequestBody body = RequestBody.create(json, MediaType.parse("application/json"));
                Request request = new Request.Builder()
                        .url(webhookUrl)
                        .post(body)
                        .build();
                
                httpClient.newCall(request).execute();
            } catch (Exception e) {
                addError("Failed to send log to Discord", e);
            }
        }).start();
    }

    // LogBack会通过setter注入配置的webhookUrl
    public void setWebhookUrl(String webhookUrl) {
        this.webhookUrl = webhookUrl;
    }
}

在logback.xml中配置自定义Appender #

创建src/main/resources/logback.xml，配置root logger使用我们的DiscordAppender：

<configuration>
    <!-- 配置自定义Discord Appender -->
    <appender name="DISCORD" class="com.yourpackage.DiscordAppender">
        <webhookUrl>https://discord.com/api/webhooks/your-webhook-id/your-webhook-token</webhookUrl>
    </appender>

    <!-- 配置Root Logger，把所有日志级别都发送到Discord -->
    <root level="info">
        <appender-ref ref="DISCORD" />
    </root>

    <!-- 可选：保留ConsoleAppender用于本地调试，生产环境可以去掉 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="info">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

第四步：测试验证 #

现在你可以做几个测试：

• 自己的代码用SLF4J的Logger输出日志
• 调用第三方库的方法，看它的日志是否被捕获
• 直接用System.out.println()或System.err.println()输出内容

所有这些输出都会被转发到你的Discord频道啦！

一些注意事项 #

• Discord速率限制：Discord的Webhook每分钟最多发送5条消息，如果你日志量很大，建议在Appender里做批量处理或者限流
• 异步发送：上面的Appender用了简单的Thread来异步发送，生产环境可以用线程池来优化
• 日志格式优化：可以把日志转成Discord的嵌入消息（Embed），看起来更美观，比如添加时间戳、日志级别颜色等

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