捕获Java反射调用void方法时的控制台输出

package online_compiler.web;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.StringWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.ToolProvider;

public class OnlineCompilerUtil {

    /**
     * Helper class to represent Java source code from a string.
     */
    static class JavaSourceFromString extends SimpleJavaFileObject {
        final String code;

        JavaSourceFromString(String name, String code) {
            super(URI.create("string:///" + name.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
            this.code = code;
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return code;
        }
    }

    /**
     * Compiles and runs a given Java source code, capturing its standard output.
     *
     * @param className   The name of the main class in the source code.
     * @param sourceCode  The Java source code to compile and run.
     * @param outputDir   The directory where compiled classes will be placed and loaded from.
     * @return            The captured standard output of the executed program, or compilation errors.
     * @throws ClassNotFoundException      If the compiled class cannot be found.
     * @throws NoSuchMethodException       If the main method is not found.
     * @throws SecurityException           If a security manager denies access.
     * @throws IllegalAccessException      If the main method is inaccessible.
     * @throws IllegalArgumentException    If arguments for main method are invalid.
     * @throws InvocationTargetException   If the invoked main method throws an exception.
     * @throws MalformedURLException       If the output directory path is invalid.
     * @throws IOException                 If there's an error with I/O streams.
     */
    public static String compileAndRun(String className, String sourceCode, String outputDir)
            throws ClassNotFoundException, NoSuchMethodException, SecurityException,
                   IllegalAccessException, IllegalArgumentException, InvocationTargetException,
                   MalformedURLException, IOException {

        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        if (compiler == null) {
            return "Error: JDK is required to run the compiler. JRE does not include it.";
        }

        // 1. Compile the source code
        JavaSourceFromString jsfs = new JavaSourceFromString(className, sourceCode);
        Iterable<? extends JavaFileObject> fileObjects = Arrays.asList(jsfs);

        List<String> options = new ArrayList<>();
        // Set the output directory for compiled classes
        options.add("-d");
        options.add(outputDir);
        // Add the output directory to the classpath for class loading
        options.add("-classpath");
        options.add(outputDir);

        StringWriter compilationOutput = new StringWriter(); // To capture compiler messages (errors/warnings)
        boolean success = compiler.getTask(compilationOutput, null, null, options, null, fileObjects).call();

        if (!success) {
            // If compilation fails, return the compiler's output
            return "Compilation failed:\n" + compilationOutput.toString();
        }

        // 2. Capture System.out for runtime output
        PrintStream originalOut = System.out; // Save original System.out
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        // Create a new PrintStream that writes to our ByteArrayOutputStream
        // 'true' for auto-flush, "UTF-8" for character encoding
        PrintStream newOut = new PrintStream(baos, true, "UTF-8");

        try {
            System.setOut(newOut); // Redirect System.out

            // Load the compiled class using a URLClassLoader
            URLClassLoader classLoader = URLClassLoader.newInstance(new URL[]{new java.io.File(outputDir).toURI().toURL()});
            Class<?> cls = Class.forName(className, true, classLoader);

            // Get the 'main' method (public static void main(String[] args))
            Method mainMethod = cls.getMethod("main", new Class[]{String[].class});
            Object[] mainArgs = new Object[]{new String[0]}; // Arguments for main method

            // Invoke the method. For void methods, this will return null.
            // The actual output is captured by redirecting System.out.
            mainMethod.invoke(null, mainArgs); // For static methods, the object can be null

            // Return the captured output as a string
            return baos.toString("UTF-8");

        } finally {
            System.setOut(originalOut); // *** ALWAYS RESTORE ORIGINAL System.out ***
            // Close the streams to release resources
            if (newOut != null) {
                newOut.close();
            }
            if (baos != null) {
                baos.close();
            }
        }
    }

    public static void main(String[] args) {
        // Example program to compile and run
        String program = "public class Main{" +
                " public static void main (String [] args){" +
                " System.out.println (\"Hello, World from Main!\");" +
                " System.err.println(\"This is an error message on System.err.\");" + // Note: System.err is not redirected here
                " int x = 10;" +
                " System.out.println(\"The value of x is: \" + x);" +
                " }" +
                "}";
        String className = "Main";
        // Use a temporary directory for compiled classes
        String tempDir = System.getProperty("java.io.tmpdir") + java.io.File.separator + "compiled_classes";
        new java.io.File(tempDir).mkdirs(); // Ensure directory exists

        try {
            System.out.println("Compiling and running program...");
            String output = compileAndRun(className, program, tempDir);
            System.out.println("\n--- Captured Program Output ---");
            System.out.println(output);
            System.out.println("------------------------------");
        } catch (Exception e) {
            System.err.println("An error occurred during compilation or execution: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // Optional: Clean up compiled class files
            // new java.io.File(tempDir, className + ".class").delete();
            // new java.io.File(tempDir).delete(); // Only if directory is empty
        }
    }
}