L'exécution d'un programme java à partir d'un autre programme java

Je suis en train de travailler sur un programme java simple. Simplement, il compile et exécute un autre programme java. Je suis à l'Exécution.fonction exec() pour compiler et exécuter. Il n'y a pas de problème à la compilation. mais lorsqu'il s'exécute, si le deuxième programme a besoin d'une entrée pour lire à partir du clavier, je ne peux pas lui donner de la maîtrise du processus. J'ai utilisé getOutputStream() fonction. mais il ne pouvait pas aider. Je vais vous donner mon code.

public class sam {  
    public static void main(String[] args) throws Exception {  
        try { 
             Process p = Runtime.getRuntime().exec("javac sam2.java");
             Process p2 = Runtime.getRuntime().exec("java sam2");
             BufferedReader in = new BufferedReader(  
                                new InputStreamReader(p2.getInputStream()));

             OutputStream out = p.getOutputStream();
             String line = null; 
             line = in.readLine();
             System.out.println(line);
             input=input+"\n";
             out.write(input.getBytes());
             p.wait(10000);
             out.flush();
        }catch (IOException e) {  
             e.printStackTrace();  
        }  
    }  
}

C'est mon programme de master(sam.java).

Le code suivant est celui de sam2.java

public class sam2 {  
public static void main(String[] args) throws Exception {  

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String str; 
    System.out.println("Enter the number..\n");
    str = br.readLine(); 
    System.out.println(Integer.parseInt(str));

    }  
}

Il n'y a pas de problème, si mon deuxième programme a l'impression que les énoncés. Mais le problème se pose lorsque j'ai lu quelque chose de l'autre.

vous auriez à faire une sorte de tuyau de l'entrée standard STDIN de sam à sam2 mais peut-être plus de mal que de sa valeur.
S'il vous plaît apprendre conventions de nommage java et de s'y tenir, ici: les noms de classe doit commencer avec une lettre majuscule.
j'essayais de montrer un exemple simple. merci pour vos conseils.. 🙂

OriginalL'auteur BheeMa | 2013-03-05

21

Il est un peu étrange, mais vous pouvez exécuter le deuxième programme sans fork. Juste l'appel de la méthode main. Donc, oubliez le moteur d'exécution de la section et de faire cela:
```
sam2.main(new String[0]);
```
Bien sûr, de cette façon, vous devez compiler sam2 au moment de la compilation

je ne pourrais pas comprendre ce que tu veux dire par cette déclaration..!! 🙁
Il fonctionne.. 🙂 merci beaucoup.. Mais quand je l'utilise de cette façon.. l'ensemble de la commande sera parti pour le second programme. maître exécutera seulement après l'achèvement de la deuxième programme.. dois-je utiliser des threads pour résoudre ce problème..??
Bien sûr, vous devriez.
Problème..!!! quand je stocker le nom de la classe de seconde programme d'une variable de type chaîne, il rencontre l'erreur suivante.. impossible de trouver le symbole tempfile.principale(new String[0]); symbole: la méthode main(String[]) localisation: variable tempfile de type Chaîne de caractères Que dois-je faire..??
Que voulez-vous? Vous ne pouvez pas utiliser une Chaîne de caractères comme une instance de classe. Peut-être que vous devriez utiliser java réflexion à ce travail. Mais la réflexion n'est généralement pas nécessaire.

OriginalL'auteur András Tóth

Chaque processus doit être autorisé à exécuter et terminer. Vous pouvez utiliser Process#waitFor à cette fin. De même, vous avez besoin de consommer une sortie du processus en même temps. waitFor bloquera alors vous aurez besoin d'utiliser un Thread pour lire l'entrée (et si vous en avez besoin, écrire la sortie dans le processus)

En fonction de l'emplacement de l'java/fichier de classe, vous pouvez aussi avoir besoin de spécifier un dossier de départ à partir duquel l'exécution du processus peut commencer.

Plus de cela beaucoup plus facile à l'aide de ProcessBuilder

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
public class CompileAndRun {
public static void main(String[] args) {
new CompileAndRun();
}
public CompileAndRun() {
try {
int result = compile("compileandrun/HelloWorld.java");
System.out.println("javac returned " + result);
result = run("compileandrun.HelloWorld");
} catch (IOException | InterruptedException ex) {
ex.printStackTrace();
}
}
public int run(String clazz) throws IOException, InterruptedException {        
ProcessBuilder pb = new ProcessBuilder("java", clazz);
pb.redirectError();
pb.directory(new File("src"));
Process p = pb.start();
InputStreamConsumer consumer = new InputStreamConsumer(p.getInputStream());
consumer.start();
int result = p.waitFor();
consumer.join();
System.out.println(consumer.getOutput());
return result;
}
public int compile(String file) throws IOException, InterruptedException {        
ProcessBuilder pb = new ProcessBuilder("javac", file);
pb.redirectError();
pb.directory(new File("src"));
Process p = pb.start();
InputStreamConsumer consumer = new InputStreamConsumer(p.getInputStream());
consumer.start();
int result = p.waitFor();
consumer.join();
System.out.println(consumer.getOutput());
return result;        
}
public class InputStreamConsumer extends Thread {
private InputStream is;
private IOException exp;
private StringBuilder output;
public InputStreamConsumer(InputStream is) {
this.is = is;
}
@Override
public void run() {
int in = -1;
output = new StringBuilder(64);
try {
while ((in = is.read()) != -1) {
output.append((char) in);
}
} catch (IOException ex) {
ex.printStackTrace();
exp = ex;
}
}
public StringBuilder getOutput() {
return output;
}
public IOException getException() {
return exp;
}
}
}

Maintenant, évidemment, vous devriez vérifier les résultats de retour du processus, et peut-être produire un meilleur mécanisme pour interagir avec le processus, mais c'est l'idée de base...

OriginalL'auteur MadProgrammer

1

Vous pouvez simplement appeler la méthode main de la deuxième classe. La principale méthode est juste comme toute autre méthode statique.

OriginalL'auteur Jay Q.

C'est ce qui a fonctionné pour moi:

try {
single.main(new String[0]);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e);
}

OriginalL'auteur denis

0

Il suffit d'appeler le principal fichier de classe. Par exemple, si votre fichier de classe java nom est xyz.java, vous pouvez appeler et exécuter le même en java swing application sur un clic de JButton, le code est
```
private void Btn_createdatabaseActionPerformed(java.awt.event.ActionEvent evt) {                                                   
xyz.main(new String[0]);
}
```
Que c'est...

OriginalL'auteur Srinivasan. B

Vous devez vous connecter pour publier un commentaire.