Tutto quello che volevi sapere su Maven. (Parte 2) - "Progetto Java dalla A alla Z"

Tutto su Maven: l'inizio mi piace esercitarmi. Non puoi nemmeno immaginare quanto possa essere noioso a volte scrivere di teoria. Tuttavia, non puoi andare da nessuna parte senza di lei. La pratica è un'altra questione, ovviamente. Adesso passiamo velocemente ai comandi che ho descritto precedentemente, e concludiamo)

Configurazione di pom.xml

Mentre stavamo teorizzando, abbiamo ottenuto un pom.xml piuttosto buono:

Visualizza codice

<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>

- Ma per avere qualcosa da compilare, deve essere aggiunto lì! Logico? - Sì, capitano. bgg Aggiungiamo quindi una classe che avrà un metodo e due test. Creiamo uno schema di cartelle regolare per Maven: In src/main/java creeremo un pacchetto in cui lavoreremo. Per comporlo correttamente sarebbe bene mettere all'inizio il nome dell'organizzazione ( groupId ) e poi il nome del progetto. Nel nostro caso sarà così: com.github.javarushcommunity.mavendemo Per quanto mi riguarda, questo è un ottimo pacchetto. In esso creeremo la classe ImageComparator , per la quale scriveremo due test.

Collegare Maven e il progetto nel suo insieme a IDEA

Affinché l'idea possa riconoscere le nostre dipendenze e offrirsi di utilizzarle nel progetto, dobbiamo fare diverse cose:

1. Spiega l'idea di dove saranno le sorgenti del codice e dove saranno i test.
2. Aggiungi un progetto esperto all'idea.

Per ottenere il primo, devi trovare questa icona: cliccaci sopra e vai alla sezione Moduli . Successivamente è necessario dare alle cartelle create il contrassegno richiesto, come mostrato nella figura seguente: Cioè:

• • src/main/java - Sorgenti
• • src/main/resources - Risorse
• • src/test/java - Test
• • src/test/resources - Testare le risorse
• • target - Escluso

Tutte queste Fonti, Risorse, Test, Risorse di test ed Escluse si trovano nella riga in cui è scritto Contrassegna come . Seleziona una cartella ed etichettala di conseguenza. E il secondo passo è aggiungere il progetto Maven a IDEA in modo che possa funzionare con la sua magia. Per fare ciò, devi trovare il file pom.xml in IDEA e fare clic con il pulsante destro del mouse per selezionare Aggiungi come progetto Maven . E questo è tutto, sarai felice (: Dopodiché, sulla destra apparirà una piastra Maven , che puoi aprire ed eseguire i comandi Maven al suo interno.

Scriviamo sorgenti e test per il nostro “progetto”

Quindi abbiamo aggiunto Maven all’idea, ora descriviamo la classe che fungerà da sorgente per noi:

Comparatore di immagini:

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();
   }
}

Creiamo dei test per questo scopo. La classe che testa deve essere nello stesso pacchetto, solo in src/test/java. L'idea lo sa e puoi sfruttare le sue capacità. Per fare ciò, clicchiamo sul nome della classe presente nel file stesso e selezioniamo Crea test sulla lampadina che appare: ci verrà chiesto di selezionare le impostazioni per il test futuro. Non installiamo nulla, basta fare clic su OK: per il nostro test, prenderemo il confronto delle immagini dalle immagini di test e le inseriremo nelle risorse di test (src/test/resource). Successivamente scriveremo due test. Si verificherà che queste due immagini siano diverse. E nell'altro trasmetteremo la stessa immagine e ci aspetteremo una risposta che sono la stessa cosa. Quindi otteniamo il seguente test:

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);
   }
}

I test sono molto semplici, non mi dilungherò su di essi. Se sei interessato, un giorno scriverò un articolo sui test (scrivilo nei commenti).

Esegui comandi Maven

Ora, quando tutto è pronto per vedere il lavoro dei team, seleziona il nostro progetto nel plugin Maven e apri Lifecycle al suo interno : Ora fai clic su compila e guarda cosa è successo: Da questo possiamo trarre due conclusioni:

1. I nostri sorgenti sono stati compilati e inseriti nel percorso specificato.
2. Il comando ha avuto successo: BUILD SUCCESS.

E in realtà, se andiamo alla struttura del progetto e guardiamo cosa è cambiato lì, vedremo che è stata aggiunta la cartella di destinazione , che possiamo ancora esplorare e trovare la nostra classe ImageComparator compilata : Ora vorrei iniziare un nuovo pacchetto comandare da zero. Per fare ciò, eseguiamo (cliccando due volte) il comando clean : di conseguenza, ci viene detto che abbiamo eliminato la cartella di destinazione , che conteneva tutto ciò che era stato creato dopo il comando compile . Eseguiamo il comando test : Test eseguiti: 0... ma ne abbiamo scritti ben DUE. Cioè, per qualche motivo i test non sono stati eseguiti. Il live coding è così, andiamo sul web) Dopo 5 minuti di ricerca su Google, ho scoperto che con JUnit5 è necessario aggiungere un altro plugin:

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

Aggiungiamolo al progetto, inseriamo la versione in <properties/> come meglio possiamo e riavviamo il test : ora è una questione diversa! Sono stati eseguiti due test e hanno avuto esito positivo. Fuoco! Adesso eseguiamo il nostro pacchetto e aspettiamo di trovare il jarnik nella cartella di destinazione : cioè vediamo di nuovo che i test sono stati superati, e dopo questo (garantisce che tutto nel progetto sia buono) possiamo raccogliere il progetto in un archivio. La figura mostra che esiste un archivio nei registri di lancio di Maven e nella struttura del progetto. Successivamente abbiamo install . Grande squadra. Oh, prima che mi dimentichi. È considerata buona pratica pulire il progetto prima di eseguire un nuovo comando eseguendo clean . Questo ti salverà da sciocchezze in futuro - lo garantisco dalla mia esperienza))) Pertanto, prima eseguiamo clean e poi installiamo : dove si trova la freccia, puoi vedere chiaramente dove si trova il repository locale. In base a ciò che scrivono, questo è sulla mia strada: /Users/roman_beskrovnyi/.m2 E l'archivio stesso si troverà qui: /Users/roman_beskrovnyi/.m2/repository/com/github/javarushcommunity/maven-demo/1.0- SNAPSHOT E se andiamo al terminale e proviamo ad entrare nella cartella dove si trova l'archivio, allora sarà lì: deploy non ce lo mostrerà, e non ti servono ancora gli altri...

Invece di uscita

Oggi abbiamo esaminato rapidamente cos'è Maven, cosa c'è, quali sono i comandi principali lì. Ho cercato di trasmetterlo in modo semplice e con esempi. Tutto il codice sorgente dell'esempio si trova nell'organizzazione della community JavaRush su GitHub nel progetto maven-demo . Scrivi tutte le domande nei commenti. Come al solito ti consiglio di iscriverti al mio account su Github per non perdere il nuovo codice per il nostro progetto JRTB. Ancora una volta, non è morto. Era semplicemente in stasi))

Un elenco di tutti i materiali della serie si trova all'inizio di questo articolo.