Soutenez-nous
Les FAQs Java :
FAQ JAVA FAQ Java EE FAQ Java ME FAQ Java XML FAQ JavaFX FAQ Java GUI FAQ Struts FAQ JSF FAQ JDBC JDO FAQ Hibernate FAQ Spring FAQ Eclipse FAQ NetBeans FAQ JCreator FAQ Maven 2

FAQ JavaConsultez toutes les FAQ

Nombre d'auteurs : 53, nombre de questions : 231, dernière mise à jour : 26 janvier 2014 

 
OuvrirSommaireLe développementExécution

Cela se fait de la même manière que dans la plupart des langages comme C/C++, C-Shell, Bash, ...

Lors de l'appel du programme :

 
Sélectionnez
java MaClasse param1 param2 ... paramN 

Les paramètres sont stockés dans un tableau de chaines de caractères qui se trouve dans la méthode main de la classe principale :

 
Sélectionnez
public static void main (String[] args) {  ... } 

On peut ainsi accéder aux éléments rentrés en paramètres via le tableau "args", par exemple :

 
Sélectionnez
// nombre de paramètres 
int nbParam = args.length; 
for (int i = 0; i < nbParam; i++) { 
    System.out.println(args[i]); 
}

Attention : une exception est levée si l'on tente d'accéder à un élément du tableau qui n'existe pas.

Créé le 19 juillet 2004  par bahamouth

Il y a différentes façons de comprendre "exécutable" :

Une machine virtuelle est installée
Ecrire un script dans un fichier de commande (.bat, ...) pour lancer l'application
Créer une application .jar exécutable (plus d'infos)

  • points positif : on simplifie le lancement de l'application.
  • points négatif : la machine virtuelle installée n'est peut-être pas assez récente.

Installation automatique d'une machine virtuelle

Packager son application avec une machine virtuelle associée (exemple : InstallAnyWhere de ZeroG).

  • points positif : L'utilisateur n'a pas à installer une machine virtuelle lui-même et on est sûr de la compatibilité JVM / application.
  • points négatif : L'application est plus lourde de quelques Mo supplémentaires et il faut réaliser un exécutable par plateforme.

Plus de machine virtuelle

Utilisation d'un compilateur natif.

  • points positif : L'application est plus légère qu'avec une JVM associée et on gagne en performance (Le gain est nettement moins significatif maintenant que la JVM utilise un compilateur à la volée (Just In Time)).
  • points négatif : L'application n'est plus portable et le logiciel, pour rendre le code natif, se limite souvent aux classes les plus courantes de l'API.

Pour les logiciels dont vous pourriez avoir besoin, cf. http://java.developpez.com/outils/.

Créé le 7 avril 2003  par Pierre-Yves Varoux

Tout d'abord, il convient de créer un fichier Manifest.
Ce fichier contiendra le nom de la classe à exécuter ainsi que les archives à mettre dans le CLASSPATH.

 
Sélectionnez
Manifest-Version: 1.0 
Created-By: 1.4.1_01 (Sun Microsystems Inc.) 
Main-Class: Start 
Class-Path: ./archive1.jar ./archive2.jar 


Attention : il est nécessaire de terminer le fichier manifest par un saut de ligne.


Nous appellerons le fichier MANIFEST.MF et il sera placé dans un répertoire META-INF en racine de l'application (par exemple).
Les archives jar du classpath ne seront pas inclues dans ce jar mais seront situées par la suite dans le même répertoire que nous allons créer (ou dans un path bien défini).
Si l'on veut qu'elles soient rangées dans un répertoire il suffira de donner le path:

 
Sélectionnez
Class-Path: path1/archive1.jar path2/archive2.jar 


Pour créer le jar il faut déjà supprimer tous les .java
L'idéal étant de copier tous les .class (avec leur arborescence s'ils sont packagés) dans un répertoire temporaire pour créer le jar dans ce répertoire. On peut aussi copier les fichiers qui seront accessibles dans le jar (images) s'il y en a.


La commande permettant de créer un fichier .jar est la suivante :

 
Sélectionnez
jar cvfm fichier-jar fichier-manifeste fichiers...


Voilà la signification des différents paramètres :

  • fichier-jar : est le nom du jar à créer
  • fichier-manifeste : fichier MANIFEST.MF
  • fichiers : fichiers à ajouter à l'archive. Si un des fichiers est un répertoire, celui-ci est traité récursivement.


Dans le répertoire des .class, on exécutera donc la commande suivante :

 
Sélectionnez
jar cvfm monappli.jar META-INF/MANIFEST.MF . 


Cela va nous créer un .jar éxécutable nommé monappli.jar avec le fichier MANIFEST.MF présent dans le répertoire META/INF. Ce jar se voit ajouter les fichiers du répertoire courant (spécifié par le caractère '.').


Le programme jar reconstruira le fichier Manifest et affichera sur la sortie standard les résultats (ça permet de vérifier qu'il est codé correctement).
On exécute ensuite le jar de la façon suivante :

 
Sélectionnez
java -jar monappli.jar


Les archives indiquées dans le Class-Path du Manifest seront recherchées selon leurs chemin relatif par rapport au fichier Jar principal.

Mis à jour le 20 décembre 2009  par bahamouth, Clément Cunin, le y@m's, sinok

Lien : Working with Manifest Files: The Basics

Il faut d'abord générer un certificat :

 
Sélectionnez

keytool -genkey -alias signature -keystore monStore

Il faut alors répondre aux différentes questions (nom, prénom, société, adresse,....) Cela génère un certificat "signature' qui est stocké dans un dépot "monStore"

Ensuite pour signer le jar :

 
Sélectionnez

jarsigner -keystore monStore -signedjar sMonJar.jar monJar.jar signature

Cela génère le jar "sMonJar.jar" qui est la version signée avec le certificat "signature" du jar "monJar.jar".

Créé le 7 juillet 2005  par christopheJ

Lien : Creating a Trusted Applet with Local File System Access Rights

Avant le SDK 1.4

 
Sélectionnez
Throwable t = new Throwable(); 
StringWriter sw = new StringWriter(); 
t.printStackTrace(new PrintWriter(sw, true)); 
String stackTrace = sw.toString(); 
 

La chaîne ainsi obtenue correspond a l'affichage d'un printStackTrace() d'une exception.

A partir du SDK 1.4

 
Sélectionnez
Throwable t = new Throwable(); 
StackTraceElement traces[] = t.getStackTrace(); 
 

Le tableau traces contient la pile d'exécution au moment de la création du Throwable. Le premier élément du tableau correspond a la création du Throwable, le dernier élément du tableau représente le bas de la pile.

Créé le 19 juillet 2004  par bulbo

Une astuce possible est d'utiliser une ServerSocket, du package java.net. On peut lancer un tel type de socket (sur un port précis) lors de l'exécution du main. Si une Exception est levée, cela indique qu'une instance de l'application est déjà en train de tourner. Voici un exemple :

 
Sélectionnez

private static int PORT = 12345; 
public static void main(String[] args) { 
      try { 
         new ServerSocket(PORT); 
         System.out.println("Instance du programme unique"); 
      }catch(Exception e){ 
         System.out.println("Il y a deja une instance du programme active"); 
         System.exit(0); 
      } 
} 

La seule difficulté sera de déterminer un port libre (non utilisé par une quelconque application de la machine).

Lorsque l'application est déployé via Java Web Start, il est possible d'utiliser un service conçu spécialement pour cela :

 
Sélectionnez

// Utilisation du service :
SingleInstanceService singleInstanceService = 
	(SingleInstanceService)ServiceManager.lookup("javax.jnlp.SingleInstanceService");
 
// Ajout d'un listener qui sera appelé pour chaque nouvelle instance :
singleInstanceService.addSingleInstanceListener( new SingleInstanceListener() {
	public void newActivation(String[] params) {
		// 'params' contient les paramètres passé à la nouvelle instance
	}
});
Mis à jour le 25 août 2007  par Debernad, jcarre, adiGuba

Lien : Classe javax.jnlp.SingleInstanceService
Lien : Qu'est-ce que Java Web Start ?

Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : - Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2014 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction, ne peut en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.