Discussion :

[clmin]

Bonjour,

j'aimerai votre aide afin d'utiliser un programme java dans mon propre projet.
J'ai un fichier .jar que j'utilise régulièrement dans un terminal (java -jar ApplicationExterne.jar arguments).
Je voudrai l'utiliser dans mon projet eclipse. Puisque le readme le définit comme un "java package", j'ai ajouter le jar à mes librairies.
Jusque là, pas de problèmes.

Mon problème est que je ne sais pas comment l'utiliser, j'aurai besoin d'une méthode qui lancerait le main avec les argument de mon choix, puis mettrai les résultats dans un buffer plutôt que de les afficher.
Quelque chose du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
ApplicationExterne app = new ApplicationExterne();
res = app.main(arguments);

Est-ce possible?

[joel.drigo]

Salut,

Puisque tu lances ton application par la ligne de commande java -jar ApplicationExterne.jar arguments, c'est que ton jar est un jar "exécutable".

Tu as deux solutions :

1. En incluant effectivement le jar en tant que bibliothèque à ton programme. Mais ceci implique que tu vas devoir exécuter l'application en appelant directement la méthode main() de la classe, comme dans n'importe quel cas d'appel de méthode en Java. Il te faut donc connaitre le nom de la classe. Si tu ne le connais pas, tu peux aller le voir dans le jar, en l'ouvrant par exemple avec un logiciel de compression (winzip, 7zip, winrar...), en regardant, dans le fichier META-INF/MANIFEST.MF qui s'y trouve, la propriété Main-Class. Pour les paramètres, comme la méthode main a
   
   • soit un seul argument de type String[], il te faudra donc passer tes arguments sous cette forme (MaClasse.main(new String[]{ "arg1", "arg2"});) ;
   • soit un varargs (String...args), qui te permettra te passer tes arguments sans passer par un tableau intermédiaire (MaClasse.main( "arg1", "arg2"); ) ;
   • si tu es à l'origine des classes dans le jar, tu peux aussi simplement te prévoir une méthode d'appel, avec des arguments typés, sans passer par des String, ce qui peut nettement te simplifier les appels et les rendre plus lisibles aussi.
   
   
   
2. En l'exécutant comme un programme externe. Pas besoin d'inculre le jar en tant que bibiothèque externe. Pour faire ça, regarde la classe ProcessBuilder (regarde aussi à ce sujet http://blog.developpez.com/adiguba/p...ilder_redirect).
   

En revanche, dans aucun cas, tu ne pourras récupérer un résultat comme tu as écrit : res = Machin.main( arguments ). La méthode main est forcément void. Là aussi, l'intérêt de faire une méthode spécifque pour un appel pur Java est aussi de pouvoir avoir un type de retour.

On peut avoir par exemple simplement quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class MaClasseQuiFaitUnTrucAvecUneImage {
 
 
     public static void main(String... args) {
          if ( args.length==2 ) {
 
                 try {
                      writeImage( args[1], process( readImage( args[0] ) );
                 }
                 catch(IOException e) {
                         System.err.println( "Error: cannot process image");
                         e.printStackTrace();
                 }
 
          }
          else {
             System.err.println( "Error: missing argument");
          }
     }
 
     public static BufferedImage process(BufferedImage image) {
                /*...*/
     }
 
     private static BufferedImage readImage(String path) throws IOException {
                /*...*/
      }
 
     private static void writeImage(String path, BufferedImage image) throws IOException {
               /*...*/
      }
 
}

[clmin]

Ok, je vois comment faire dans les deux cas. Merci beaucoup!
D'un point de vue efficacité, tu me conseille lequel des deux?
Sachant que j'aimerai transformer mon projet en exécutable à un certain point...

[joel.drigo]

L'avantage de la solution d'appel en Java (donc l'inclusion du jar en bibliothèque), outre les possibilités de pouvoir avoir des méthodes avec des arguments typés, voire d'avoir différentes méthodes selon les cas, donc de favoriser la lisibilité, c'est que tu n'auras pas à gérer la problématique de l'emplacement du fichier (enfin elle sera beaucoup plus simple : à partir du moment où le jar est dans le classpath, la classe est accessible directement, alors que pour lancer une commande externe, il faut pouvoir savoir son chemin physique exact, ou pouvoir le déterminer automatiquement).

[clmin]

Hello,
je suis parvenue à utiliser le jar externe, et pensait la question résolue.
Mais en voulant boucler le processus, je suis tombée sur un problème qui me laisse perplexe:
Utiliser l'appli une fois est facile:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Boot boot = new Boot();
try {
	boot.run(new String[]{"-targ1"});			
} catch (Exception e) {
	e.printStackTrace();
}

Je ne semble pas pouvoir l'utiliser plus d'une fois cependant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Boot boot = new Boot();
try {
	boot.run(new String[]{"-targ1"});			
	boot.run(new String[]{"-targ2"});
} catch (Exception e) {
	e.printStackTrace();
}

me fait une erreur. En regardant le code de Boot, j'ai repéré le problème: il y a un paramètre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

private static JarClassLoader loader = null;

qui est initialisé dans run(), mais seulement s'il est null: sinon erreur.
J'ai donc essayé de réinitialiser la classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Boot boot = new Boot();
try {
	boot.run(new String[]{"-targ1"});			
} catch (Exception e) {
	e.printStackTrace();
	new ErrorDialog(e);
}
boot = new Boot();
try {
	boot.run(new String[]{"-targ2"});
} catch (Exception e) {
	e.printStackTrace();
	new ErrorDialog(e);
}

mais j'ai la même erreur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Boot boot = new Boot();
try {
	boot.run(new String[]{"-targ1"});			
} catch (Exception e) {
	e.printStackTrace();
	new ErrorDialog(e);
}
Boot b = new Boot();
try {
	b.run(new String[]{"-targ2"});
} catch (Exception e) {
	e.printStackTrace();
}

Fait la même chose, tout comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Boot boot = new Boot();
try {
	boot.run(new String[]{"-targ1"});			
} catch (Exception e) {
	e.printStackTrace();
	new ErrorDialog(e);
}
boot = null;
try {
	boot.run(new String[]{"-targ2"});
} catch (Exception e) {
	e.printStackTrace();
}

Y aurait-il un moyen d'obliger le programme à "oublier" boot?

[joel.drigo]

1. C'est quoi cette classe Boot ? Pourquoi aurait-elle besoin d'un JarClassLoader ?
2. C'est quoi l'erreur ?