Implémentation de package JAR
Le package JAR peut être emballé à l'aide de la directive JAR. La saisie du pot dans la ligne de commande peut afficher le contenu de la directive JAR
D'après les deux exemples indiqués dans le dernier spectacle, il existe deux façons d'emballer. La différence entre les deux consiste à utiliser le fichier manifeste manifeste que vous avez défini. Le premier exemple n'est pas emballé à l'aide du fichier manifeste, donc le fichier manifeste dans le package JAR généré final est le fichier par défaut. Cette méthode convient à une structure de package JAR relativement simple, il n'y a pas d'autre dépendance de package JAR et le package JAR généré n'a pas besoin d'être exécutable. Le package JAR généré de cette manière ne peut pas être exécuté à l'aide de la commande java -jar XXX.jar car l'entrée du programme n'est pas spécifiée dans le fichier manifeste. La deuxième instance est une méthode d'emballage relativement courante, c'est-à-dire utiliser un fichier manifeste personnalisé pour participer à l'emballage, afin que vous puissiez ajouter des dépendances au package et spécifiez l'entrée du programme pour implémenter java -jar XXX.jar pour exécuter directement le package JAR.
La première méthode d'emballage simple
La chose la plus simple est de former et de sortir le fichier bytecode de classe compilé dans le dossier actuel. Les exemples sont les suivants:
Écrivez trois fichiers Java, test1.java test2.java et main.java
classe publique test1 {public static void main (String [] args) {} public void display () {System.out.println ("Ceci est class test1"); }}et fichier test2.java
classe publique test2 {public static void main (String [] args) {} public void display () {System.out.println ("Ceci est class test2"); }}Main.java
classe publique Main {public static void main (String [] args) {for (String a: args) {System.out.println ("Paramètre Gived" + a); } test1 t1 = new test1 (); t1.display (); test2 t2 = new test2 (); t2.display (); }} Compilez ces trois fichiers sur la ligne de commande et utilisez la commande javac pour compiler.
Utilisez la directive JAR pour emballer le fichier de classe compilé
La liste ajoutée s'affiche pendant l'emballage. Utilisez l'outil de décompression pour ouvrir le package test.jar généré et vous pouvez voir la structure suivante:
En plus des fichiers compilés à trois classes, il existe un dossier Meta-Inf supplémentaire, qui contient un manifeste.mf (fichier de liste). Le rôle de ce fichier est très important, comme expliqué plus loin. Regardons d'abord le contenu
Manifest très simple, ne contient que la version manifeste et la version Java.
L'exécution de java -jar test.jar à ce moment a l'effet suivant:
Aucune erreur d'attribut de liste principale signalée. En effet, nous utilisons la première méthode pour générer le pot en utilisant le manifeste par défaut. Le manifeste par défaut ne spécifie pas l'entrée du programme, donc une erreur se produit.
Vous pouvez modifier directement le fichier manifeste dans le package JAR (ouvrir l'outil de décompression et l'enregistrer après l'avoir modifié) et le modifier par l'effet suivant:
Après avoir exécuté à nouveau java -jar test.jar , le programme entre dans le contenu correct:
L'attribut de classe principale est ajouté au fichier manifeste et spécifie l'entrée du programme, qui réalise l'exécution directe du fichier JAR.
Par conséquent, l'utilisation du manifeste par défaut ne peut pas exécuter directement le fichier JAR. Utilisez le fichier manifeste que vous définissez pour l'emballer ou modifiez le fichier manifeste dans le package.
La deuxième façon de faire des emballages
La deuxième méthode d'emballage est plus générale. D'une manière générale, la première ligne du fichier Java est package XXX; Autrement dit, le nom du package, il détermine également le chemin du fichier de classe compilé. Lorsqu'il y a plusieurs fichiers Java à compiller et à être emballés et qu'ils ont différents noms de packages, il est très irréaliste d'écrire un fichier à un moment où l'emballer en fonction de la première méthode, il existe donc une deuxième méthode. Mettez tous les répertoires qui existent dans les fichiers de classe à emballer et les packages JAR de dépendance dans un dossier racine (tels que FOO), puis rédigez un fichier manifeste manifeste pour spécifier l'entrée du programme et d'autres packages JAR de dépendance ajoutés. Dans l'exécution de la commande:
Notez qu'il y a un espace et un point derrière foo/ dans la commande ci-dessus
Voyons un exemple ci-dessous
Il en va de même pour test1.java, test2.java et main.java, mais chacun a ses propres noms de packages.
package cn.mytest1; public class test1 {public static void main (String [] args) {} public void display () {System.out.println ("Ceci est class test1"); }} package cn.mytest2; public class test2 {public static void main (String [] args) {} public void display () {System.out.println ("Ceci est class test2"); }} package cn.mymain; import Cn.mytest1.test1; import Cn.Mytest2.Test2; public class Main {public static void main (String [] args) {for (string item: args) {System.out.println ("Passing Paramètre" + item); } test1 t1 = new test1 (); test2 t2 = new test2 (); t1.display (); t2.display (); }} Également compilés à l'aide de la directive Javac, les trois fichiers de classe existent dans différents chemins car leurs noms de packages sont différents. Mettez tous les dossiers compilés contenant des fichiers de classe dans le dossier FOO:
Ensuite, écrivez un fichier manifeste en dehors de FOO:
Le contenu du manifeste est le suivant:
Remarque : La dernière ligne du fichier manifeste est une ligne vide.
Exécutez la commande à partir de la ligne de commande: jar cvfm test.jar MANIFEST.MF -C foo/ .
Testez si le package JAR peut être exécuté directement sur la ligne de commande, utilisez la commande java -jar test.jar
Package correctement et exécutez le pot avec succès.
Introduction de fichiers manifestes
Grâce aux deux exemples ci-dessus, nous pouvons voir que le fichier manifeste est nécessaire pour l'emballage de JAR. Le fichier manifeste décrit les informations détaillées du fichier JAR emballé et existe dans le dossier Meta-Inf emballé. Le contenu principal d'un fichier manifeste simple est le suivant:
L'essentiel est que les trois attributs du chemin de classe de classe principale de la Version manifeste sont très importants lors de la fabrication de packages en pot. Manifeste-Version est le numéro de version, écrivez-le en conséquence. La classe principale est le programme d'entrée du package JAR, qui spécifie le nom complet de la classe en cours d'exécution (doit inclure le nom du package). De cette façon, vous pouvez utiliser java -jar name.jar pour exécuter directement le package JAR. Le troisième chemin de classe fait référence à d'autres packages JAR sur qui doivent être invoqués lors de l'emballage. Lors de l'emballage, votre programme peut également contenir d'autres packages JAR, vous devez donc ajouter des dépendances.
Notez qu'il existe un espace entre le côlon et le contenu de chaque attribut manifeste, et il doit y avoir une ligne vierge à la fin après l'écriture, sinon il y aura toujours une erreur dans le temps d'exécution que l'attribut de liste principale ne peut être trouvé.
résumé
La chose facile à faire des erreurs dans l'emballage de fichiers en pot est la rédaction de fichiers manifestes manifestes, qui sont sujets à formater des erreurs telles que peu d'espaces entre le côlon de l'attribut et le contenu, pas d'espaces entre l'ajout de dépendances dans le chemin de classe, trop de dépendances, pas d'espaces au début de chaque ligne lors de la rédaction de lignées à l'écriture, pas de temps à la fin du fichier, etc. Emballage.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.