Ausführen einer Java-Anwendung in einem separaten Prozess

Question

Kann eine Java-Anwendung plattformunabhängig in einem separaten Prozess unter Verwendung ihres Namens und nicht ihres Speicherorts geladen werden?

Ich weiß, dass man ein Programm über ... ausführen kann.

Process process = Runtime.getRuntime().exec( COMMAND );

... das Hauptproblem dieser Methode ist, dass solche Aufrufe dann plattformspezifisch sind.

Im Idealfall würde ich eine Methode in etwas so Einfaches wie... verpacken.

EXECUTE.application( CLASS_TO_BE_EXECUTED );

... und geben Sie den voll qualifizierten Namen einer Anwendungsklasse als CLASS_TO_BE_EXECUTED .

Answer 1

Dies ist eine Zusammenfassung einiger der anderen Antworten, die gegeben wurden. Die Java-Systemeigenschaften bieten genügend Informationen, um den Pfad zum Java-Befehl und den Klassenpfad auf eine, wie ich glaube, plattformunabhängige Weise zu ermitteln.

public final class JavaProcess {

    private JavaProcess() {}        

    public static int exec(Class klass, List<String> args) throws IOException,
                                               InterruptedException {
        String javaHome = System.getProperty("java.home");
        String javaBin = javaHome +
                File.separator + "bin" +
                File.separator + "java";
        String classpath = System.getProperty("java.class.path");
        String className = klass.getName();

        List<String> command = new LinkedList<String>();
        command.add(javaBin);
        command.add("-cp");
        command.add(classpath);
        command.add(className);
        if (args != null) {
            command.addAll(args);
        }

        ProcessBuilder builder = new ProcessBuilder(command);

        Process process = builder.inheritIO().start();
        process.waitFor();
        return process.exitValue();
    }

}

Sie würden diese Methode wie folgt ausführen:

int status = JavaProcess.exec(MyClass.class, args);

Ich dachte, es machte Sinn, in der tatsächlichen Klasse statt der String-Darstellung des Namens übergeben, da die Klasse in den Klassenpfad sowieso für diese zu arbeiten hat.

Answer 2

Zwei Hinweise:

System.getProperty("java.home") + "/bin/java" gibt Ihnen einen Pfad zur ausführbaren Java-Datei.

((URLClassLoader) Thread.currentThread().getContextClassLoader()).getURL() hilft Ihnen, den Klassenpfad der aktuellen Anwendung zu rekonstruieren.

Dann wird Ihr EXECUTE.application ist einfach (Pseudocode):

Process.exec(javaExecutable, "-classpath", urls.join(":"), CLASS_TO_BE_EXECUTED)

Answer 3

Das mag für Sie ein Overkill sein, aber Projekt Akuma tut, was Sie wollen und mehr. Ich habe es gefunden über diese Eingabe in Kohsukes (einem von Suns Startprogrammierern) fabelhaft nützlichem Blog.

Answer 4

In Erweiterung der Antwort von @stepancheg würde der eigentliche Code so aussehen (in Form eines Tests).

import org.junit.Test;

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Arrays;
import java.util.stream.Collectors;

public class SpinningUpAJvmTest {
    @Test
    public void shouldRunAJvm() throws Exception {
        String classpath = Arrays.stream(((URLClassLoader) Thread.currentThread().getContextClassLoader()).getURLs())
                .map(URL::getFile)
                .collect(Collectors.joining(File.pathSeparator));
        Process process = new ProcessBuilder(
                System.getProperty("java.home") + "/bin/java",
                "-classpath",
                classpath,
                MyMainClass.class.getName()
                // main class arguments go here
        )
                .inheritIO()
                .start();
        int exitCode = process.waitFor();
        System.out.println("process stopped with exitCode " + exitCode);
    }
}

Answer 5

public abstract class EXECUTE {

    private EXECUTE() { /* Procedural Abstract */ }

    public static Process application( final String CLASS_TO_BE_EXECUTED ) {

        final String EXEC_ARGUMENT 
        = new StringBuilder().
              append( java.lang.System.getProperty( "java.home" ) ).
              append( java.io.File.separator ).
              append( "bin" ).
              append( java.io.File.separator ).
              append( "java" ).
              append( " " ).
              append( new java.io.File( "." ).getAbsolutePath() ).
              append( java.io.File.separator ).
              append( CLASS_TO_BE_EXECUTED ).
              toString();

        try {       

            return Runtime.getRuntime().exec( EXEC_ARGUMENT );

        } catch ( final Exception EXCEPTION ) {     

            System.err.println( EXCEPTION.getStackTrace() );
        }

        return null;
    }
}