Wie kann ich eine Java-Anwendung neu starten?

94

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.

Azfar Niaz
quelle
2
Vielleicht verstehe ich deine Frage nicht. Sie möchten, dass Ihre Anwendung über eine Schaltfläche verfügt, mit der die Anwendung neu gestartet wird? Nachdem die App nicht mehr ausgeführt wird, sollte sie sich selbst neu starten können. Das klingt für mich unmöglich.
Jay
Ich frage das nicht, nachdem JVM gestoppt ist, ich frage, wie ich meinen Haupt-Java-Frame wieder erscheinen lassen kann.
Azfar Niaz
2
Nicht unmöglich. Ich sehe, dass die Eclipse-Workbench häufig neu gestartet wird, selbst Windows führt diesen Trick nach Updates aus. Die falsche Annahme ist, dass die Anwendung das einzige ist, auf dem nichts läuft. Wir brauchen einen Neustart-fähigen Launcher, der die Schildkröten ganz nach unten bringt.
Whatnick
Genau wie in der C # -Anwendung, wo können Sie dazu System.restart () schreiben?
Azfar Niaz
@aniaz dann sollten Sie die Frage aktualisieren, um darauf hinzuweisen, dass Sie den Rahmen ein- / ausblenden möchten. Die Anwendung ist NICHT der Frame.
Whatnick

Antworten:

104

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)
Veger
quelle
5
Gibt es nicht einen kleinen Zeitraum, in dem zwei Versionen derselben App gleichzeitig ausgeführt werden?
Monir
5
Beendet System.exit (0) den untergeordneten Prozess nicht?
Horcrux7
16
@Veger Frage, ob System.exit(0)der untergeordnete Prozess beendet wird, hat dieselbe Antwort wie ob diese Antwort wirklich funktioniert und warum. Wenn Sie Ihrer Antwort keine vernünftige Erklärung geben können, haben Sie schlechte Arbeit geleistet. Eine Antwort, die mehr Fragen liefert als beantwortet, ist kein Beispiel für eine gründliche Antwort. Gute Antworten zeigen nicht nur den Code, sondern erklären auch, wie und warum sie funktionieren, welche Nachteile sie haben und welche Alternativen es gibt. Sie haben nicht einmal versucht, diese Dinge zu behandeln.
Tomáš Zato - Wiedereinsetzung von Monica
8
So viele Kommentare darüber, ob die Frage von @ Horcrux7 beantwortet werden soll oder nicht. Ihr hättet ihm von Anfang an die Antwort sagen können, lol. Nun, ich werde weitermachen und es tun (etwas spät, ich weiß): Nein, tut es nicht. Dort.
Voldemort
10
Um meine Fragen selbst zu beantworten. Das Beispiel funktioniert nicht !!! Das System.exit (0) beendet den Client-Prozess sofort.
Horcrux7
35
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 .

Meinersbur
quelle
Bei einer möglichen Verbesserung erhalten Sie ManagementFactory.getRuntimeMXBean().getInputArguments() nur die an die JVM übergebenen Eingabeargumente. Es fehlen Parameter, die an Ihre Anwendung übergeben wurden. zB , java -jar start.jar -MISSED_PARAM=true. Auf einem Oracle JVM können Sie diese Parameter mit abrufen System.getProperty("sun.java.command").
Chris2M
1
Die übergeordnete VM könnte enden, wenn die untergeordnete VM und die übergeordnete VM nicht über Pipes miteinander verbunden wären. Dies geschieht beim Starten der untergeordneten VM. Mit ProcessBuilderund inheritIO()kann die untergeordnete VM so gestartet werden, dass die übergeordnete VM endet.
Christian Hujer
1
Ich habe eine Version davon in Gang gebracht. In diesem Kommentar erfahren Sie, wie Sie es stoppen können: Benennen Sie etwas im Pfad um, das die Datei java.exe enthält.
Dale
Dies ist streng genommen kein Neustart, sondern das Starten einer neuen JVM mit denselben Argumenten wie diese.
Thorbjørn Ravn Andersen
4
Was ist der Unterschied? Gibt es einen Unterschied zwischen dem Neustart eines PCs und dem Herunterfahren des Betriebssystems + dem erneuten Booten?
Meinersbur
27

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.

aioobe
quelle
3
+1 für bessere Designberatung; Manchmal ist dies jedoch einfach nicht möglich, insbesondere wenn beispielsweise JNI verwendet wird.
Maerics
Nun, eine native Bibliothek könnte den globalen Status ändern, der nicht über die JNI-Schnittstelle geändert werden kann. Es gibt also keine andere Möglichkeit, den Status des Programms neu zu starten, als den Prozess neu zu starten. Natürlich sollte die native Bibliothek besser gestaltet sein, aber manchmal hängen Sie von Dingen ab, die Sie nicht kontrollieren können.
Maerics
Ok, aber mit dieser Überlegung können Sie genauso gut eine reine Java-Bibliothek haben, die einige interne statische Variablen modifiziert. Dies wäre jedoch ein Konstruktionsfehler und sollte in gut geschriebenen Bibliotheken nicht auftreten.
Aioobe
1
Ihre Antwort ist falsch, da dies auch ohne externe Anwendungen / Daemons möglich ist, wie von Meinersbur und meiner eigenen Antwort gezeigt. Für Selbstaktualisierungszwecke ist ein Neustart einer Anwendung eine gute Lösung, sodass auch Anwendungen neu gestartet werden müssen.
Veger
1
Aber Sie tun eine externe Anwendung verwenden: java! Sie vergessen, dass Java eine Sprachspezifikation ist, kein Programm. Was ist, wenn ich Ihr Programm mit einem anderen JVM wie z. B. kaffe ausführe ? Meine Antwort wurde trotzdem aktualisiert :-)
aioobe
9

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.

Maerics
quelle
sehr interessante Lösung. Das Problem unter OSX ist, dass Java-Apps normalerweise über eine kompilierte JavaApplicationStubVersion ausgeführt werden. Ich bin mir nicht sicher, ob es einen einfachen Weg gibt, dies zu umgehen.
Dan Rosenstark
7

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.

Whatnick
quelle
5

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

Amr Lotfy
quelle
4

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();
        }
    }
Malz
quelle
3

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.

01es
quelle
3

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ß.

Christian Hujer
quelle
2

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);
Tal
quelle
2

Ä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]
$
Mark Jeronimus
quelle
-13
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.

NBStudios
quelle
4
Der Benutzer hat darum gebeten, die Anwendung neu zu starten und nicht nur ein Fenster auszublenden und anzuzeigen.
Amr Lotfy