Exécuter un autre jar dans un programme Java

J'avais écrit plusieurs applications java simples nommées A.jar, B.jar.

Maintenant, je veux écrire un programme java GUI afin que l'utilisateur puisse appuyer sur le bouton A pour exécuter A.jar et le bouton B pour exécuter B.jar.

Je souhaite également afficher les détails du processus d'exécution dans mon programme GUI.

Toute suggestion?

Si je comprends bien, il semble que vous souhaitiez exécuter les fichiers JAR dans un processus distinct depuis votre application java GUI.

Pour ce faire, vous pouvez utiliser:

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

Il est toujours bon de tamponner la sortie du processus.

.jar n'est pas exécutable. Instanciez des classes ou appelez n'importe quelle méthode statique.

EDIT: Ajoutez une entrée Main-Class lors de la création d'un JAR.

> p.mf (contenu de p.mf)

Classe principale: pk.Test

>Test.java

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

Utilisez la classe Process et ses méthodes,

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

J'espère que cela t'aides:

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

Si le fichier jar est dans votre chemin de classe et que vous connaissez sa classe Main, vous pouvez simplement appeler la classe principale. En utilisant DITA-OT comme exemple:

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

Notez que cela obligera le jar subordonné à partager de l'espace mémoire et un chemin de classe avec votre jar, avec tout le potentiel d'interférence que cela peut provoquer. Si vous ne voulez pas que ces choses soient polluées, vous avez d'autres options, comme mentionné ci-dessus - à savoir:

• créez un nouveau ClassLoader avec le pot à l'intérieur. C'est plus sûr; vous pouvez au moins isoler les connaissances du nouveau fichier jar vers un chargeur de classe principal si vous concevez les choses en sachant que vous utiliserez des fichiers alien. C'est ce que nous faisons dans ma boutique pour notre système de plugins; l'application principale est un minuscule shell avec une fabrique ClassLoader, une copie de l'API et la connaissance que l'application réelle est le premier plugin pour lequel elle devrait construire un ClassLoader. Les plugins sont une paire de jars - interface et implémentation - qui sont compressés ensemble. Les ClassLoaders partagent tous toutes les interfaces, tandis que chaque ClassLoader n'a connaissance que de sa propre implémentation. La pile est un peu complexe, mais elle passe tous les tests et fonctionne à merveille.
• use Runtime.getRuntime.exec(...)(qui isole complètement le fichier jar, mais a les pièges normaux «trouver l'application», «échapper à vos chaînes», «WTF spécifique à la plate-forme» et «OMG System Threads» lors de l'exécution des commandes système.

Ce qui suit fonctionne en démarrant le fichier jar avec un fichier de commandes, au cas où le programme s'exécuterait de manière autonome:

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

Dans le batchfile.bat, nous pouvons dire:

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

Si vous êtes java 1.6, les opérations suivantes peuvent également être effectuées:

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