Wie kann ich eine Java-Anwendung neu starten?

import java.io.File;
import java.io.IOException;
import java.lang.management.ManagementFactory;

public class Main {
    public static void main(String[] args) throws IOException, InterruptedException {
        StringBuilder cmd = new StringBuilder();
        cmd.append(System.getProperty("java.home") + File.separator + "bin" + File.separator + "java ");
        for (String jvmArg : ManagementFactory.getRuntimeMXBean().getInputArguments()) {
            cmd.append(jvmArg + " ");
        }
        cmd.append("-cp ").append(ManagementFactory.getRuntimeMXBean().getClassPath()).append(" ");
        cmd.append(Main.class.getName()).append(" ");
        for (String arg : args) {
            cmd.append(arg).append(" ");
        }
        Runtime.getRuntime().exec(cmd.toString());
        System.exit(0);
    }
}

All jenen gewidmet, die sagen, es ist unmöglich.

Dieses Programm sammelt alle verfügbaren Informationen zu rekonstruieren, die original-Kommandozeile. Dann startet es und da ist es genau der gleiche Befehl, Ihre Anwendung beginnt ein zweites mal. Dann verlassen wir das ursprüngliche Programm, die Kind-Programm laufen bleibt, (auch unter Linux) und hat die sehr gleiche Sache.

WARNUNG: Wenn Sie dies ausführen, werden Sie sich bewusst, dass es nie endet anlegen von neuen Prozessen, ähnlich wie ein Gabel Bombe.

InformationsquelleAutor der Antwort Meinersbur

Streng genommen, ein Java-Programm nicht neu starten, selbst da tun Sie es töten müssen, der JVM, in der es ausgeführt wird, und starten Sie es erneut, aber nach dem beenden der JVM nicht mehr ausgeführt wird (getötet), dann wird keine Maßnahme ergriffen werden kann.

Könnten Sie tun,, einige tricks mit benutzerdefinierten classloadern geladen, pack, und starten Sie den AWT-Komponenten wieder, aber dies wird wahrscheinlich dazu führen, dass viele Kopfschmerzen mit Bezug auf die GUI-event-Schleife.

Je nachdem, wie die Anwendung gestartet wird, könnte man anfangen, die JVM in ein wrapper-Skript, welches eine do/while-Schleife, die fortgesetzt, wenn die JVM beendet mit einem bestimmten code, dann die AWT-app aufrufen zu müssen System.exit(RESTART_CODE). Zum Beispiel, in scripting pseudocode:

DO
  # Launch the awt program
  EXIT_CODE = # Get the exit code of the last process
WHILE (EXIT_CODE == RESTART_CODE)

Das AWT sollte die app beenden der JVM mit etwas anderem als der RESTART_CODE auf "normale" Kündigung, die nicht erforderlich ist, neu starten.

InformationsquelleAutor der Antwort maerics

Wenn Sie wirklich brauchen, um starten Sie Ihre app, könnten Sie schreiben, eine separate app-start...

Dieser Seite finden Sie viele verschiedene Beispiele für verschiedene Szenarien:

http://www.rgagnon.com/javadetails/java-0014.html

InformationsquelleAutor der Antwort Sean W.

Recherchiere ich das Thema selber kam in dieser Frage.

Unabhängig von der Tatsache, dass die Antwort bereits akzeptiert, würde ich noch gerne eine alternative bieten Ansatz für die Vollständigkeit. Speziell, Apache Ant diente als eine sehr flexible Lösung.

Grundsätzlich, alles läuft darauf hinaus, ein Ant-script-Datei mit einem einzigen Java-Ausführung einer Aufgabe (siehe hier und hier) aufgerufen von Java-code (siehe hier). Dieser Java-code, der eine Methode startenkönnte ein Teil der Anwendung muss neu gestartet werden. Benötigt die Anwendung eine Abhängigkeit vom Apache-Ant-Bibliothek (jar).

Wenn die Anwendung neu gestartet werden muss, sollte es Methode starten und beenden der VM. Die Ant java task sollte Optionen Gabel und spawn auf true gesetzt.

Hier ist ein Beispiel für ein Ant-Skript:

<project name="applaucher" default="launch" basedir=".">
<target name="launch">
    <java classname="package.MasinClass" fork="true" spawn="true">
        <jvmarg value="-splash:splash.jpg"/>
        <jvmarg value="-D other VM params"/>
        <classpath>
            <pathelement location="lib-1.jar" />
            ...
            <pathelement location="lib-n.jar" />
        </classpath>
    </java>
</target>
</project>

Den code für die starten Methode kann wie folgt Aussehen:

public final void launch(final String antScriptFile) {
 /* configure Ant and execute the task */
   final File buildFile = new File(antScriptFile);
   final Project p = new Project();
   p.setUserProperty("ant.file", buildFile.getAbsolutePath());

   final DefaultLogger consoleLogger = new DefaultLogger();
   consoleLogger.setErrorPrintStream(System.err);
   consoleLogger.setOutputPrintStream(System.out);
   consoleLogger.setMessageOutputLevel(Project.MSG_INFO);
   p.addBuildListener(consoleLogger);

   try {
       p.fireBuildStarted();
       p.init();
       final ProjectHelper helper = ProjectHelper.getProjectHelper();
       p.addReference("ant.projectHelper", helper);
       helper.parse(p, buildFile);
       p.executeTarget(p.getDefaultTarget());
       p.fireBuildFinished(null);
   } catch (final BuildException e) {
       p.fireBuildFinished(e);
   }

   /* exit the current VM */
   System.exit(0);

}

Eine sehr bequeme Sache hier ist, dass das gleiche Skript ist für die erstmalige Anwendung start-up sowie für den Neustart.

InformationsquelleAutor der Antwort 01es

Nur das hinzufügen von Informationen, die nicht in den anderen Antworten.

Wenn procfs /proc/self/cmdline erhältlich

Wenn Sie in einer Umgebung ausgeführt, die bietet procfs und hat daher die /proc Dateisystem verfügbar ist (was bedeutet, dies ist keine portable Lösung), können Sie Java read /proc/self/cmdline um neu zu starten, so wie hier:

public static void restart() throws IOException {
    new ProcessBuilder(getMyOwnCmdLine()).inheritIO().start();
}
public static String[] getMyOwnCmdLine() throws IOException {
    return readFirstLine("/proc/self/cmdline").split("\u0000");
}
public static String readFirstLine(final String filename) throws IOException {
    try (final BufferedReader in = new BufferedReader(new FileReader(filename))) {
        return in.readLine();
    }
}

Auf Systemen mit /proc/self/cmdline zur Verfügung, das ist wohl die eleganteste Art und Weise, wie "neu" die aktuelle Java-Prozess von Java. Kein JNI eingebunden sind, und keine raten, Wege und Sachen erforderlich.

Vielen UNIX-Systemen, einschließlich GNU/Linux (einschließlich Android) haben heute procfs Jedoch auf einige wie FreeBSD, es ist veraltet und ein Auslaufmodell. Mac OS X ist eine Ausnahme in dem Sinne, dass es nicht procfs. Windows auch nicht procfs. Cygwin hat procfs aber es ist unsichtbar für Java, weil es nur sichtbar für Anwendungen, die mit der Cygwin-DLLs anstelle von Windows-system fordert, und Java ist nicht bewusst, Cygwin.

Vergessen Sie nicht, verwenden ProcessBuilder.inheritIO()

Die Standardeinstellung ist, dass stdin /stdout /stderr (in Java genannt System.in /System.out /System.err) des gestarteten Prozesses werden festgelegt, um Rohre die es erlauben, den derzeit Laufenden Prozess für die Kommunikation mit dem neu gestarteten Prozesses. Wenn Sie möchten, starten Sie den aktuellen Prozess, das ist die meisten wahrscheinlich nicht, was Sie wollen. Stattdessen würden Sie wollen, dass stdin /stdout /stderr sind die gleichen wie in der aktuellen VM. Dies wird als geerbt. Sie können dies tun, durch aufrufen inheritIO() Ihrer ProcessBuilder Instanz.

Falle auf Windows

Einen häufigen Anwendungsfall einer restart() Funktion ist, die Anwendung neu zu starten nach einem update. Das Letzte mal habe ich versucht, dieses unter Windows war dies problematisch. Wenn überschrieb die Anwendung .jar Datei mit der neuen version wird die Anwendung gestartet wird, sich schlecht zu benehmen und gibt Ausnahmen, über die .jar - Datei. Ich bin einfach nur sagen, in diesem Fall ist Ihre Verwendung. Ich habe damals das Problem gelöst, indem er die Anwendung in einer batch-Datei und mit einem Magie-Wert zurückgeben von System.exit() dass ich abgefragt in der batch-Datei hatte und die batch-Datei starten Sie die Anwendung neu statt.

InformationsquelleAutor der Antwort Christian Hujer

Ähnlich wie Yoda ' s ' verbessert " Antwort, aber mit weiteren Verbesserungen (sowohl funktionalen, Lesbarkeit und Testbarkeit). Es ist jetzt sicher zu führen, und Neustarts, wie so oft, wie die Menge von Programm-Argumenten.

• Keine Anhäufung von JAVA_TOOL_OPTIONS Optionen.
• Automatisch findet die main-Klasse.
• Erbt aktuellen stdout/stderr.

public static void main(String[] args) throws Exception {
    if (args.length == 0)
        return;
    else
        args = Arrays.copyOf(args, args.length - 1);

    List<String> command = new ArrayList<>(32);
    appendJavaExecutable(command);
    appendVMArgs(command);
    appendClassPath(command);
    appendEntryPoint(command);
    appendArgs(command, args);

    System.out.println(command);
    try {
        new ProcessBuilder(command).inheritIO().start();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

private static void appendJavaExecutable(List<String> cmd) {
    cmd.add(System.getProperty("java.home") + File.separator + "bin" + File.separator + "java");
}

private static void appendVMArgs(Collection<String> cmd) {
    Collection<String> vmArguments = ManagementFactory.getRuntimeMXBean().getInputArguments();

    String javaToolOptions = System.getenv("JAVA_TOOL_OPTIONS");
    if (javaToolOptions != null) {
        Collection<String> javaToolOptionsList = Arrays.asList(javaToolOptions.split(" "));
        vmArguments = new ArrayList<>(vmArguments);
        vmArguments.removeAll(javaToolOptionsList);
    }

    cmd.addAll(vmArguments);
}

private static void appendClassPath(List<String> cmd) {
    cmd.add("-cp");
    cmd.add(ManagementFactory.getRuntimeMXBean().getClassPath());
}

    private static void appendEntryPoint(List<String> cmd) {
    StackTraceElement[] stackTrace          = new Throwable().getStackTrace();
    StackTraceElement   stackTraceElement   = stackTrace[stackTrace.length - 1];
    String              fullyQualifiedClass = stackTraceElement.getClassName();
    String              entryMethod         = stackTraceElement.getMethodName();
    if (!entryMethod.equals("main"))
        throw new AssertionError("Entry point is not a 'main()': " + fullyQualifiedClass + '.' + entryMethod);

    cmd.add(fullyQualifiedClass);
}

private static void appendArgs(List<String> cmd, String[] args) {
    cmd.addAll(Arrays.asList(args));
}

V1.1 Bugfix: null-Zeiger, wenn JAVA_TOOL_OPTIONS ist nicht festgelegt

Beispiel:

$ java -cp Temp.jar Temp a b c d e
[/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java, -cp, Temp.jar, Temp, a, b, c, d]
[/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java, -cp, Temp.jar, Temp, a, b, c]
[/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java, -cp, Temp.jar, Temp, a, b]
[/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java, -cp, Temp.jar, Temp, a]
[/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java, -cp, Temp.jar, Temp]
$

InformationsquelleAutor der Antwort Mark Jeronimus