Bagaimana cara memulai ulang aplikasi Java AWT? Saya memiliki tombol yang telah saya lampirkan penangan kejadian. Kode apa yang harus saya gunakan untuk memulai ulang aplikasi?

Saya ingin melakukan hal yang sama dengan yang Application.Restart()dilakukan di aplikasi C #.

Tentu saja dimungkinkan untuk memulai ulang aplikasi Java.

Metode berikut menunjukkan cara untuk memulai ulang aplikasi 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);
}

Pada dasarnya ini melakukan hal berikut:

1. Temukan java yang dapat dieksekusi (saya menggunakan biner java di sini, tetapi itu tergantung pada kebutuhan Anda)
2. Temukan aplikasinya (toples dalam kasus saya, menggunakan MyClassInTheJar kelas untuk menemukan lokasi jar itu sendiri)
3. Buat perintah untuk memulai ulang jar (dalam kasus ini menggunakan biner java)
4. Jalankan! (dan dengan demikian menghentikan aplikasi saat ini dan memulainya lagi)

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

Didedikasikan untuk semua orang yang mengatakan itu tidak mungkin.

Program ini mengumpulkan semua informasi yang tersedia untuk merekonstruksi baris perintah asli. Kemudian, itu meluncurkannya dan karena ini adalah perintah yang sama, aplikasi Anda memulai untuk kedua kalinya. Kemudian kita keluar dari program aslinya, program anak tetap berjalan (bahkan di Linux) dan melakukan hal yang sama.

PERINGATAN : Jika Anda menjalankan ini, ketahuilah bahwa ini tidak pernah berhenti membuat proses baru, mirip dengan bom garpu .

Pada dasarnya, Anda tidak bisa. Setidaknya tidak dengan cara yang dapat diandalkan. Namun, Anda tidak perlu melakukannya.

Tidak bisa berpisah

Untuk memulai ulang program Java, Anda perlu memulai ulang JVM. Untuk memulai ulang JVM, Anda perlu

1. Temukan javapeluncur yang digunakan. Anda dapat mencoba System.getProperty("java.home")tetapi tidak ada jaminan bahwa ini benar-benar akan mengarah ke peluncur yang digunakan untuk meluncurkan aplikasi Anda. (Nilai yang dikembalikan mungkin tidak mengarah ke JRE yang digunakan untuk meluncurkan aplikasi atau bisa saja diganti oleh -Djava.home.)

2. Anda mungkin ingin menghormati pengaturan memori asli dll ( -Xmx,, -Xms…) jadi Anda perlu mencari tahu pengaturan mana yang digunakan untuk memulai JVM pertama. Anda dapat mencoba menggunakan ManagementFactory.getRuntimeMXBean().getInputArguments()tetapi tidak ada jaminan bahwa ini akan mencerminkan pengaturan yang digunakan. Ini bahkan dijabarkan dalam dokumentasi metode itu:

   Biasanya, tidak semua opsi baris perintah ke perintah 'java' diteruskan ke mesin virtual Java. Karenanya, argumen masukan yang dikembalikan mungkin tidak menyertakan semua opsi baris perintah.

3. Jika program Anda membaca input dari Standard.instdin asli akan hilang di restart.

4. Banyak dari trik dan peretasan ini akan gagal jika ada file SecurityManager.

The seharusnya tidak perlu bagian

Saya menyarankan Anda untuk mendesain aplikasi Anda sehingga mudah untuk membersihkan semuanya dan setelah itu buat instance baru dari kelas "utama" Anda.

Banyak aplikasi dirancang untuk tidak melakukan apa pun selain membuat instance dalam metode utama:

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

Dengan menggunakan pola ini, seharusnya cukup mudah untuk melakukan sesuatu seperti:

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

dan biarkan launch()mengembalikan true jika dan hanya jika aplikasi ditutup sedemikian rupa sehingga perlu dimulai ulang.

Sebenarnya, program Java tidak dapat memulai ulang sendiri karena untuk melakukannya, program tersebut harus mematikan JVM yang menjalankannya dan kemudian memulainya lagi, tetapi setelah JVM tidak lagi berjalan (dimatikan) maka tidak ada tindakan yang dapat diambil.

Anda dapat melakukan beberapa trik dengan pemuat kelas khusus untuk memuat, mengemas, dan memulai komponen AWT lagi tetapi ini kemungkinan akan menyebabkan banyak sakit kepala terkait dengan loop peristiwa GUI.

Bergantung pada bagaimana aplikasi diluncurkan, Anda dapat memulai JVM dalam skrip pembungkus yang berisi perulangan do / while, yang berlanjut saat JVM keluar dengan kode tertentu, maka aplikasi AWT harus memanggil System.exit(RESTART_CODE). Misalnya, dalam pembuatan skrip pseudocode:

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

Aplikasi AWT harus keluar dari JVM dengan sesuatu selain RESTART_CODE pada penghentian "normal" yang tidak memerlukan restart.

Eclipse biasanya dimulai ulang setelah plugin diinstal. Mereka melakukan ini menggunakan eclipse.exe pembungkus (aplikasi peluncur) untuk windows. Aplikasi ini menjalankan jar pelari gerhana inti dan jika aplikasi java gerhana diakhiri dengan kode peluncuran ulang, eclipse.exe memulai ulang meja kerja. Anda dapat membuat kode asli, skrip shell, atau pembungkus kode java lain yang serupa untuk memulai ulang.

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

/ mnt untuk memulai skrip di jendela yang diperkecil

^ & keluar untuk menutup jendela cmd setelah selesai

contoh skrip cmd

@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

tidur 10 tidur selama 10 detik

Jika Anda benar-benar perlu memulai ulang aplikasi Anda, Anda dapat menulis aplikasi terpisah untuk memulainya ...

Halaman ini memberikan banyak contoh berbeda untuk berbagai skenario:

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

Meskipun pertanyaan ini sudah lama dan sudah terjawab, saya telah menemukan masalah dengan beberapa solusi dan memutuskan untuk menambahkan saran saya ke dalam campuran.

Masalah dengan beberapa solusi adalah mereka membangun satu string perintah. Ini menimbulkan masalah ketika beberapa parameter berisi spasi, terutama java.home .

Misalnya, di jendela, baris

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

Mungkin mengembalikan sesuatu seperti ini:C:\Program Files\Java\jre7\bin\java

String ini harus dibungkus dengan tanda kutip atau di-escape karena spasi di dalamnya Program Files. Bukan masalah besar, tapi agak mengganggu dan rawan error, terutama pada aplikasi lintas platform.

Oleh karena itu solusi saya membangun perintah sebagai larik perintah:

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

Saya sendiri sedang meneliti subjeknya ketika menemukan pertanyaan ini.

Terlepas dari kenyataan bahwa jawabannya sudah diterima, saya tetap ingin menawarkan pendekatan alternatif untuk kelengkapan. Secara khusus, Apache Ant berfungsi sebagai solusi yang sangat fleksibel.

Pada dasarnya, semuanya bermuara pada file skrip Ant dengan satu tugas eksekusi Java (lihat di sini dan di sini ) yang dipanggil dari kode Java (lihat di sini ). Kode Java ini, yang bisa menjadi metode peluncuran , bisa menjadi bagian dari aplikasi yang perlu direstart. Aplikasi harus memiliki ketergantungan pada pustaka Apache Ant (jar).

Setiap kali aplikasi perlu dimulai ulang, itu harus memanggil peluncuran metode dan keluar dari VM. Tugas Ant java harus memiliki opsi fork dan spawn disetel ke true.

Berikut adalah contoh skrip 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>

Kode untuk metode peluncuran mungkin terlihat seperti ini:

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

}

Hal yang sangat mudah di sini adalah bahwa skrip yang sama digunakan untuk aplikasi awal dan juga untuk memulai ulang.

Hanya menambahkan informasi yang tidak ada di jawaban lain.

Jika procfs /proc/self/cmdline tersedia

Jika Anda menjalankan di lingkungan yang menyediakan procfs dan karena itu memiliki /procsistem file yang tersedia (yang berarti ini bukan solusi portabel), Anda dapat meminta Java membaca /proc/self/cmdlineuntuk memulai ulang sendiri, seperti ini:

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

Pada sistem yang /proc/self/cmdlinetersedia, ini mungkin cara paling elegan untuk "memulai ulang" proses Java saat ini dari Java. Tidak ada JNI yang terlibat, dan tidak perlu menebak jalur dan hal-hal yang diperlukan. Ini juga akan menangani semua opsi JVM yang diteruskan ke javabiner. Baris perintah akan sama persis dengan salah satu proses JVM saat ini.

Banyak sistem UNIX termasuk GNU / Linux (termasuk Android) saat ini memiliki procfs Namun pada beberapa sistem seperti FreeBSD, ini sudah usang dan dihentikan. Mac OS X adalah pengecualian dalam arti tidak memiliki procfs . Windows juga tidak memiliki procfs . Cygwin memiliki procfs tetapi tidak terlihat di Java karena hanya terlihat oleh aplikasi yang menggunakan Cygwin DLL, bukan panggilan sistem Windows, dan Java tidak mengetahui Cygwin.

Jangan lupa gunakan ProcessBuilder.inheritIO()

Standarnya adalah stdin/ stdout/ stderr(dalam Java disebut System.in/ System.out/ System.err) dari Proses yang dimulai diatur ke pipa yang memungkinkan proses yang sedang berjalan untuk berkomunikasi dengan proses yang baru dimulai. Jika Anda ingin memulai kembali proses saat ini, ini kemungkinan besar ini bukan yang Anda inginkan . Sebaliknya Anda ingin agar stdin/ stdout/ stderrsama dengan VM saat ini. Ini disebut warisan . Anda dapat melakukannya dengan memanggil instance inheritIO()Anda ProcessBuilder.

Jebakan di Windows

Kasus penggunaan yang sering dari suatu restart()fungsi adalah memulai ulang aplikasi setelah pembaruan. Terakhir kali saya mencoba ini di Windows, ini bermasalah. Saat menimpa file aplikasi .jardengan versi baru, aplikasi mulai berperilaku tidak semestinya dan memberikan pengecualian tentang.jar file tersebut. Saya hanya memberi tahu, kalau-kalau ini kasus penggunaan Anda. Saat itu saya memecahkan masalah dengan membungkus aplikasi dalam file batch dan menggunakan nilai kembali ajaib dari System.exit()yang saya tanyakan di file batch dan file batch memulai ulang aplikasi sebagai gantinya.

Pertanyaan lama dan semua itu. Tapi ini adalah cara lain yang menawarkan beberapa keuntungan.

Di Windows, Anda dapat meminta penjadwal tugas untuk memulai aplikasi Anda lagi untuk Anda. Keuntungannya adalah menunggu beberapa saat sebelum aplikasi dimulai ulang. Anda dapat pergi ke pengelola tugas dan menghapus tugas dan itu berhenti berulang.

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

Mirip dengan jawaban ' ditingkatkan ' Yoda , tetapi dengan peningkatan lebih lanjut (baik fungsional, keterbacaan, dan kemampuan pengujian). Sekarang aman untuk dijalankan, dan dimulai ulang sebanyak jumlah argumen program yang diberikan.

• Tidak ada akumulasi JAVA_TOOL_OPTIONSopsi.
• Menemukan kelas utama secara otomatis.
• Mewarisi stdout / stderr saat ini.

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

Perbaikan Bug V1.1: pointer null jika JAVA_TOOL_OPTIONS tidak disetel

Contoh:

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

Saya kira Anda tidak benar-benar ingin menghentikan aplikasi, tetapi untuk "Memulai kembali". Untuk itu, Anda dapat menggunakan ini dan menambahkan "Reset" Anda sebelum tidur dan setelah jendela tak terlihat.