本文深入探讨了在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()也会被捕获并同时输出到文件和控制台。
灵云AI开放平台
灵云AI开放平台
150 查看详情 
解决方案二：采用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），它们提供了更灵活、更健壮的日志管理机制，是处理应用程序输出的最佳实践。
以上就是Java中重定向超类构造器System.out输出的策略与最佳实践的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/764547.html
微信扫一扫 
支付宝扫一扫 
