动态调用Java方法时捕获控制台输出：重定向System.out的实践指南

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

// 假设这是您动态编译并加载的类
class UserProvidedCode {
    public static void main(String[] args) {
        System.out.println("Hello from user code!");
        System.err.println("An error message from user code."); 
        System.out.print("Another line of output.");
    }

    public String calculateSum(int a, int b) {
        int sum = a + b;
        System.out.println("Calculating sum: " + a + " + " + b);
        return "Sum is: " + sum;
    }
}

public class DynamicOutputCapturer {

    /**
     * 捕获指定方法执行时的System.out和System.err输出。
     *
     * @param targetClass 目标类
     * @param methodName 目标方法名
     * @param paramTypes 目标方法的参数类型数组
     * @param args 目标方法的参数值数组
     * @return 包含标准输出和标准错误的字符串
     * @throws NoSuchMethodException 如果找不到指定方法
     * @throws InvocationTargetException 如果被调用的方法抛出异常
     * @throws IllegalAccessException 如果无法访问指定方法
     */
    public static String captureMethodOutput(Class<?> targetClass, String methodName, Class<?>[] paramTypes, Object[] args)
            throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        // 保存原始的System.out和System.err流
        PrintStream originalOut = System.out;
        PrintStream originalErr = System.err;

        // 创建用于捕获输出的字节数组输出流
        ByteArrayOutputStream baosOut = new ByteArrayOutputStream();
        ByteArrayOutputStream baosErr = new ByteArrayOutputStream();

        // 创建新的PrintStream，将其指向字节数组输出流
        PrintStream newOut = new PrintStream(baosOut, true); // true表示自动刷新
        PrintStream newErr = new PrintStream(baosErr, true);

        try {
            // 重定向System.out和System.err
            System.setOut(newOut);
            System.setErr(newErr);

            // 获取并调用目标方法
            Method method = targetClass.getMethod(methodName, paramTypes);
            Object instance = null;

            // 如果方法不是静态的，需要创建类的实例
            if (!Modifier.isStatic(method.getModifiers())) {
                try {
                    instance = targetClass.newInstance(); // 尝试调用无参构造函数
                } catch (InstantiationException e) {
                    // 如果类没有公共的无参构造函数，将无法创建实例
                    System.err.println("Error: Cannot create instance for non-static method. " +
                                       "Class " + targetClass.getName() + " may lack a public no-arg constructor.");
                    throw new RuntimeException("Failed to instantiate class: " + targetClass.getName(), e);
                }
            }

            // 调用目标方法
            Object returnValue = method.invoke(instance, args);

            // 确保所有缓冲区内容被写入
            newOut.flush();
            newErr.flush();

            // 获取捕获到的输出内容
            String capturedStandardOutput = baosOut.toString();
            String capturedErrorOutput = baosErr.toString();

            StringBuilder result = new StringBuilder();
            if (returnValue != null) {
                result.append("Method Return Value: ").append(returnValue.toString()).append("\n");
            }
            if (!capturedStandardOutput.isEmpty()) {
                result.append("Standard Output:\n").append(capturedStandardOutput);
            }
            if (!capturedErrorOutput.isEmpty()) {
                result.append("Error Output:\n").append(capturedErrorOutput);
            }

            return result.toString();

        } finally {
            // 恢复原始的System.out和System.err
            System.setOut(originalOut);
            System.setErr(originalErr);
            // 关闭新的PrintStream
            newOut.close();
            newErr.close();
            // ByteArrayOutputStream不需要手动关闭，因为它基于内存
        }
    }

    public static void main(String[] args) {
        try {
            // 示例1: 调用UserProvidedCode的main方法并捕获输出
            System.out.println("--- 捕获 UserProvidedCode.main() 的输出 ---");
            String mainOutput = captureMethodOutput(UserProvidedCode.class, "main", new Class[]{String[].class}, new Object[]{new String[0]});
            System.out.println("捕获结果:\n" + mainOutput);

            // 示例2: 调用UserProvidedCode的calculateSum方法并捕获输出
            System.out.println("\n--- 捕获 UserProvidedCode.calculateSum(5, 3) 的输出 ---");
            String sumOutput = captureMethodOutput(UserProvidedCode.class, "calculateSum", new Class[]{int.class, int.class}, new Object[]{5, 3});
            System.out.println("捕获结果:\n" + sumOutput);

            // 验证原始的System.out是否已恢复
            System.out.println("\n--- 原始 System.out 已恢复 ---");
            System.out.println("这条消息应该正常打印到控制台。");

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