Führen Sie ein anderes JAR in einem Java-Programm aus

Ich hatte mehrere einfache Java-Anwendungen mit den Namen A.jar, B.jar geschrieben.

Jetzt möchte ich ein GUI-Java-Programm schreiben, damit der Benutzer die Taste A drücken kann, um A.jar auszuführen, und die Taste B, um B.jar auszuführen.

Außerdem möchte ich die Laufzeitprozessdetails in meinem GUI-Programm ausgeben.

Irgendein Vorschlag?

Wenn ich das richtig verstehe, möchten Sie die Jars anscheinend in einem separaten Prozess in Ihrer Java-GUI-Anwendung ausführen.

Dazu können Sie Folgendes verwenden:

// Run a java app in a separate system process
Process proc = Runtime.getRuntime().exec("java -jar A.jar");
// Then retreive the process output
InputStream in = proc.getInputStream();
InputStream err = proc.getErrorStream();

Es ist immer eine gute Praxis, die Ausgabe des Prozesses zu puffern.

.jar ist nicht ausführbar. Instanziieren Sie Klassen oder rufen Sie eine statische Methode auf.

BEARBEITEN: Fügen Sie beim Erstellen einer JAR einen Eintrag für die Hauptklasse hinzu.

> p.mf (Inhalt von p.mf)

Hauptklasse: pk.Test

>Test.java

package pk;
public class Test{
  public static void main(String []args){
    System.out.println("Hello from Test");
  }
}

Verwenden Sie die Process-Klasse und ihre Methoden.

public class Exec
{
   public static void main(String []args) throws Exception
    {
        Process ps=Runtime.getRuntime().exec(new String[]{"java","-jar","A.jar"});
        ps.waitFor();
        java.io.InputStream is=ps.getInputStream();
        byte b[]=new byte[is.available()];
        is.read(b,0,b.length);
        System.out.println(new String(b));
    }
}

Hoffe das hilft:

public class JarExecutor {

private BufferedReader error;
private BufferedReader op;
private int exitVal;

public void executeJar(String jarFilePath, List<String> args) throws JarExecutorException {
    // Create run arguments for the

    final List<String> actualArgs = new ArrayList<String>();
    actualArgs.add(0, "java");
    actualArgs.add(1, "-jar");
    actualArgs.add(2, jarFilePath);
    actualArgs.addAll(args);
    try {
        final Runtime re = Runtime.getRuntime();
        //final Process command = re.exec(cmdString, args.toArray(new String[0]));
        final Process command = re.exec(actualArgs.toArray(new String[0]));
        this.error = new BufferedReader(new InputStreamReader(command.getErrorStream()));
        this.op = new BufferedReader(new InputStreamReader(command.getInputStream()));
        // Wait for the application to Finish
        command.waitFor();
        this.exitVal = command.exitValue();
        if (this.exitVal != 0) {
            throw new IOException("Failed to execure jar, " + this.getExecutionLog());
        }

    } catch (final IOException | InterruptedException e) {
        throw new JarExecutorException(e);
    }
}

public String getExecutionLog() {
    String error = "";
    String line;
    try {
        while((line = this.error.readLine()) != null) {
            error = error + "\n" + line;
        }
    } catch (final IOException e) {
    }
    String output = "";
    try {
        while((line = this.op.readLine()) != null) {
            output = output + "\n" + line;
        }
    } catch (final IOException e) {
    }
    try {
        this.error.close();
        this.op.close();
    } catch (final IOException e) {
    }
    return "exitVal: " + this.exitVal + ", error: " + error + ", output: " + output;
}
}

Wenn sich das Glas in Ihrem Klassenpfad befindet und Sie die Hauptklasse kennen, können Sie einfach die Hauptklasse aufrufen. Am Beispiel von DITA-OT:

import org.dita.dost.invoker.CommandLineInvoker;
....
CommandLineInvoker.main('-f', 'html5', '-i', 'samples/sequence.ditamap', '-o', 'test')

Beachten Sie, dass das untergeordnete JAR den Speicherplatz und einen Klassenpfad mit Ihrem JAR teilt, mit allen möglichen Interferenzen, die dazu führen können. Wenn Sie nicht möchten, dass das Zeug verschmutzt wird, haben Sie andere Möglichkeiten, wie oben erwähnt - nämlich:

• Erstellen Sie einen neuen ClassLoader mit dem Glas darin. Das ist sicherer; Sie können das Wissen des neuen Glases zumindest auf einen Core Classloader beschränken, wenn Sie Dinge mit dem Wissen entwerfen, dass Sie Alien-Gläser verwenden. Das machen wir in meinem Shop für unser Plugins-System. Die Hauptanwendung ist eine winzige Shell mit einer ClassLoader-Factory, einer Kopie der API und dem Wissen, dass die reale Anwendung das erste Plugin ist, für das sie einen ClassLoader erstellen sollte. Plugins sind zwei Jars - Schnittstelle und Implementierung -, die zusammen gezippt werden. Die ClassLoader teilen sich alle Schnittstellen, während jeder ClassLoader nur über Kenntnisse seiner eigenen Implementierung verfügt. Der Stapel ist ein wenig komplex, aber er besteht alle Tests und funktioniert wunderbar.
• use Runtime.getRuntime.exec(...)(das die JAR vollständig isoliert, aber die normalen Fallstricke "Find the Application", "Escape Your Strings Right", "Platform-Specific WTF" und "OMG System Threads" beim Ausführen von Systembefehlen aufweist.

Im Folgenden wird das JAR mit einer Batch-Datei gestartet, falls das Programm als eigenständiges Programm ausgeführt wird:

public static void startExtJarProgram(){
        String extJar = Paths.get("C:\\absolute\\path\\to\\batchfile.bat").toString();
        ProcessBuilder processBuilder = new ProcessBuilder(extJar);
        processBuilder.redirectError(new File(Paths.get("C:\\path\\to\\JavaProcessOutput\\extJar_out_put.txt").toString()));
        processBuilder.redirectInput();
        try {
           final Process process = processBuilder.start();
            try {
                final int exitStatus = process.waitFor();
                if(exitStatus==0){
                    System.out.println("External Jar Started Successfully.");
                    System.exit(0); //or whatever suits 
                }else{
                    System.out.println("There was an error starting external Jar. Perhaps path issues. Use exit code "+exitStatus+" for details.");
                    System.out.println("Check also C:\\path\\to\\JavaProcessOutput\\extJar_out_put.txt file for additional details.");
                    System.exit(1);//whatever
                }
            } catch (InterruptedException ex) {
                System.out.println("InterruptedException: "+ex.getMessage());
            }
        } catch (IOException ex) {
            System.out.println("IOException. Faild to start process. Reason: "+ex.getMessage());
        }
        System.out.println("Process Terminated.");
        System.exit(0);
    }

In der batchfile.bat können wir dann sagen:

@echo off
start /min C:\path\to\jarprogram.jar

Wenn Sie Java 1.6 sind, können Sie auch Folgendes tun:

import javax.tools.JavaCompiler; 
import javax.tools.ToolProvider; 

public class CompilerExample {

    public static void main(String[] args) {
        String fileToCompile = "/Users/rupas/VolatileExample.java";

        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

        int compilationResult = compiler.run(null, null, null, fileToCompile);

        if (compilationResult == 0) {
            System.out.println("Compilation is successful");
        } else {
            System.out.println("Compilation Failed");
        }
    }
}