Compilation en Java

La programmation dans un IDE est géniale : cohérence des dépendances du code, débogage pratique, tests clairs, thème sombre. Ainsi, grâce à l'IDE, le développement se développe à pas de géant. Mais elle se détend. Chaque jour, en s'immergeant dans les fonctionnalités de l'EDI, le développeur s'habitue à s'engager avec un seul bouton ou à construire en deux clics. La situation est bien pire avec ceux qui débutent en programmation et qui travaillent dans l'IDE dès le début, ignorant le travail sur la ligne de commande. Par exemple, dans Intellij IDEA, la compilation d'une application Java est démontrée par une barre de chargement dans le panneau inférieur, et tous les paramètres de compilation, le traitement du chemin de classe et d'autres plaisirs de la vie Java restent en coulisses. Nous suggérons de parler de compilation en Java sans IDE. Pour exécuter les exemples de cet article, assurez-vous que JDK 1.7 ou version ultérieure est installé sur votre ordinateur.

Comment compiler un programme ?

La compilation en programmation est la réduction du code source en bytecode pour le démarrage ultérieur du programme. La séquence d'actions depuis le code source jusqu'au lancement du programme ressemble à ceci :

1. Il existe du code source dans un fichier appelé ClassName.java ;
2. S'il n'y a pas d'erreurs dans le code, il est compilé en bytecode (dans le fichier ClassName.class) ;
3. Le programme démarre.

En règle générale, chaque programme est contenu dans un répertoire distinct. À titre d'exemple simple, prenons la sortie vers la console :

class Test {
   public static void main(String[] args) {
      System.out.println("Это говорит приложение из командной строки");
   }
}

A quoi sert la commande javac ?

Bon, le premier point est réglé. Allons plus loin pour comprendre : comment compiler ? :) La commande javac nous y aidera, dont l'argument doit spécifier le fichier requis :

javac Test.java

S'il n'y a aucune erreur dans le code, un fichier Test.class apparaîtra à côté du fichier Test.java. Il s'agit du bytecode compilé. Il faut maintenant le lancer. Ici, nous utilisons la commande java, qui exécute le bytecode : La capture d'écran montre que nous obtenons des hiéroglyphes dans la sortie : évidemment, il s'agit d'un encodage cassé. Cela se produit généralement sur un système Windows. Pour afficher correctement l'alphabet cyrillique dans la console, il existe les commandes suivantes :

REM change CHCP to UTF-8
CHCP 65001
CLS

Ils modifient la page de codes shell actuelle pour la durée de la fenêtre actuelle. Essayons encore:

D:\Java>java Test

C'est ce que dit l'application depuis la ligne de commande. Connaître le fonctionnement de la commande javac est très utile, puisque cette commande est la base de tout système de construction de projet.

Compilation et exécution de plusieurs classes

Pour travailler avec plusieurs classes, vous avez besoin d'un chemin de classe. Il est similaire à un système de fichiers dans lequel les classes sont contenues et les packages agissent comme des dossiers. À ce stade, cela vaut la peine de penser à séparer les fichiers de code source des fichiers compilés. En règle générale, les sources se trouvent dans le répertoire src et les classes compilées dans bin. Par exemple, nous avons une classe Boxet une classe BoxMachinequi contient une méthode main. Classe Box:

package src;

public class Box {
   private double size;

   public Box(double size) {
       this.size = size;
   }

   public String toString() {
       return "Box have size " + size;
   }
}

C'est dans le package src et doit être corrigé. Classe BoxMachine:

package src;

public class BoxMachine {
   public static void main(String[] args) {
       for(int  i = 0; i < 5; i++) {
           System.out.println(new Box(Math.random()*10));
       }
   }
}

Cette classe se trouve également dans le package src. Dans la méthode main, il crée cinq objets de classe Boxde tailles différentes et affiche des informations les concernant sur la console. Pour compiler ce groupe de classes, vous devez utiliser la commande javac du répertoire principal (qui contient les dossiers src et bin) avec les arguments :

javac -d bin ./src/*

-d— un drapeau après lequel vous devez indiquer l'emplacement où iront les classes compilées. C'est très pratique, car le transfert, par exemple, de 1 000 classes est un processus très laborieux. bin- nom de dossier. ./src/*— emplacement des fichiers sources. *indique que tous les fichiers doivent être compilés. Les classes compilées apparaissent désormais dans le dossier bin. Pour les exécuter, utilisez la commande java du même répertoire, également avec des arguments :

java -classpath ./bin BoxMachine

-classpath— un drapeau après lequel vous devez indiquer l'emplacement des classes compilées. Java recherchera la classe principale et toutes les classes associées dans ce répertoire. ./bin— le nom du dossier dans lequel se trouvent les classes compilées. BoxMachine— nom de la classe principale. Comme dans le premier cas, ne doit pas être spécifié .class, puisqu'il s'agit du nom d'une classe et non d'un fichier. Conclusion:

D:\Java>java -classpath ./bin src.BoxMachine
Box have size 4.085985295359718
Box have size 8.63682158248986
Box have size 6.027448124299726
Box have size 7.288317703877914
Box have size 1.106181659384694

Création de fichiers JAR

Pour rendre le programme facile à porter et à exécuter, vous pouvez rassembler les classes compilées dans un fichier jar - une archive de classes. La principale différence avec les archives zip ou rar est la présence d'un fichier manifeste. Ce manifeste spécifie la classe principale qui sera exécutée lors de l'exécution du fichier jar, le chemin de classe et de nombreuses informations supplémentaires. Créons un fichier manifest.mf dans le répertoire principal. Son contenu sera le suivant :

main-class: src.BoxMachine
class-path: bin/

main-classspécifie la classe qui contient la méthode mainet sera exécutée au démarrage. class-path— chemin vers les classes compilées ou les bibliothèques supplémentaires. Il est maintenant temps de créer un vrai programme sans IDE en utilisant la commande jar :

jar -cmf manifest.mf box-machine.jar  -C bin .

-cmf— un indicateur après lequel vous devez spécifier le chemin d'accès au fichier manifeste. manifest.mf- chemin vers le manifeste. box-machine.jar- nom du fichier jar de sortie. -С— un indicateur après lequel le chemin vers les classes compilées est indiqué. .— le chemin où le fichier jar sera placé. Dans notre cas, il s'agit du répertoire principal. Vous pouvez maintenant lancer. Le lancement des fichiers jar se fait également à l'aide de la commande java, mais vous devez ensuite spécifier le flag -jar: il indique que le fichier Jar est en cours de lancement, et le deuxième argument est le chemin d'accès au jarfichier, y compris l'extension :

java -jar box-machine.jar

Conclusion:

Box have size 5.5495235762547965
Box have size 9.695870044165662
Box have size 2.3408385788129227
Box have size 7.2790741216674135
Box have size 2.3620854470160513

Compiler en Java sans IDE : un aperçu des systèmes de build

Malgré la relative facilité d'utilisation de la ligne de commande, il est très difficile de créer des projets de taille moyenne et grande en l'utilisant. Cela prend beaucoup de temps et comporte de nombreuses erreurs à des degrés divers. Heureusement, il existe des systèmes d'assemblage qui facilitent grandement le processus de travail. Avec plusieurs équipes, ce système peut assembler un projet de toute complexité, et l'abondance de plugins créés au cours de l'existence de tels systèmes peut éliminer presque tous les maux de tête.

Comment compiler Java ?

Les systèmes de build Java les plus connus sont Ant, Maven et Gradle. Il n'y a pas de bon ou de mauvais : chacun d'eux est créé pour résoudre certains problèmes. Examinons chacun d'eux plus en détail.

Fourmi

Ant est un outil de construction qui utilise un script décrit à l'aide d'un fichier XML. Structure du fichier XML :

<?xml version="1.0"?>
<project name="NameПроекта" default="сценарийПоУмолчанию">
    <target name="NameСценария">
  //  Действия сценария
        <echo>Hello, World!</echo>
    </target>
  //  Второй сценарий
  //  И тд
</project>

Créons un fichier build.xml dans le répertoire principal avec le contenu suivant :

<?xml version="1.0"?>
<project name="BoxMachine" default="test">
   <target name="test">
       <echo>First build in Ant!</echo>
   </target>
</project>

Dans le même répertoire, appelez la commande ant :

D:\Java>D:\Temp\ant\bin\ant
Buildfile: D:\Java\build.xml

test:
     [echo] First build in Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

La balise <target>peut spécifier diverses tâches qui vous permettent de gérer l'assembly et le système de fichiers. Ant dispose de plus de 150 commandes disponibles, répertoriées dans la documentation. Dans l’exemple ci-dessous nous n’en utilisons que 5 :

• mkdir - création de répertoires
• delete- suppression de fichiers et de répertoires
• javac- Compilation de code Java
• java- exécuter du code compilé

Voici à quoi ressemble un simple script de compilation, de construction ou de nettoyage :

<?xml version="1.0"?>
<project name="BoxMachine" default="compile">
   <target name="compile">
       <mkdir dir="result/classes"/>
       <javac destdir="result/classes" includeantruntime="false">
           <src path="src"/>
       </javac>
   </target>
   <target name="run" depends="compile">
       <java classname="BoxMachine" classpath="result/classes"/>
   </target>
   <target name="clean">
       <delete dir="result"/>
   </target>
</project>

Le script décrit trois actions - compile, ,code>run et clean. compilecrée un répertoire de résultats contenant des classes, puis utilise javac pour compiler les classes dans le répertoire créé. runexécute les classes compilées avec la commande java. cleansupprime le répertoire de résultats. Si vous exécutez la commande ant sans arguments dans le répertoire principal, l'action de compilation s'exécutera. Si une action spécifique doit être effectuée, elle est spécifiée dans l'argument.

D:\Java>D:/Temp/ant/bin/ant compile
Buildfile: D:\Java\build.xml

compile:
    [mkdir] Created dir: D:\Java\result\classes
    [javac] Compiling 2 source files to D:\Java\result\classes

BUILD SUCCESSFUL
Total time: 1 second

Maven

Maven propose une approche légèrement différente de la création de projets. Ici, le développeur décrit plutôt son projet et les outils complémentaires qu'il utilise, contrairement à Ant, où le build est une séquence d'actions. Maven est populaire parmi les développeurs en raison de sa gestion simple des dépendances et de son intégration pratique avec tous les environnements de développement. Lorsque nous travaillons avec Maven, nous adhérons à la structure de projet suivante : les règles de construction, les dépendances, etc. sont décrites dans le fichier pom.xml. Il se trouve généralement dans le dossier principal du projet. Au démarrage, Maven vérifie la structure et la syntaxe du fichier, vous avertissant des erreurs. Dans le répertoire principal, à côté des dossiers bin et src, créez un fichier pom.xml, ajoutez à l'intérieur :

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>ru.javarush.testmaven</groupId>
  <artifactId>testMavenWithoutIde</artifactId>
  <version>1.0.0</version>

  <build>
     <defaultGoal>compile</defaultGoal>
     <sourceDirectory>src</sourceDirectory>
     <outputDirectory>bin</outputDirectory>
     <finalName>${project.artifactId}-${project.version}</finalName>
  </build>
</project>

Ensuite, exécutez la commande mvn sur la ligne de commande :

D:\Java>mvn
[INFO] Scanning for projects...
[INFO]
[INFO] -------------< ru.javarush.testmaven:testMavenWithoutIde >--------------
[INFO] Building testMavenWithoutIde 1.0.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ testMavenWithoutIde ---
[WARNING] Using platform encoding (Cp1251 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory D:\Java\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ testMavenWithoutIde ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1251, i.e. build is platform dependent!
[INFO] Compiling 2 source files to D:\Java\bin
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 15.521 s
[INFO] Finished at: 2019-06-25T20:18:05+03:00
[INFO] ------------------------------------------------------------------------

Il y a maintenant un dossier src dans le dossier bin où se trouvent les classes compilées. Dans pom.xml, la balise build définit le but de la build - compilation, les répertoires du code source et des fichiers de résultat de la compilation, ainsi que le nom du projet. Maven dispose d'une variété de cibles de build et de plugins pour exécuter des tests, créer des fichiers Jar, créer des distributions et d'autres tâches.

Graduation

Il s'agit du système de construction le plus récent, basé sur Ant et Maven. La principale différence est qu'il fonctionne sur la base d'un graphique acyclique pour déterminer l'ordre des tâches. Ceci est très utile pour les tâches plus complexes, telles que les builds incrémentielles et multi-projets. Lors de la construction avec Gradle, il est également recommandé de s'en tenir à la structure des dossiers du projet Maven. À propos, le fichier de construction dans Gradle s'appelle build.gradle et semble beaucoup plus petit que celui de Maven. Exemple pour nos cours :

apply plugin: 'java'
apply plugin: 'application'

sourceSets {
   main {
       java {
           srcDirs 'src'
       }
   }
}
sourceSets.main.output.classesDir = file("bin")

mainClassName = "src.BoxMachine"

defaultTasks 'compileJava', 'run'

Le fichier inclut les plugins, définit le répertoire des fichiers de code source (si la structure du projet Maven n'est pas utilisée), le répertoire des résultats de build, le nom de la classe principale et les tâches par défaut. La commande gradle dans le répertoire où se trouve le fichier build.gradle est responsable du démarrage de la build :

d:\Java>D:\Temp\gradle\bin\gradle

Welcome to Gradle 5.4.1!

Here are the highlights of this release:
 - Run builds with JDK12
 - New API for Incremental Tasks
 - Updates to native projects, including Swift 5 support

For more details see https://docs.gradle.org/5.4.1/release-notes.html

Starting a Gradle Daemon (subsequent builds will be faster)

> Task :help

Welcome to Gradle 5.4.1.

To run a build, run gradle <task> ...

To see a list of available tasks, run gradle tasks

To see a list of command-line options, run gradle --help

To see more detail about a task, run gradle help --task <task>

For troubleshooting, visit https://help.gradle.org

BUILD SUCCESSFUL in 52s
1 actionable task: 1 executed

Conclusion

À première vue, la possibilité de compiler et d’assembler du code sans IDE semble inutile. En effet, pourquoi s'embêter avec les lignes de commande et Google toutes les commandes quand il existe un IDE confortable avec des plugins, une vérification automatique de tout ce qui est possible (les IDE modernes ne vérifient pas le niveau de QI) et une intégration avec les systèmes populaires. Cependant, la pratique montre que la capacité d'assembler du code sans environnement de développement et de comprendre chaque étape de ce processus est une nécessité absolue. Cette compétence permettra à vous et à votre entreprise d'économiser beaucoup de cellules nerveuses et de temps. Vous pouvez apprendre à utiliser l'EDI, vous entraîner à écrire du code et, bien sûr, acquérir les bases de la programmation Java ici, sur JavaRush. Il est temps de recommencer à apprendre :)