Java重定向System.out与双重输出实现

本文深入探讨了在Java中，为何子类构造器中的`System.setOut()`无法直接重定向超类构造器中的`System.out.println()`输出，并详细解释了Java对象初始化顺序的影响。文章提供了多种实用策略，包括通过修改超类、在实例化前设置全局输出，以及利用自定义`TeePrintStream`或专业的日志框架来实现同时向文件和控制台输出信息，为开发者提供了全面管理程序输出流的指导。

理解Java构造器执行顺序

在Java中，当创建一个子类实例时，其构造器的执行顺序遵循一个严格的模式：首先会调用超类的构造器，然后才会执行子类构造器中super()调用之后的部分。这是Java对象初始化机制的一部分，旨在确保超类状态在子类实例化之前得到正确初始化。

考虑以下示例：

import java.io.IOException;
import java.io.PrintStream;

// 超类
public class SuperClass {
    public SuperClass() {
        System.out.println("Message from SuperClass constructor");
    }
    public void doSomething() {
        System.out.println("Message from SuperClass method");
    }
}

// 子类
public class SubClass extends SuperClass {
    private PrintStream ps;

    public SubClass() {
        super(); // 显式或隐式调用超类构造器
        try {
            ps = new PrintStream("file.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.setOut(ps); // 在超类构造器执行之后才设置System.out
        System.out.println("Message from SubClass constructor");
    }
}

当你实例化SubClass时，SuperClass的构造器会首先执行，此时System.out仍然指向默认的控制台输出。只有在SuperClass构造器执行完毕，并且SubClass构造器中的super()调用返回后，System.setOut(ps)才会被执行，将System.out重定向到文件。因此，SuperClass构造器中的System.out.println()不会被重定向到文件，而SubClass构造器以及之后的方法调用（如doSomething()）中的System.out.println()则会输出到文件。

重定向超类构造器输出的策略

由于构造器执行顺序的限制，直接在子类构造器中使用System.setOut()来捕获超类构造器中的System.out.println()输出是不可行的。要实现此目标，需要采取不同的策略。

1. 修改超类 (推荐)

如果可以修改超类的代码，最健壮和推荐的方法是让超类不再直接依赖System.out.println()，而是使用一个可配置的输出流或日志框架。

方案一：通过构造器注入PrintStream

超类可以接受一个PrintStream对象作为其构造器的参数，并将所有输出定向到该流。

// 修改后的超类
import java.io.PrintStream;

public class SuperClassModified {
    private PrintStream outputStream;

    public SuperClassModified(PrintStream os) {
        this.outputStream = os;
        this.outputStream.println("Message from SuperClassModified constructor");
    }

    public void doSomething() {
        this.outputStream.println("Message from SuperClassModified method");
    }
}

// 子类使用修改后的超类
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class SubClassWithModifiedSuper {
    public SubClassWithModifiedSuper() {
        PrintStream filePs = null;
        try {
            filePs = new PrintStream(new FileOutputStream("file.txt"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 将文件输出流传递给超类
        super(filePs); // 假设SuperClassModified有一个接受PrintStream的构造器
        // 在这里，filePs已经生效，超类构造器会输出到file.txt
        System.out.println("Message from SubClassWithModifiedSuper constructor (still to console)");
    }
}

注意： 上述SubClassWithModifiedSuper的super(filePs)需要超类有一个匹配的构造器。System.out.println()在子类中仍会输出到控制台，因为System.setOut()尚未被调用。如果子类也想重定向，需要独立设置。

方案二：使用日志框架

更专业的做法是让超类使用日志框架（如SLF4J/Logback, Log4j, java.util.logging）。日志框架提供了灵活的配置，可以轻松地将输出重定向到文件、控制台或任何其他目标，而无需修改核心业务逻辑。

// 超类使用日志框架
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SuperClassWithLogger {
    private static final Logger logger = LoggerFactory.getLogger(SuperClassWithLogger.class);

    public SuperClassWithLogger() {
        logger.info("Message from SuperClassWithLogger constructor");
    }

    public void doSomething() {
        logger.info("Message from SuperClassWithLogger method");
    }
}

// 子类或应用启动时配置日志
// 例如，通过logback.xml或log4j.properties配置，将SuperClassWithLogger的输出定向到文件。
// 子类中无需System.setOut()，只需确保日志框架已正确配置。
public class SubClassUsingLogger extends SuperClassWithLogger {
    public SubClassUsingLogger() {
        super(); // 超类构造器会使用logger输出
        // 子类可以继续使用logger或System.out，取决于需求
        System.out.println("Message from SubClassUsingLogger constructor (to console by default)");
    }
}

通过日志框架，超类和子类可以独立地配置它们的输出目标，互不干扰，且具有更强大的功能（如日志级别、格式化等）。

2. 在子类中实现 (局限性较大)

如果无法修改超类，并且必须使用System.setOut()，那么唯一的办法是在子类实例化之前就完成System.setOut()的调用。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class MainApp {
    public static void main(String[] args) {
        PrintStream filePs = null;
        try {
            filePs = new PrintStream(new FileOutputStream("redirected_output.txt"));
            // 在实例化SubClass之前，全局重定向System.out
            System.setOut(filePs);

            SubClass sub = new SubClass(); // 现在，SuperClass构造器中的System.out.println()将输出到filePs
            sub.doSomething(); // 假设SubClass继承了doSomething

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (filePs != null) {
                filePs.close();
            }
            // 考虑恢复System.out到原始控制台，如果需要
            // System.setOut(System.out); // 原始的System.out需要事先保存
        }
    }
}

// 假设SuperClass和SubClass仍是原始的，未修改的
// SuperClass:
// public class SuperClass { public SuperClass() { System.out.println("Message from SuperClass constructor"); } ... }
// SubClass:
// public class SubClass extends SuperClass { public SubClass() { super(); ... } ... }

注意事项：

• 这种方法是全局性的：一旦System.setOut()被调用，所有后续的System.out.println()都会被重定向，直到再次调用System.setOut()改变它。
• 通常需要在应用程序的启动阶段（如main方法开始时）执行此操作。
• 如果需要同时输出到控制台，此方法不能直接实现，需要结合下一节的“双重输出”方案。

实现控制台与文件双重输出

有时，我们希望程序输出既能显示在控制台，又能同时写入到文件中。这可以通过自定义PrintStream或使用日志框架来实现。

1. 自定义TeePrintStream

TeePrintStream（“Tee”指T形管，表示分流）是一个自定义的PrintStream，它将所有写入操作转发给两个或多个内部PrintStream对象。

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;

/**
 * 一个PrintStream，将其所有输出同时发送到两个底层PrintStream。
 */
class TeePrintStream extends PrintStream {
    private final PrintStream primary;
    private final PrintStream secondary;

    public TeePrintStream(OutputStream out1, OutputStream out2) {
        super(out1);
        this.primary = new PrintStream(out1);
        this.secondary = new PrintStream(out2);
    }

    @Override
    public void write(int b) {
        primary.write(b);
        secondary.write(b);
    }

    @Override
    public void write(byte[] buf, int off, int len) {
        primary.write(buf, off, len);
        secondary.write(buf, off, len);
    }

    @Override
    public void flush() {
        primary.flush();
        secondary.flush();
    }

    @Override
    public void close() {
        primary.close();
        secondary.close();
        super.close(); // 关闭自身的底层流
    }
}

使用示例：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class DualOutputExample {
    public static void main(String[] args) {
        PrintStream originalOut = System.out; // 保存原始的System.out
        PrintStream filePs = null;

        try {
            filePs = new PrintStream(new FileOutputStream("dual_output.txt"));
            // 创建一个TeePrintStream，同时输出到文件和原始的控制台
            TeePrintStream teePs = new TeePrintStream(filePs, originalOut);

            System.setOut(teePs); // 设置为新的TeePrintStream

            System.out.println("This message goes to both console and file.");
            System.out.println("Another message here.");

            // 实例化原始的SubClass，其SuperClass构造器输出也将被重定向到两者
            SubClass sub = new SubClass(); // 假设SubClass是原始的，其中System.setOut()被注释掉
            sub.doSomething(); // 假设SuperClass有一个doSomething方法

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (System.out instanceof TeePrintStream) {
                System.out.close(); // 关闭TeePrintStream及其内部流
            }
            // 恢复System.out到原始控制台，以防后续代码需要
            System.setOut(originalOut); 
            if (filePs != null) {
                filePs.close(); // 确保文件流被关闭，尽管teePs.close()应该已经处理了
            }
        }
        System.out.println("Back to console only.");
    }
}

在这个例子中，System.setOut()在SubClass实例化之前被调用，因此SuperClass构造器的输出也会被TeePrintStream捕获，同时写入文件和控制台。

2. 使用Java日志框架 (推荐)

日志框架是处理应用程序输出最灵活和强大的方式。它们天生支持多目标输出（Appender），并提供日志级别、格式化、异步写入等高级功能。

示例（使用Logback）：

1. 添加依赖：

   
       ch.qos.logback
       logback-classic
       1.2.3 
   

2. logback.xml配置（放置在src/main/resources）：

   
       
           
               %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
           
       
   
       
           application.log
           
               %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
           
       
   
       
           
           
       
   

3. 在代码中使用Logger：

   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   // 超类
   public class SuperClassWithLogger {
       private static final Logger logger = LoggerFactory.getLogger(SuperClassWithLogger.class);
   
       public SuperClassWithLogger() {
           logger.info("Message from SuperClassWithLogger constructor");
       }
       public void doSomething() {
           logger.info("Message from SuperClassWithLogger method");
       }
   }
   
   // 子类
   public class SubClassWithLogger extends SuperClassWithLogger {
       private static final Logger logger = LoggerFactory.getLogger(SubClassWithLogger.class);
   
       public SubClassWithLogger() {
           super(); // 超类构造器中的日志会根据logback.xml配置输出
           logger.info("Message from SubClassWithLogger constructor");
       }
   }
   
   public class AppMain {
       public static void main(String[] args) {
           new SubClassWithLogger();
           // 所有通过logger输出的信息都会同时写入控制台和application.log文件
           // 注意：System.out.println()仍然只会输出到控制台，除非也重定向System.out
           System.out.println("This is a System.out.println() call.");
       }
   }

   通过日志框架，你可以轻松地为不同类甚至不同日志消息配置不同的输出目标和级别，而无需手动管理PrintStream。

注意事项与总结

1. System.setOut()的全局性： System.setOut()会改变JVM全局的System.out引用。在多线程或大型应用中，应谨慎使用，因为它可能影响其他不期望被重定向的模块。
2. 资源管理： 当使用FileOutputStream或自定义PrintStream时，务必在不再需要时关闭它们，以避免资源泄露（如文件句柄未释放）。finally块是进行资源清理的理想场所。
3. 优先使用日志框架： 对于任何非调试性质的应用程序输出，强烈建议使用成熟的日志框架（如Logback、Log4j2或java.util.logging）。它们提供了更强大的功能、更好的性能、更灵活的配置，并且是行业标准实践。
4. 理解初始化顺序： 深入理解Java类的加载、初始化和对象创建顺序对于解决此类问题至关重要。超类构造器总是先于子类构造器执行。

通过上述策略，开发者可以有效地管理Java应用程序的输出流，无论是重定向超类构造器的输出，还是实现同时向控制台和文件输出的功能。选择最适合项目需求和可维护性的方法至关重要。