本文深入探讨了在java中如何有效重定向超类构造器中`system.out.println()`的输出，并解决同时将输出导向文件和控制台的需求。核心在于理解java对象初始化时构造器的调用顺序，并利用全局`system.setout()`结合自定义`printstream`实现多目标输出，或采用更专业的日志框架，以提升输出管理的可控性和灵活性。
理解超类构造器输出重定向失效的根源：构造器调用顺序
在Java中，当子类构造器被调用时，它总是会隐式或显式地调用其父类的构造器。这个调用发生在子类构造器体内的任何代码执行之前。这意味着，如果在子类构造器中尝试通过System.setOut()重定向标准输出流，那么在super()调用期间执行的父类构造器中的System.out.println()语句将仍然输出到原始的System.out流，因为此时重定向尚未生效。
考虑以下示例代码：
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.io.PrintStream;
// 超类定义
public class SuperClass implements ActionListener {
public SuperClass() {
System.out.println("SuperClass constructor: Some message");
}
@Override
public void actionPerformed(ActionEvent event) {
System.out.println("SuperClass actionPerformed: " + toString());
}
@Override
public String toString() {
return "Some other message";
}
}
// 子类定义
public class SubClass extends SuperClass {
private PrintStream ps;
public SubClass() {
super(); // 此处会先执行SuperClass的构造器
// SuperClass构造器执行完毕后，才会执行以下代码
try {
ps = new PrintStream("file.txt");
} catch (IOException e) {
e.printStackTrace();
}
System.setOut(ps); // 此时重定向才生效，但SuperClass构造器已执行完毕
}
}当我们创建SubClass实例时，SuperClass构造器中的"SuperClass constructor: Some message"会打印到控制台，而不是file.txt。然而，actionPerformed()方法中的System.out.println()则会被重定向到file.txt，因为它在System.setOut(ps)之后被调用。
解决方案一：在实例化前全局重定向并实现多目标输出
为了解决超类构造器输出的重定向问题，System.setOut()必须在子类实例被创建之前就执行。同时，为了满足将输出同时导向文件和控制台的需求，我们可以创建一个自定义的PrintStream，它能将数据写入到多个底层输出流。
立即学习“Java免费学习笔记（深入）”；
1. 创建一个“Tee”型PrintStream
“Tee”型流（TeePrintStream）的工作原理类似于管道中的“T”形接头，将一个输入流的数据同时复制到两个或多个输出流。
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
/**
* TeePrintStream是一个PrintStream的子类，它将所有输出写入到两个底层的PrintStream。
* 类似于Unix的'tee'命令，将输出同时发送到两个目的地。
*/
public class TeePrintStream extends PrintStream {
private final PrintStream branch1;
private final PrintStream branch2;
/**
* 构造一个TeePrintStream。
* @param out1 第一个输出流。
* @param out2 第二个输出流。
*/
public TeePrintStream(PrintStream out1, PrintStream out2) {
// 调用父类构造器，通常将一个流作为主要流，但实际写入会分发到两个。
// 这里选择out1作为super的底层流，但关键在于重写write方法。
super(out1);
this.branch1 = out1;
this.branch2 = out2;
}
@Override
public void write(int b) {
branch1.write(b);
branch2.write(b);
}
@Override
public void write(byte[] buf, int off, int len) {
branch1.write(buf, off, len);
branch2.write(buf, off, len);
}
@Override
public void flush() {
branch1.flush();
branch2.flush();
super.flush(); // 确保父类底层的流也被刷新
}
@Override
public void close() {
// 关闭所有底层流
branch1.close();
branch2.close();
super.close(); // 关闭由super()构造器关联的流
}
}2. 在应用程序启动时全局重定向
在主应用程序的入口点（例如main方法）中，在任何可能创建SubClass实例的代码之前，进行System.out的重定向。
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
public class MainApplication {
public static void main(String[] args) {
PrintStream originalOut = System.out; // 保存原始的System.out
PrintStream fileStream = null;
TeePrintStream teeStream = null;
try {
// 1. 创建文件输出流
fileStream = new PrintStream(new FileOutputStream("output.log", true)); // true表示追加模式
// 2. 创建TeePrintStream，将输出同时导向文件和原始控制台
teeStream = new TeePrintStream(fileStream, originalOut);
// 3. 全局重定向System.out
System.setOut(teeStream);
// 此时，任何System.out.println()都会同时输出到文件和控制台
System.out.println("Application starting...");
// 创建SubClass实例，其SuperClass构造器现在也会打印到文件和控制台
SubClass sub = new SubClass();
System.out.println("SubClass instance created.");
// 模拟动作执行
sub.actionPerformed(null);
System.out.println("Application finished.");
} catch (IOException e) {
originalOut.println("Error setting up output redirection: " + e.getMessage());
e.printStackTrace(originalOut);
} finally {
// 恢复原始的System.out并关闭自定义流
if (teeStream != null) {
System.setOut(originalOut); // 恢复原始输出流
teeStream.close(); // 关闭TeePrintStream，它会负责关闭其内部的fileStream
} else if (fileStream != null) {
fileStream.close();
}
}
}
}通过这种方式，System.out在SubClass实例创建之前就已经被重定向，因此SuperClass构造器中的System.out.println()也会被捕获并同时输出到文件和控制台。
解决方案二：采用Java日志框架
在生产环境中，直接修改System.out通常不是最佳实践。更推荐的方法是使用成熟的Java日志框架，如Log4j、Logback或Java Util Logging (JUL)。日志框架提供了更强大、更灵活的输出管理能力，包括：
- 日志级别控制： 可以根据日志的重要性（如DEBUG, INFO, WARN, ERROR）进行过滤。
- 多目标输出（Appenders）： 可以同时配置输出到控制台、文件、数据库、网络等多个目的地。
- 格式化输出： 灵活定义日志信息的格式。
- 异步日志： 提高应用程序性能。
- 滚动策略： 自动管理日志文件大小和数量。
使用日志框架的示例
假设我们使用SLF4J作为日志门面，Logback作为实现。
-
添加依赖：
org.slf4j slf4j-api 1.7.30 ch.qos.logback logback-classic 1.2.3 -
配置Logback (logback.xml)： 在src/main/resources目录下创建logback.xml文件。
%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n application.log %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n -
修改SuperClass和SubClass使用Logger：
import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; // 超类定义 public class SuperClass implements ActionListener { private static final Logger logger = LoggerFactory.getLogger(SuperClass.class); public SuperClass() { logger.info("SuperClass constructor: Some message"); // 使用logger输出 } @Override public void actionPerformed(ActionEvent event) { logger.info("SuperClass actionPerformed: {}", toString()); // 使用logger输出 } @Override public String toString() { return "Some other message"; } } // 子类定义 (不再需要重定向System.out) public class SubClass extends SuperClass { private static final Logger logger = LoggerFactory.getLogger(SubClass.class); public SubClass() { super(); // SuperClass的日志会通过其自身的logger输出 logger.info("SubClass constructor: Initialized."); } } // 主应用程序 public class MainApplicationWithLogging { private static final Logger logger = LoggerFactory.getLogger(MainApplicationWithLogging.class); public static void main(String[] args) { logger.info("Application starting..."); SubClass sub = new SubClass(); logger.info("SubClass instance created."); sub.actionPerformed(null); logger.info("Application finished."); } }通过这种方式，SuperClass和SubClass的输出都将通过各自的Logger进行管理，并根据logback.xml的配置同时输出到控制台和文件，而无需担心构造器调用顺序导致的System.out重定向问题。
注意事项与最佳实践
- 全局状态修改的风险： System.setOut()会修改JVM的全局标准输出流。这可能会影响到应用程序中其他不期望被重定向的部分，或者被第三方库的输出。因此，在使用完毕后务必恢复原始的System.out。
- System.err的重定向： 类似地，System.err也可以通过System.setErr()进行重定向，通常用于错误日志。
- 日志框架的优势： 对于复杂的应用程序，日志框架是管理输出的专业且推荐方式。它提供了精细的控制粒度，并且通常对性能影响较小。
-
何时使用System.setOut()： System.setOut()在某些特定场景下非常有用，例如：
- 在测试中捕获输出进行验证。
- 在小型工具或脚本中快速将输出导向文件。
- 处理无法修改其源代码的遗留代码，这些代码大量使用了System.out.println()。
- 资源管理： 当创建自定义PrintStream或FileOutputStream时，务必在不再需要时关闭它们，以释放文件句柄和其他系统资源，防止资源泄露。try-with-resources语句是管理这些资源的好方法。
总结
要解决Java中超类构造器System.out.println()输出无法被子类System.setOut()重定向的问题，关键在于理解构造器调用的时序性：父类构造器先于子类构造器体执行。因此，System.setOut()必须在子类实例创建之前全局设置。为了同时将输出导向文件和控制台，可以实现一个自定义的TeePrintStream。然而，对于生产级的应用程序，更推荐使用功能强大的日志框架（如Logback、Log4j），它们提供了更灵活、更健壮的日志管理机制，是处理应用程序输出的最佳实践。
