Tout ce que vous vouliez savoir sur Maven. (Partie 2) - "Projet Java de A à Z"

Tout sur Maven : le début J'adore pratiquer. Vous ne pouvez même pas imaginer à quel point il peut parfois être fastidieux d’écrire sur la théorie. Cependant, vous ne pouvez aller nulle part sans elle. La pratique est bien entendu une autre affaire. Passons maintenant rapidement en revue les commandes que j'ai décrites précédemment, et nous terminerons)

Configuration de pom.xml

Pendant que nous réfléchissions, nous avons obtenu un très bon pom.xml :

Voir le code

<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://maven.apache.org/POM/4.0.0"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                     http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.github.javarushcommunity</groupId>
   <artifactId>maven-demo</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>Maven Demo Project</name>

   <url>https://github.com/javarushcommunity/maven-demo/</url>

   <licenses>
       <license>
           <name>The Apache Software License, Version 2.0</name>
           <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
       </license>
   </licenses>

   <developers>
       <developer>
           <id>romankh3</id>
           <name>Roman Beskrovnyi</name>
           <email>roman.beskrovnyy@gmail.com</email>
       </developer>
   </developers>

   <scm>
       <connection>git@github.com:javarushcommunity/maven-demo.git</connection>
       <developerConnection>git@github.com:javarushcommunity/maven-demo.git</developerConnection>
       <url>https://github.com/javarushcommunity/maven-demo</url>
   </scm>

   <properties>
       <mockito.version>2.26.0</mockito.version>
       <junit.version>5.5.2</junit.version>
       <image.comparison.version>4.3.0</image.comparison.version>
       <maven.compiler.source>1.8</maven.compiler.source>
       <maven.compiler.target>1.8</maven.compiler.target>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <javadoc.plugin.version>3.1.1</javadoc.plugin.version>
       <source.plugin.version>3.2.0</source.plugin.version>
   </properties>

   <dependencies>
       <dependency>
           <groupId>org.mockito</groupId>
           <artifactId>mockito-core</artifactId>
           <version>${mockito.version}</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>org.junit.jupiter</groupId>
           <artifactId>junit-jupiter-api</artifactId>
           <version>${junit.version}</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>com.github.romankh3</groupId>
           <artifactId>image-comparison</artifactId>
           <version>${image.comparison.version}</version>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-source-plugin</artifactId>
               <version>${source.plugin.version}</version>
               <executions>
                   <execution>
                       <id>attach-sources</id>
                       <goals>
                           <goal>jar</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-javadoc-plugin</artifactId>
               <version>${javadoc.plugin.version}</version>
               <executions>
                   <execution>
                       <id>attach-javadocs</id>
                       <goals>
                           <goal>jar</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>
</project>

- Mais pour avoir quelque chose à compiler, il faut que ça y soit ajouté ! Logique? - Oui capitaine. bgg Par conséquent, ajoutons une classe qui aura une méthode et deux tests pour celle-ci. Créons un schéma de dossiers standard pour Maven : Dans src/main/java nous allons créer un package dans lequel nous travaillerons. Pour le composer correctement, il serait bien de mettre le nom de l'organisation ( groupId ) au début, puis le nom du projet. Dans notre cas, ce sera comme ceci : com.github.javarushcommunity.mavendemo Quant à moi, c'est un très bon package. Nous y créerons la classe ImageComparator , pour laquelle nous écrirons deux tests.

Connecter Maven et le projet dans son ensemble à IDEA

Pour que l'idée puisse reconnaître nos dépendances et proposer de les utiliser dans le projet, nous devons faire plusieurs choses :

1. Dites à l'idée où seront les sources du code et où seront les tests.
2. Ajoutez un projet maven à l'idée.

Pour réaliser le premier, vous devez trouver cette icône : Cliquez dessus et rendez-vous dans la section Modules . Ensuite, vous devez attribuer aux dossiers créés le marqueur requis, comme le montre la figure ci-dessous : C'est-à-dire :

• • src/main/java - Sources
• • src/main/resources - Ressources
• • src/test/java - Tests
• • src/test/resources - Ressources de test
• • cible – Exclus

Toutes ces Sources, Ressources, Test, Ressources de Test et Exclues se trouvent sur la ligne où Marquer comme est écrit . Sélectionnez un dossier et étiquetez-le en conséquence. Et la deuxième étape consiste à ajouter le projet maven à IDEA afin qu'il puisse opérer sa magie. Pour ce faire, vous devez rechercher le fichier pom.xml dans IDEA et cliquer avec le bouton droit pour sélectionner Ajouter en tant que projet Maven . Et c'est tout, vous serez heureux (: Après cela, une plaque Maven apparaîtra sur la droite , que vous pourrez ouvrir et exécuter des commandes Maven.

Nous écrivons des sources et des tests pour notre « projet »

Nous avons donc ajouté Maven à l’idée, décrivons maintenant la classe qui nous servira de sources :

Comparateur d'images :

package com.github.javarushcommunity.mavendemo;

import com.github.romankh3.image.comparison.ImageComparison;
import com.github.romankh3.image.comparison.model.ImageComparisonResult;
import com.github.romankh3.image.comparison.model.ImageComparisonState;

import java.awt.image.BufferedImage;

/**
* Class created for answering, does two images the same or not.
*/
public class ImageComparator {

   /**
    * Method, which says the same images or not.
    *
    * @param image1 image1 for comparison
    * @param image2 image2 for comparison
    * @return return true, if images are the same, false - otherwise.
    */
   public boolean isTheSameImages(BufferedImage image1, BufferedImage image2) {
       //Create ImageComparison object
       ImageComparison imageComparison = new ImageComparison(image1, image2);

       //Compare images
       ImageComparisonResult imageComparisonResult = imageComparison.compareImages();

       //Check, that ImageComparisonState is MATCH:
       return ImageComparisonState.MATCH == imageComparisonResult.getImageComparisonState();
   }
}

Créons des tests à cet effet. La classe qui teste doit être dans le même package, uniquement dans src/test/java. L'idée le sait et vous pouvez profiter de ses capacités. Pour cela, cliquez sur le nom de la classe dans le fichier lui-même et sélectionnez Créer un test sur l'ampoule qui apparaît : Il nous sera demandé de sélectionner les paramètres du futur test. Nous n'installons rien, cliquez simplement sur OK : pour notre test, nous effectuerons une comparaison d'images à partir des images de test et les placerons dans des ressources de test (src/test/resource). Après cela, nous écrirons deux tests. On vérifiera que ces deux images sont différentes. Et dans l’autre, nous transmettrons la même image et attendrons une réponse indiquant qu’elles sont identiques. On obtient alors le test suivant :

package com.github.javarushcommunity.mavendemo;

import com.github.romankh3.image.comparison.ImageComparisonUtil;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.awt.image.BufferedImage;

@DisplayName("Unit-level testing for ImageComparator")
class ImageComparatorTest {

   private final ImageComparator comparator = new ImageComparator();

   @Test
   public void shouldConfirmImagesNotTheSame() {
       //given
       BufferedImage image1 = ImageComparisonUtil.readImageFromResources("image1.png");
       BufferedImage image2 = ImageComparisonUtil.readImageFromResources("image2.png");

       //when
       boolean theSameImages = comparator.isTheSameImages(image1, image2);

       //then
       Assertions.assertFalse(theSameImages);
   }

   @Test
   public void shouldConfirmImagesTheSame() {
       //given
       BufferedImage image1 = ImageComparisonUtil.readImageFromResources("image1.png");

       //when
       boolean theSameImages = comparator.isTheSameImages(image1, image1);

       //then
       Assertions.assertTrue(theSameImages);
   }
}

Les tests sont très simples, je ne m’y attarderai pas. Si vous êtes intéressé, j'écrirai un jour un article sur les tests (écrivez-le dans les commentaires).

Exécuter les commandes Maven

Maintenant, quand tout est prêt pour voir le travail des équipes, sélectionnez notre projet dans le plugin Maven et ouvrez Lifecycle dedans : Cliquez maintenant sur compiler et voyez ce qui s'est passé : De là, nous pouvons tirer deux conclusions :

1. Nos sources ont été compilées et placées dans le chemin spécifié.
2. La commande a réussi - BUILD SUCCESS.

Et vraiment, si nous allons dans la structure du projet et regardons ce qui a changé là-bas, nous verrons que le dossier cible a été ajouté , que nous pouvons toujours explorer et trouver notre classe ImageComparator compilée : Maintenant, j'aimerais démarrer un nouveau package commande à partir de zéro. Pour ce faire, exécutons (cliquez deux fois) la commande clean : Du coup, on nous dit que nous avons supprimé le dossier cible , qui contenait tout ce qui a été créé après la commande de compilation . Lançons la commande test : Tests run: 0... mais nous en avons écrit jusqu'à DEUX. Autrement dit, pour une raison quelconque, les tests n'ont pas été exécutés. Le live coding, c'est comme ça, allons sur le web) Après 5 minutes de recherche sur Google, j'ai découvert qu'avec JUnit5, vous deviez ajouter un plugin supplémentaire :

<plugin>
   <groupId>org.apache.maven.plugins</groupId>
   <artifactId>maven-surefire-plugin</artifactId>
   <version>2.22.2</version>
</plugin>

Ajoutons-le au projet, mettons la version dans <properties/> du mieux que nous pouvons et recommençons le test : Maintenant c'est une autre affaire ! Deux tests ont été exécutés et ont réussi. Feu! Maintenant, nous exécutons notre package et espérons trouver le jarnik dans le dossier cible : c'est-à-dire que nous voyons à nouveau que les tests ont réussi, et après cela (garantissant que tout dans le projet est bon), nous pouvons rassembler le projet dans un archive. La figure montre qu'il existe une archive dans les journaux de lancement de Maven et la structure du projet. Ensuite, nous avons install . Bonne équipe. Oh, avant que j'oublie. Il est considéré comme une bonne pratique de nettoyer le projet avant d'exécuter une nouvelle commande en exécutant clean . Cela vous évitera des bêtises à l'avenir - je le garantis d'après ma propre expérience))) Par conséquent, nous exécutons d'abord clean , puis installons : Là où se trouve la flèche, vous pouvez clairement voir où se trouve le référentiel local. D'après ce qu'ils écrivent, ceci est sur mon chemin : /Users/roman_beskrovnyi/.m2 Et l'archive elle-même se trouvera ici : /Users/roman_beskrovnyi/.m2/repository/com/github/javarushcommunity/maven-demo/1.0- INSTANTANÉ Et si nous allons au terminal et essayons d'entrer dans le dossier où se trouve l'archive, alors elle sera là : déployer ne nous le montrera pas, et vous n'avez pas encore besoin des autres...

Au lieu de la sortie

Aujourd'hui, nous avons rapidement expliqué ce qu'est Maven, ce qu'il contient, quelles sont ses principales commandes. J'ai essayé de transmettre cela simplement et avec des exemples. Tout le code source de l'exemple se trouve dans l'organisation JavaRush Community sur GitHub dans le projet maven-demo . Écrivez toutes les questions dans les commentaires. Comme d'habitude, je vous propose de vous abonner à mon compte sur Github pour ne pas rater le nouveau code de notre projet JRTB. Encore une fois, il n'est pas mort. Il était simplement en stase))

Une liste de tous les matériaux de la série se trouve au début de cet article.