Jak mogę zrestartować aplikację Java?

95

Jak mogę zrestartować aplikację Java AWT? Mam przycisk, do którego dołączyłem procedurę obsługi zdarzeń. Jakiego kodu należy użyć, aby zrestartować aplikację?

Chcę zrobić to samo, Application.Restart()co w aplikacji C #.

Azfar Niaz
źródło
2
Może nie rozumiem twojego pytania. Chcesz, aby Twoja aplikacja miała przycisk, który ponownie uruchamia aplikację? Czy po tym, jak aplikacja przestanie działać, powinna być w stanie uruchomić się ponownie? Wydaje mi się to niemożliwe.
Jay
Nie pytam, że po zatrzymaniu JVM pytam, jak mogę odrodzić moją główną ramkę Java?
Azfar Niaz
2
Niemożliwe. Widzę, że środowisko robocze eclipse często uruchamia się ponownie, nawet system Windows robi to po aktualizacjach. Fałszywe założenie jest takie, że aplikacja jest jedyną działającą rzeczą, pod którą nie ma nic. Będziemy potrzebować wyrzutni zdolnej do ponownego uruchomienia, żółwie do końca.
whatnick
tak samo jak w aplikacji C #, gdzie można napisać System.restart (), aby to zrobić?
Azfar Niaz
@aniaz, powinieneś zaktualizować pytanie, aby wskazać, że chcesz pokazać / ukryć ramkę. Aplikacja NIE jest ramką.
whatnick

Odpowiedzi:

106

Oczywiście istnieje możliwość ponownego uruchomienia aplikacji Java.

Poniższa metoda przedstawia sposób ponownego uruchomienia aplikacji Java:

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

Zasadniczo wykonuje następujące czynności:

  1. Znajdź plik wykonywalny java (użyłem tutaj pliku binarnego java, ale to zależy od twoich wymagań)
  2. Znajdź aplikację (w moim przypadku jar, używając MyClassInTheJarklasy, aby znaleźć samą lokalizację jar)
  3. Zbuduj polecenie, aby zrestartować jar (w tym przypadku używając pliku binarnego Java)
  4. Wykonaj to! (a tym samym kończąc bieżącą aplikację i uruchamiając ją ponownie)
Veger
źródło
5
Czy nie ma małego przedziału czasowego, w którym dwie wersje tej samej aplikacji działają w tym samym czasie?
Monir
5
Czy System.exit (0) nie zakończy procesu potomnego?
Horcrux7
16
@Veger Pytanie, czy System.exit(0)kończy proces potomny, ma taką samą odpowiedź, jak to, czy ta odpowiedź naprawdę działa i dlaczego. Jeśli nie możesz podać sensownego wyjaśnienia wraz z odpowiedzią, wykonałeś złą robotę. Odpowiedź, która dostarcza więcej pytań niż odpowiedzi, nie jest przykładem dokładnej odpowiedzi. Dobre odpowiedzi nie tylko pokazują kod, ale także wyjaśniają, jak i dlaczego działają, jakie są wady i jakie są alternatywy. Nawet nie próbowałeś tego ukrywać.
Tomáš Zato - Przywróć Monikę
8
Tyle komentarzy debatujących, czy odpowiedzieć na pytanie @ Horcrux7, czy nie. Mogliście po prostu powiedzieć mu odpowiedź od samego początku lol. Cóż, pójdę dalej i zrobię to (wiem trochę późno): nie, nie. Tam.
Voldemort,
10
Aby odpowiedzieć sobie na moje pytania. Próbka nie działa !!! System.exit (0) natychmiast przerywa proces klienta.
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);
    }
}

Dedykowany wszystkim, którzy mówią, że to niemożliwe.

Ten program gromadzi wszystkie dostępne informacje w celu odtworzenia oryginalnego wiersza poleceń. Następnie uruchamia je, a ponieważ jest to to samo polecenie, aplikacja uruchamia się po raz drugi. Następnie wychodzimy z oryginalnego programu, program potomny działa (nawet pod Linuksem) i robi to samo.

OSTRZEŻENIE : Jeśli to uruchomisz, pamiętaj, że nigdy nie kończy się tworzenie nowych procesów, podobnie jak bomba widelca .

Meinersbur
źródło
Ewentualne ulepszenia ManagementFactory.getRuntimeMXBean().getInputArguments() podadzą tylko argumenty wejściowe przekazane do maszyny JVM. Pomija parametry przekazane do Twojej aplikacji. np java -jar start.jar -MISSED_PARAM=true. W jvm Oracle można pobrać te parametry za pomocą System.getProperty("sun.java.command").
Chris2M,
1
Nadrzędna maszyna wirtualna mogłaby zakończyć się, gdyby podrzędna maszyna wirtualna i nadrzędna maszyna wirtualna nie byłyby ze sobą połączone za pomocą potoków, co dzieje się w przypadku uruchamiania maszyny podrzędnej. Używając ProcessBuilderi inheritIO(), podrzędną maszynę wirtualną można uruchomić w taki sposób, że nadrzędna maszyna wirtualna zakończy się.
Christian Hujer
1
Mam wersję tego. Ten komentarz mówi, jak to zatrzymać: zmień nazwę czegoś w ścieżce zawierającej plik java.exe.
Dale
Mówiąc ściśle, nie jest to ponowne uruchamianie, ale uruchomienie nowej maszyny JVM z tymi samymi argumentami, co ta.
Thorbjørn Ravn Andersen
4
Co za różnica? Czy istnieje różnica między ponownym uruchomieniem komputera a zamknięciem systemu operacyjnego + ponownym uruchomieniem?
Meinersbur
29

Zasadniczo nie możesz. Przynajmniej nie w rzetelny sposób. Jednak nie powinieneś tego robić.

Nie mogą się rozstać

Aby zrestartować program Java, należy zrestartować maszynę JVM. Aby zrestartować maszynę JVM, musisz

  1. Znajdź javaużywany program uruchamiający. Możesz spróbować, System.getProperty("java.home")ale nie ma gwarancji, że wskaże to program uruchamiający, który został użyty do uruchomienia aplikacji. (Zwracana wartość może nie wskazywać na środowisko JRE używane do uruchamiania aplikacji lub mogła zostać zastąpiona przez -Djava.home.)

  2. Ty przypuszczalnie chcą uhonorować oryginalną pamięć ustawienia etc ( -Xmx, -Xms...), więc trzeba dowiedzieć się, które ustawienia gdzie użyty do uruchomienia pierwszego JVM. Możesz spróbować użyć, ManagementFactory.getRuntimeMXBean().getInputArguments()ale nie ma gwarancji, że będzie to odzwierciedlać użyte ustawienia. Jest to nawet zapisane w dokumentacji tej metody:

    Zazwyczaj nie wszystkie opcje wiersza polecenia polecenia „java” są przekazywane do wirtualnej maszyny języka Java. W związku z tym zwrócone argumenty wejściowe mogą nie zawierać wszystkich opcji wiersza polecenia.

  3. Jeśli program odczyta dane wejściowe z Standard.inoryginalnego standardowego wejścia, zostanie utracone podczas ponownego uruchamiania.

  4. Wiele z tych sztuczek i hacków zawiedzie w obecności pliku SecurityManager.

Nie powinno potrzebować części

Zalecam zaprojektowanie aplikacji tak, aby można było łatwo wszystko uporządkować, a następnie utworzyć nową instancję swojej „głównej” klasy.

Wiele aplikacji nie robi nic poza tworzeniem instancji w metodzie głównej:

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

Korzystając z tego wzorca, powinno być łatwo zrobić coś takiego:

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

i niech launch()zwraca prawdę wtedy i tylko wtedy, gdy aplikacja została zamknięta w taki sposób, że trzeba ją ponownie uruchomić.

aioobe
źródło
3
+1 za lepsze porady projektowe; chociaż czasami jest to po prostu niemożliwe, zwłaszcza jeśli na przykład używasz JNI.
maerics
Cóż, natywna biblioteka mogłaby modyfikować stan globalny, którego nie można zmodyfikować z poziomu interfejsu JNI, więc nie byłoby innego sposobu „ponownego uruchomienia” stanu programu niż ponowne uruchomienie procesu. Oczywiście natywna biblioteka powinna być lepiej zaprojektowana, ale czasami polegasz na rzeczach, nad którymi nie masz kontroli.
maerics
Ok, ale z takim rozumowaniem równie dobrze można mieć czystą bibliotekę Javy modyfikującą niektóre wewnętrzne zmienne statyczne. Byłby to jednak błąd projektowy i nie powinien występować w dobrze napisanych bibliotekach.
aioobe
1
Twoja odpowiedź jest nieprawidłowa, ponieważ jest to całkowicie możliwe nawet bez zewnętrznych aplikacji / demonów, jak pokazał Meinersbur i moja własna odpowiedź. W celu samoaktualizacji dobrym rozwiązaniem jest ponowne uruchomienie aplikacji, więc w rzeczywistości istnieje również potrzeba ponownego uruchomienia aplikacji.
Veger
1
Ale zrobić użyciu zewnętrznej aplikacji: java! Zapominasz, że Java to specyfikacja języka, a nie program. Co się stanie, jeśli uruchomię twój program przy użyciu innej jvm, na przykład kaffe ? Tak czy inaczej zaktualizowałem moją odpowiedź :-)
aioobe
10

Ściśle mówiąc, program Java nie może sam się zrestartować, ponieważ w tym celu musi zabić maszynę JVM, w której działa, a następnie uruchomić ją ponownie, ale gdy maszyna JVM przestanie działać (zostanie zabita), nie można podjąć żadnych działań.

Możesz zrobić kilka sztuczek z niestandardowymi programami ładującymi klasy, aby załadować, spakować i ponownie uruchomić komponenty AWT, ale prawdopodobnie spowoduje to wiele problemów związanych z pętlą zdarzeń GUI.

W zależności od sposobu uruchomienia aplikacji można uruchomić JVM w skrypcie opakowującym zawierającym pętlę do / while, która jest kontynuowana, gdy JVM kończy pracę z określonym kodem, wtedy aplikacja AWT musiałaby wywołać System.exit(RESTART_CODE). Na przykład w pseudokodzie skryptowym:

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

Aplikacja AWT powinna opuścić maszynę JVM za pomocą czegoś innego niż RESTART_CODE po „normalnym” zakończeniu, które nie wymaga ponownego uruchomienia.

maerics
źródło
bardzo ciekawe rozwiązanie. Problem na OSX polega na tym, że zazwyczaj aplikacje Java są uruchamiane ze skompilowanego JavaApplicationStub... Nie jestem pewien, czy jest na to łatwy sposób.
Dan Rosenstark,
7

Eclipse zwykle uruchamia się ponownie po zainstalowaniu wtyczki. Robią to za pomocą opakowania eclipse.exe (aplikacji uruchamiającej) dla systemu Windows. Ta aplikacja wykonuje rdzeń eclipse runner jar i jeśli aplikacja eclipse java zakończy działanie z ponownym uruchomieniem kodu, eclipse.exe restartuje środowisko robocze. Możesz zbudować podobny fragment kodu natywnego, skryptu powłoki lub innego opakowania kodu java, aby zrestartować.

whatnick
źródło
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, aby uruchomić skrypt w zminimalizowanym oknie

^ & wyjdź, aby zamknąć okno cmd po zakończeniu

przykładowy skrypt cmd może być

@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

spać 10 spać przez 10 sekund

Amr Lotfy
źródło
4

Chociaż to pytanie jest stare i odpowiedziałem, natknąłem się na problem z niektórymi rozwiązaniami i postanowiłem dodać moją sugestię do miksu.

Problem z niektórymi rozwiązaniami polega na tym, że tworzą one pojedynczy ciąg poleceń. Stwarza to problemy, gdy niektóre parametry zawierają spacje, zwłaszcza java.home .

Na przykład w systemie Windows linia

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

Może zwrócić coś takiego:C:\Program Files\Java\jre7\bin\java

Ten ciąg musi być zawinięty w cudzysłów lub zmieniony ze względu na spację w Program Files. Nie jest to duży problem, ale nieco denerwujący i podatny na błędy, szczególnie w aplikacjach wieloplatformowych.

Dlatego moje rozwiązanie buduje polecenie jako tablicę poleceń:

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();
        }
    }
Słód
źródło
4

Wystarczy dodać informacje, których nie ma w innych odpowiedziach.

Jeśli procfs /proc/self/cmdline jest dostępny

Jeśli pracujesz w środowisku, które zapewnia procfs i dlatego masz /procdostępny system plików (co oznacza, że ​​nie jest to rozwiązanie przenośne), możesz odczytać Javę /proc/self/cmdlinew celu ponownego uruchomienia, na przykład:

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

W systemach z /proc/self/cmdlinedostępnością jest to prawdopodobnie najbardziej elegancki sposób „ponownego uruchomienia” bieżącego procesu Java z poziomu Javy. Bez JNI i bez zgadywania ścieżek i innych rzeczy. To również zajmie się wszystkimi opcjami JVM przekazanymi do javapliku binarnego. Wiersz poleceń będzie dokładnie taki sam, jak w bieżącym procesie JVM.

Wiele systemów UNIX, w tym GNU / Linux (w tym Android), ma obecnie procfs. Jednak w niektórych, takich jak FreeBSD, jest on przestarzały i wycofywany. Mac OS X jest wyjątkiem w tym sensie, że nie ma procfs . Windows również nie ma procfs . Cygwin ma procfs, ale jest niewidoczny dla Javy, ponieważ jest widoczny tylko dla aplikacji używających bibliotek DLL Cygwin zamiast wywołań systemowych Windows, a Java nie wie o Cygwin.

Nie zapomnij użyć ProcessBuilder.inheritIO()

Domyślnie stdin/ stdout/ stderr(w Javie wywoływane System.in/ System.out/ System.err) uruchomionego procesu są ustawione na potoki, które umożliwiają bieżącemu procesowi komunikację z nowo uruchomionym procesem. Jeśli chcesz ponownie uruchomić bieżący proces, najprawdopodobniej nie jest to to, czego chcesz . Zamiast tego chciałbyś, aby stdin/ stdout/ stderrbyły takie same jak te z bieżącej maszyny wirtualnej. Nazywa się to dziedziczeniem . Możesz to zrobić, wywołując inheritIO()swoją ProcessBuilderinstancję.

Pułapka w systemie Windows

Częstym przypadkiem użycia restart()funkcji jest ponowne uruchomienie aplikacji po aktualizacji. Kiedy ostatnio próbowałem tego w systemie Windows, było to problematyczne. Po nadpisaniu .jarpliku aplikacji nową wersją, aplikacja zaczęła działać nieprawidłowo i dawała wyjątki dotyczące .jarpliku. Mówię tylko, na wypadek, gdyby to był twój przypadek użycia. Wtedy rozwiązałem problem, opakowując aplikację w plik wsadowy i używając magicznej wartości zwracanej, z System.exit()której odpytałem w pliku wsadowym i zamiast tego plik wsadowy ponownie uruchomił aplikację.

Christian Hujer
źródło
3

Kiedy natknąłem się na to pytanie, sam badałem ten temat.

Niezależnie od tego, że odpowiedź została już zaakceptowana, nadal chciałbym zaproponować alternatywne podejście do kompletności. W szczególności Apache Ant służył jako bardzo elastyczne rozwiązanie.

Zasadniczo wszystko sprowadza się do pliku skryptu Ant z pojedynczym zadaniem wykonania Java (patrz tutaj i tutaj ) wywoływanym z kodu Java (patrz tutaj ). Ten kod Java, który może być uruchomieniem metody , może być częścią aplikacji, która wymaga ponownego uruchomienia. Aplikacja musi mieć zależność od biblioteki Apache Ant (jar).

Zawsze, gdy aplikacja wymaga ponownego uruchomienia, powinna wywołać uruchomienie metody i zamknąć maszynę wirtualną. Zadanie Ant Java powinno mieć opcje fork i spawn ustawione na true.

Oto przykład skryptu Ant:

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

Kod metody uruchamiania może wyglądać mniej więcej tak:

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

}

Bardzo wygodną rzeczą jest to, że ten sam skrypt jest używany do początkowego uruchamiania aplikacji, jak również do ponownego uruchamiania.

01es
źródło
2

Stare pytanie i tak dalej. Ale to kolejny sposób, który ma pewne zalety.

W systemie Windows możesz poprosić harmonogram zadań o ponowne uruchomienie aplikacji. Ma to tę zaletę, że czeka określony czas, zanim aplikacja zostanie ponownie uruchomiona. Możesz przejść do menedżera zadań i usunąć zadanie, a ono przestaje się powtarzać.

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);
Dołek
źródło
2

Podobna do „ ulepszonej ” odpowiedzi Yody , ale z dalszymi ulepszeniami (zarówno funkcjonalnymi, czytelnymi, jak i testowalnymi). Teraz można go bezpiecznie uruchomić i zrestartować tyle razy, ile podano argumentów programu.

  • Brak kumulacji JAVA_TOOL_OPTIONSopcji.
  • Automatycznie znajduje główną klasę.
  • Dziedziczy bieżące 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: pusty wskaźnik, jeśli JAVA_TOOL_OPTIONS nie jest ustawiony


Przykład:

$ 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
źródło
-13
System.err.println("Someone is Restarting me...");
setVisible(false);
try {
    Thread.sleep(600);
} catch (InterruptedException e1) {
    e1.printStackTrace();
}
setVisible(true);

Wydaje mi się, że tak naprawdę nie chcesz zatrzymywać aplikacji, ale ją „uruchomić ponownie”. W tym celu możesz użyć tego i dodać swój „Reset” przed snem i po niewidzialnym oknie.

NBStudios
źródło
4
Użytkownik poprosił o ponowne uruchomienie aplikacji, a nie tylko ukrycie i pokazanie okna.
Amr Lotfy,