Java中父类构造器System.out重定向与多目标输出管理

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

// 父类
public class SuperClass {
    public SuperClass() {
        System.out.println("SuperClass constructor message"); // 此处输出到默认System.out
    }
}

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

    public SubClass() {
        // super() 在这里隐式或显式调用，先执行SuperClass构造函数
        super(); 

        try {
            ps = new PrintStream("file.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.setOut(ps); // 此处才进行重定向
        System.out.println("SubClass constructor message"); // 此处输出到file.txt
    }
}

handlers = java.util.logging.ConsoleHandler, java.util.logging.FileHandler

java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

java.util.logging.FileHandler.level = INFO
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
java.util.logging.FileHandler.pattern = myapp.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.append = true

.level = INFO

import java.util.logging.ConsoleHandler;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.io.IOException;

// 父类
public class SuperClass {
    private static final Logger logger = Logger.getLogger(SuperClass.class.getName());

    public SuperClass() {
        logger.log(Level.INFO, "SuperClass constructor message via Logger");
    }
}

// 子类
public class SubClass extends SuperClass {
    private static final Logger logger = Logger.getLogger(SubClass.class.getName());

    public SubClass() {
        super(); // 调用父类构造函数，其日志会通过配置的Logger输出
        logger.log(Level.INFO, "SubClass constructor message via Logger");
    }

    public static void main(String[] args) {
        // 在应用程序启动时设置日志配置
        try {
            // 加载logging.properties文件
            // System.setProperty("java.util.logging.config.file", "logging.properties");
            // LogManager.getLogManager().readConfiguration();

            // 或者直接在代码中配置Handler
            Logger rootLogger = Logger.getLogger(""); // 获取根Logger
            rootLogger.setLevel(Level.INFO);

            // 移除默认的ConsoleHandler，避免重复输出
            for (java.util.logging.Handler handler : rootLogger.getHandlers()) {
                rootLogger.removeHandler(handler);
            }

            ConsoleHandler consoleHandler = new ConsoleHandler();
            consoleHandler.setLevel(Level.INFO);
            rootLogger.addHandler(consoleHandler);

            FileHandler fileHandler = new FileHandler("application.log", true); // true表示追加
            fileHandler.setLevel(Level.INFO);
            rootLogger.addHandler(fileHandler);

        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("--- Starting application ---"); // 此时System.out仍然是默认的

        // 实例化子类，其构造函数中的日志将通过Logger输出到控制台和文件
        SubClass sub = new SubClass(); 

        System.out.println("--- Application finished ---");
    }
}

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MultiplexingPrintStream extends PrintStream {
    private final List<PrintStream> streams;

    public MultiplexingPrintStream(PrintStream... streams) {
        // 调用父类构造函数，需要一个OutputStream。
        // 这里我们可以使用一个空的OutputStream，因为实际的写入操作会委托给内部的streams。
        super(new OutputStream() {
            @Override
            public void write(int b) throws IOException {
                // Do nothing, actual writes handled by delegate streams
            }
        });
        this.streams = new ArrayList<>(Arrays.asList(streams));
    }

    @Override
    public void write(int b) {
        for (PrintStream s : streams) {
            s.write(b);
        }
    }

    @Override
    public void write(byte[] buf, int off, int len) {
        for (PrintStream s : streams) {
            s.write(buf, off, len);
        }
    }

    @Override
    public void flush() {
        for (PrintStream s : streams) {
            s.flush();
        }
    }

    @Override
    public void close() {
        for (PrintStream s : streams) {
            s.close();
        }
    }

    // 可以根据需要重写更多方法，例如println()系列，以确保它们也委托给所有流
    // 但通常调用write()就足够了，因为println()最终会调用write()
}

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

public class MainApp {

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

        try {
            filePs = new PrintStream(new FileOutputStream("combined_output.log", true)); // 追加模式

            // 创建一个多路输出流，同时写入原始控制台和文件
            MultiplexingPrintStream multiPs = new MultiplexingPrintStream(originalOut, filePs);
            System.setOut(multiPs); // 设置为新的System.out

            System.out.println("--- Application started (redirected) ---"); // 这条消息会同时出现在控制台和文件

            // 实例化子类，其父类构造函数中的System.out.println也会被重定向
            SubClass sub = new SubClass(); 

            System.out.println("--- Application finished (redirected) ---");

        } catch (IOException e) {
            e.printStackTrace();
            // 如果文件操作失败，至少恢复System.out以确保后续输出可见
            System.setOut(originalOut); 
            System.err.println("Failed to redirect System.out: " + e.getMessage());
        } finally {
            // 恢复System.out到原始状态（可选，但在某些场景下很重要）
            // System.setOut(originalOut); 
            if (filePs != null) {
                filePs.close();
            }
        }
    }
}

// 假设SuperClass和SubClass仍使用System.out.println()
class SuperClass {
    public SuperClass() {
        System.out.println("SuperClass constructor message from MainApp");
    }
}

class SubClass extends SuperClass {
    public SubClass() {
        super();
        System.out.println("SubClass constructor message from MainApp");
    }
}