Java中重定向超类构造器System.out输出与实现双重输出

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");
    }
}

// 修改后的超类
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)");
    }
}

// 超类使用日志框架
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)");
    }
}

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(); ... } ... }

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.");
    }
}