Voyage du fichier Java à un fichier de pot

Ce guide détaille le processus de création d'un fichier JAR à partir d'un fichier source Java. Nous couvrirons chaque étape avec des explications et des exemples.

Étape 1: Création de code Java

Créez un fichier .java contenant votre code Java. Par exemple, un fichier nommé Main.java peut ressembler à ceci:

<code class="language-java">public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}</code>

Ceci est votre code source, adhérant à la syntaxe et aux règles de Java.

Étape 2: compilation

compiler le fichier .java à l'aide du compilateur java (javac):

<code class="language-bash">javac Main.java</code>

Cela génère un fichier .class (par exemple, Main.class) contenant des bytecode - instructions lisibles par machine pour la machine virtuelle Java (JVM). Chaque fichier .java produit un fichier .class correspondant.

Étape 3: Fichier manifeste (facultatif)

Créer un fichier MANIFEST.MF (facultatif mais recommandé) pour définir les métadonnées JAR. Par exemple:

<code>Main-Class: Main</code>

Main-Class Spécifie le point d'entrée de l'application (la classe avec la méthode main). Cela simplifie l'exécution du pot.

Étape 4: Emballage de fichiers JAR

Utilisez la commande jar pour emballer le fichier .class, les ressources, et (éventuellement) le fichier manifeste dans un pot:

<code class="language-bash">jar cvfm MyApplication.jar MANIFEST.MF Main.class</code>

• c: Crée un nouveau pot.
• v: Active la sortie verbeuse (affiche le processus d'emballage).
• f: Spécifie le nom de fichier de sortie du jar (MyApplication.jar).
• m: inclut le fichier manifeste (MANIFEST.MF).

L'outil jar crée une seule archive portable (MyApplication.jar) contenant tous les composants compilés.

Étape 5: test de fichiers JAR

Exécutez le fichier JAR pour vérifier ses fonctionnalités:

<code class="language-bash">java -jar MyApplication.jar</code>

L'exécution réussie devrait produire la sortie:

<code>Hello, World!</code>

Le JVM utilise le MANIFEST.MF (si présent) pour localiser le Main-Class et exécuter sa méthode main.

Étape 6: déploiement de fichiers JAR

Le déploiement dépend de l'environnement cible:

• autonome: Copiez le pot sur la machine cible et exécutez-le en utilisant java -jar.
• Microservices (par exemple, Spring Boot): Déployez le "Jar de graisse" (contenant un serveur intégré) en utilisant java -jar.
• contenerisé (docker): Utilisez un dockerfile:

<code class="language-dockerfile">FROM openjdk:17
COPY MyApplication.jar /app/MyApplication.jar
WORKDIR /app
CMD ["java", "-jar", "MyApplication.jar"]</code>

build (docker build -t my-java-app .) et exécuter (docker run -p 8080:8080 my-java-app) le conteneur.

• Cloud: Déployer sur les plates-formes cloud (AWS, GCP, Azure) via des services CI / CD ou spécifiques au cloud.

Résumé de l'exécution:

1. Écrivez du code java (.java).
2. Compiler aux fichiers .class en utilisant javac.
3. (facultatif) Créer MANIFEST.MF.
4. package dans un pot en utilisant jar.
5. Testez le pot en utilisant java -jar.
6. Déployer dans l'environnement approprié.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!