Wie kann ich eine Java AWT-Anwendung neu starten? Ich habe eine Schaltfläche, an die ich einen Ereignishandler angehängt habe. Welchen Code soll ich verwenden, um die Anwendung neu zu starten?

Ich möchte das Gleiche tun Application.Restart()wie in einer C # -Anwendung.

Natürlich ist es möglich, eine Java-Anwendung neu zu starten.

Die folgende Methode zeigt eine Möglichkeit zum Neustarten einer Java-Anwendung:

public void restartApplication()
{
  final String javaBin = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java";
  final File currentJar = new File(MyClassInTheJar.class.getProtectionDomain().getCodeSource().getLocation().toURI());

  /* is it a jar file? */
  if(!currentJar.getName().endsWith(".jar"))
    return;

  /* Build command: java -jar application.jar */
  final ArrayList<String> command = new ArrayList<String>();
  command.add(javaBin);
  command.add("-jar");
  command.add(currentJar.getPath());

  final ProcessBuilder builder = new ProcessBuilder(command);
  builder.start();
  System.exit(0);
}

Grundsätzlich macht es folgendes:

1. Suchen Sie die ausführbare Java-Datei (ich habe hier die Java-Binärdatei verwendet, aber das hängt von Ihren Anforderungen ab).
2. Suchen Sie die Anwendung (in meinem Fall ein Glas, indem Sie die MyClassInTheJarKlasse verwenden, um den Speicherort des Glases selbst zu finden).
3. Erstellen Sie einen Befehl, um das JAR neu zu starten (in diesem Fall mit der Java-Binärdatei).
4. Führ es aus! (und damit die aktuelle Anwendung beenden und erneut 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);
    }
}

Allen gewidmet, die sagen, dass es unmöglich ist.

Dieses Programm sammelt alle verfügbaren Informationen, um die ursprüngliche Befehlszeile wiederherzustellen. Anschließend wird es gestartet, und da es sich um denselben Befehl handelt, wird Ihre Anwendung ein zweites Mal gestartet. Dann beenden wir das ursprüngliche Programm, das untergeordnete Programm läuft weiter (auch unter Linux) und macht genau das Gleiche.

WARNUNG : Wenn Sie dies ausführen, beachten Sie, dass dadurch niemals neue Prozesse erstellt werden, ähnlich wie bei einer Gabelbombe .

Grundsätzlich kann man nicht. Zumindest nicht zuverlässig. Sie sollten jedoch nicht müssen.

Das kann sich nicht trennen

Um ein Java-Programm neu zu starten, müssen Sie die JVM neu starten. Um die JVM neu zu starten, müssen Sie

1. Suchen Sie den verwendeten javaLauncher. Sie können es versuchen, System.getProperty("java.home")aber es gibt keine Garantie dafür, dass dies tatsächlich auf den Launcher verweist, mit dem Ihre Anwendung gestartet wurde. (Der zurückgegebene Wert verweist möglicherweise nicht auf die JRE, die zum Starten der Anwendung verwendet wurde, oder wurde möglicherweise von überschrieben -Djava.home.)

2. Sie würden vermutlich wollen die ursprünglichen Speichereinstellungen usw. (ehren -Xmx, -Xms...) , so dass Sie Abbildung benötigen Sie heraus , welche Einstellungen verwendet , bei denen die ersten JVM zu starten. Sie könnten es versuchen, ManagementFactory.getRuntimeMXBean().getInputArguments()aber es gibt keine Garantie dafür, dass dies die verwendeten Einstellungen widerspiegelt. Dies wird sogar in der Dokumentation dieser Methode beschrieben:

   In der Regel werden nicht alle Befehlszeilenoptionen für den Befehl 'java' an die virtuelle Java-Maschine übergeben. Daher enthalten die zurückgegebenen Eingabeargumente möglicherweise nicht alle Befehlszeilenoptionen.

3. Wenn Ihr Programm Eingaben vom Standard.inursprünglichen Standard liest, gehen diese beim Neustart verloren.

4. Viele dieser Tricks und Hacks werden in Gegenwart von a fehlschlagen SecurityManager.

Das sollte kein Teil brauchen

Ich empfehle Ihnen, Ihre Anwendung so zu gestalten, dass es einfach ist, alles zu bereinigen und anschließend eine neue Instanz Ihrer "Haupt" -Klasse zu erstellen.

Viele Anwendungen sind so konzipiert, dass sie nur eine Instanz in der Hauptmethode erstellen:

public class MainClass {
    ...
    public static void main(String[] args) {
        new MainClass().launch();
    }
    ...
}

Mit diesem Muster sollte es einfach genug sein, Folgendes zu tun:

public class MainClass {
    ...
    public static void main(String[] args) {
        boolean restart;
        do {
            restart = new MainClass().launch();
        } while (restart);
    }
    ...
}

und lassen Sie launch()true nur dann zurück, wenn die Anwendung so heruntergefahren wurde, dass sie neu gestartet werden muss.

Genau genommen kann sich ein Java-Programm nicht selbst neu starten, da es dazu die JVM, in der es ausgeführt wird, beenden und dann erneut starten muss. Sobald die JVM jedoch nicht mehr ausgeführt (beendet) wird, kann keine Aktion ausgeführt werden.

Sie können mit benutzerdefinierten Klassenladeprogrammen einige Tricks ausführen, um die AWT-Komponenten zu laden, zu packen und erneut zu starten. Dies verursacht jedoch wahrscheinlich viele Kopfschmerzen in Bezug auf die GUI-Ereignisschleife.

Abhängig davon, wie die Anwendung gestartet wird, können Sie die JVM in einem Wrapper-Skript starten, das eine do / while-Schleife enthält, die fortgesetzt wird, während die JVM mit einem bestimmten Code beendet wird. Dann müsste die AWT-App aufrufen System.exit(RESTART_CODE). Zum Beispiel beim Skripting von Pseudocode:

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

Die AWT-App sollte die JVM mit etwas anderem als RESTART_CODE bei "normaler" Beendigung beenden, für die kein Neustart erforderlich ist.

Eclipse wird normalerweise neu gestartet, nachdem ein Plugin installiert wurde. Sie tun dies mit einem Wrapper eclipse.exe (Launcher-App) für Windows. Diese Anwendung führt das Kern-Eclipse-Runner-JAR aus. Wenn die Eclipse-Java-Anwendung mit einem Relaunch-Code beendet wird, startet eclipse.exe die Workbench neu. Sie können ein ähnliches Stück nativen Codes, ein Shell-Skript oder einen anderen Java-Code-Wrapper erstellen, um den Neustart zu erreichen.

Windows

public void restartApp(){

    // This launches a new instance of application dirctly, 
    // remember to add some sleep to the start of the cmd file to make sure current instance is
    // completely terminated, otherwise 2 instances of the application can overlap causing strange
    // things:)

    new ProcessBuilder("cmd","/c start /min c:/path/to/script/that/launches/my/application.cmd ^& exit").start();
    System.exit(0);
}

/ min , um das Skript im minimierten Fenster zu starten

^ & Beenden, um das cmd-Fenster nach Abschluss zu schließen

Ein Beispiel-Cmd-Skript könnte sein

@echo off
rem add some sleep (e.g. 10 seconds) to allow the preceding application instance to release any open resources (like ports) and exit gracefully, otherwise the new instance could fail to start
sleep 10   
set path=C:\someFolder\application_lib\libs;%path%
java -jar application.jar

Schlaf 10 Schlaf für 10 Sekunden

Wenn Sie Ihre App wirklich neu starten müssen, können Sie beim Starten eine separate App schreiben ...

Diese Seite enthält viele verschiedene Beispiele für verschiedene Szenarien:

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

Obwohl diese Frage alt und beantwortet ist, bin ich auf ein Problem mit einigen der Lösungen gestoßen und habe beschlossen, meinen Vorschlag in die Mischung aufzunehmen.

Das Problem bei einigen Lösungen besteht darin, dass sie eine einzelne Befehlszeichenfolge erstellen. Dies führt zu Problemen, wenn einige Parameter Leerzeichen enthalten, insbesondere java.home .

Zum Beispiel unter Windows die Linie

final String javaBin = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java";

Könnte so etwas zurückgeben:C:\Program Files\Java\jre7\bin\java

Diese Zeichenfolge muss in Anführungszeichen gesetzt oder aufgrund des Leerzeichens in maskiert werden Program Files. Kein großes Problem, aber etwas nervig und fehleranfällig, insbesondere bei plattformübergreifenden Anwendungen.

Daher erstellt meine Lösung den Befehl als Array von Befehlen:

public static void restart(String[] args) {

        ArrayList<String> commands = new ArrayList<String>(4 + jvmArgs.size() + args.length);
        List<String> jvmArgs = ManagementFactory.getRuntimeMXBean().getInputArguments();

        // Java
        commands.add(System.getProperty("java.home") + File.separator + "bin" + File.separator + "java");

        // Jvm arguments
        for (String jvmArg : jvmArgs) {
            commands.add(jvmArg);
        }

        // Classpath
        commands.add("-cp");
        commands.add(ManagementFactory.getRuntimeMXBean().getClassPath());

        // Class to be executed
        commands.add(BGAgent.class.getName());

        // Command line arguments
        for (String arg : args) {
            commands.add(arg);
        }

        File workingDir = null; // Null working dir means that the child uses the same working directory

        String[] env = null; // Null env means that the child uses the same environment

        String[] commandArray = new String[commands.size()];
        commandArray = commands.toArray(commandArray);

        try {
            Runtime.getRuntime().exec(commandArray, env, workingDir);
            System.exit(0);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Ich habe das Thema selbst recherchiert, als ich auf diese Frage stieß.

Ungeachtet der Tatsache, dass die Antwort bereits akzeptiert wird, möchte ich der Vollständigkeit halber noch einen alternativen Ansatz anbieten. Insbesondere Apache Ant diente als sehr flexible Lösung.

Grundsätzlich läuft alles auf eine Ant-Skriptdatei mit einer einzigen Java-Ausführungsaufgabe hinaus (siehe hier) und hier ) hinaus, die von einem Java-Code aus aufgerufen wird (siehe hier ). Dieser Java - Code, der eine Methode sein kann , Start , könnte ein Teil der Anwendung sein , die neu gestartet werden muss. Die Anwendung muss von der Apache Ant-Bibliothek (jar) abhängig sein.

Wann immer die Anwendung neu gestartet werden muss, sollte sie method aufrufen Einführung und die VM beenden. Für die Ant-Java-Aufgabe sollten die Optionen Fork und Spawn auf true gesetzt sein.

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>

Der Code für die Startmethode sieht möglicherweise folgendermaßen aus:

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);

}}

Sehr praktisch ist, dass das gleiche Skript sowohl für den ersten Start der Anwendung als auch für Neustarts verwendet wird.

Fügen Sie einfach Informationen hinzu, die in anderen Antworten nicht vorhanden sind.

Wenn procfs /proc/self/cmdline verfügbar ist

Wenn Sie in einer Umgebung ausgeführt werden, die procfs bereitstellt und daher über das /procDateisystem verfügt (was bedeutet, dass dies keine tragbare Lösung ist), können Sie Java lesen lassen /proc/self/cmdline, um sich selbst neu zu starten.

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 /proc/self/cmdlineverfügbaren Systemen ist dies wahrscheinlich die eleganteste Methode, um den aktuellen Java-Prozess von Java aus neu zu starten. Kein JNI beteiligt und kein Erraten von Pfaden und Sachen erforderlich. Dadurch werden auch alle an die javaBinärdatei übergebenen JVM-Optionen berücksichtigt . Die Befehlszeile ist genau identisch mit der des aktuellen JVM-Prozesses.

Viele UNIX-Systeme, einschließlich GNU / Linux (einschließlich Android), haben heutzutage procfs. Bei einigen wie FreeBSD ist es jedoch veraltet und wird auslaufen. Mac OS X ist eine Ausnahme in dem Sinne, dass es keine Prozesse gibt . Windows hat auch keine procfs . Cygwin hat Prozesse jedoch für Java nicht sichtbar, da es nur für Anwendungen sichtbar ist, die Cygwin-DLLs anstelle von Windows-Systemaufrufen verwenden, und Java Cygwin nicht kennt.

Vergiss nicht zu benutzen ProcessBuilder.inheritIO()

Die Standardeinstellung ist, dass stdin/ stdout/ stderr(in Java mit dem Namen System.in/ System.out/ System.err) des gestarteten Prozesses auf Pipes gesetzt sind, die es dem aktuell ausgeführten Prozess ermöglichen, mit dem neu gestarteten Prozess zu kommunizieren. Wenn Sie den aktuellen Prozess neu starten möchten, ist dies höchstwahrscheinlich nicht das, was Sie möchten . Stattdessen möchten Sie, dass stdin// stdout/ stderrdieselben wie die der aktuellen VM sind. Dies wird als geerbt bezeichnet . Sie können dies tun, indem Sie inheritIO()Ihren Anruf tätigenProcessBuilder Instanz .

Fallstricke unter Windows

Ein häufiger Anwendungsfall einer restart()Funktion ist das Neustarten der Anwendung nach einem Update. Das letzte Mal, als ich dies unter Windows versuchte, war dies problematisch. Beim Überschreiben der Anwendungsdatei .jarmit der neuen Version begann sich die Anwendung schlecht zu verhalten und gab Ausnahmen über die .jarDatei aus. Ich sage nur, falls dies Ihr Anwendungsfall ist. Damals löste ich das Problem, indem ich die Anwendung in eine Batch-Datei einwickelte und einen magischen Rückgabewert verwendete System.exit(), den ich in der Batch-Datei abgefragt hatte, und stattdessen die Batch-Datei die Anwendung neu starten ließ.

Alte Frage und all das. Dies ist jedoch ein weiterer Weg, der einige Vorteile bietet.

Unter Windows können Sie den Taskplaner bitten, Ihre App erneut für Sie zu starten. Dies hat den Vorteil, dass Sie eine bestimmte Zeit warten müssen, bevor die App neu gestartet wird. Sie können zum Task-Manager gehen und die Task löschen. Die Wiederholung wird beendet.

SimpleDateFormat hhmm = new SimpleDateFormat("kk:mm");    
Calendar aCal = Calendar.getInstance(); 
aCal.add(Calendar.SECOND, 65);
String nextMinute = hhmm.format(aCal.getTime()); //Task Scheduler Doesn't accept seconds and won't do current minute.
String[] create = {"c:\\windows\\system32\\schtasks.exe", "/CREATE", "/F", "/TN", "RestartMyProg", "/SC", "ONCE", "/ST", nextMinute, "/TR", "java -jar c:\\my\\dev\\RestartTest.jar"};  
Process proc = Runtime.getRuntime().exec(create, null, null);
System.out.println("Exit Now");
try {Thread.sleep(1000);} catch (Exception e){} // just so you can see it better
System.exit(0);

Ähnlich wie Yodas ' verbesserte ' Antwort, jedoch mit weiteren Verbesserungen (sowohl Funktionalität, Lesbarkeit als auch Testbarkeit). Die Ausführung ist jetzt sicher und wird so oft neu gestartet, wie die Anzahl der angegebenen Programmargumente.

• Keine Anhäufung von JAVA_TOOL_OPTIONSOptionen.
• Findet die Hauptklasse automatisch.
• Erbt das aktuelle 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: Nullzeiger, wenn JAVA_TOOL_OPTIONS nicht gesetzt ist

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]
$

System.err.println("Someone is Restarting me...");
setVisible(false);
try {
    Thread.sleep(600);
} catch (InterruptedException e1) {
    e1.printStackTrace();
}
setVisible(true);

Ich denke, Sie möchten die Anwendung nicht wirklich stoppen, sondern neu starten. Dazu können Sie dies verwenden und Ihren "Reset" vor dem Ruhezustand und nach dem unsichtbaren Fenster hinzufügen.