Alles, was Sie über Maven wissen wollten. (Teil 2) - „Java-Projekt von A bis Z“

Alles über Maven: Der Anfang, den ich gerne übe. Sie können sich gar nicht vorstellen, wie mühsam es manchmal sein kann, über Theorie zu schreiben. Allerdings kann man ohne sie nirgendwo hingehen. Übung ist natürlich eine andere Sache. Lassen Sie uns nun kurz die Befehle durchgehen, die ich zuvor beschrieben habe, und wir kommen zum Schluss.)

pom.xml einrichten

Während wir theoretisierten, bekamen wir eine ziemlich gute pom.xml:

Code ansehen

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

- Aber um etwas zum Kompilieren zu haben, muss es dort hinzugefügt werden! Logisch? - Jawohl Kapitän. bgg Fügen wir daher eine Klasse hinzu, die eine Methode und zwei Tests dafür hat. Erstellen wir ein reguläres Ordnerschema für Maven: In src/main/java erstellen wir ein Paket, in dem wir arbeiten. Um es richtig zu verfassen, wäre es sinnvoll, am Anfang den Namen der Organisation ( groupId ) und dann den Namen des Projekts zu setzen. In unserem Fall wird es so aussehen: com.github.javarushcommunity.mavendemo Für mich ist das ein sehr gutes Paket. Darin erstellen wir die ImageComparator- Klasse , für die wir zwei Tests schreiben.

Maven und das Projekt als Ganzes mit IDEA verbinden

Damit die Idee unsere Abhängigkeiten erkennen und anbieten kann, sie im Projekt zu nutzen, müssen wir mehrere Dinge tun:

1. Teilen Sie die Idee mit, wo die Codequellen sein werden und wo die Tests stattfinden werden.
2. Fügen Sie der Idee ein Maven-Projekt hinzu.

Um das erste zu erreichen, müssen Sie dieses Symbol finden: Klicken Sie darauf und gehen Sie zum Abschnitt „Module“ . Als nächstes müssen Sie den erstellten Ordnern die erforderliche Markierung geben, wie in der Abbildung unten gezeigt: Das heißt:

• • src/main/java – Quellen
• • src/main/resources – Ressourcen
• • src/test/java – Tests
• • src/test/resources – Testressourcen
• • Ziel – Ausgeschlossen

Alle diese Quellen, Ressourcen, Tests, Testressourcen und Ausgeschlossene finden Sie in der Zeile, in der „ Markieren als“ steht . Wählen Sie einen Ordner aus und beschriften Sie ihn entsprechend. Und der zweite Schritt besteht darin, das Maven-Projekt zu IDEA hinzuzufügen, damit es seine Wirkung entfalten kann. Dazu müssen Sie die Datei pom.xml in IDEA finden und mit der rechten Maustaste klicken, um „ Als Maven-Projekt hinzufügen“ auszuwählen . Und das war's, Sie werden glücklich sein (: Danach erscheint rechts eine Maven- Platte , die Sie öffnen und darin Maven-Befehle ausführen können.

Wir schreiben Quellen und Tests für unser „Projekt“

Also haben wir der Idee Maven hinzugefügt. Beschreiben wir nun die Klasse, die für uns als Quelle dienen wird:

Bildvergleicher:

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

Lassen Sie uns zu diesem Zweck Tests erstellen. Die Klasse, die testet, muss sich im selben Paket befinden, nur in src/test/java. Die Idee weiß das und Sie können ihre Möglichkeiten nutzen. Klicken Sie dazu auf den Klassennamen in der Datei selbst und wählen Sie in der angezeigten Glühbirne „Test erstellen“ aus: Wir werden aufgefordert, Einstellungen für den zukünftigen Test auszuwählen. Wir installieren nichts, klicken einfach auf „OK“: Für unseren Test führen wir einen Bildvergleich der Testbilder durch und legen sie in den Testressourcen (src/test/resource) ab. Danach werden wir zwei Tests schreiben. Man wird überprüfen, ob diese beiden Bilder unterschiedlich sind. Und im anderen Fall werden wir dasselbe Bild vermitteln und eine Antwort erwarten, dass sie gleich sind. Dann erhalten wir den folgenden 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);
   }
}

Die Tests sind sehr einfach, ich werde nicht weiter darauf eingehen. Wenn Sie interessiert sind, werde ich eines Tages einen Artikel über das Testen schreiben (schreiben Sie darüber in den Kommentaren).

Führen Sie Maven-Befehle aus

Wenn nun alles bereit ist, um die Arbeit der Teams zu sehen, wählen Sie unser Projekt im Maven-Plugin aus und öffnen Sie Lifecycle darin : Klicken Sie nun auf „Kompilieren“ und sehen Sie, was passiert ist: Daraus können wir zwei Schlussfolgerungen ziehen:

1. Unsere Quellen wurden zusammengestellt und im angegebenen Pfad abgelegt.
2. Der Befehl war erfolgreich – BUILD SUCCESS.

Und wirklich, wenn wir zur Projektstruktur gehen und uns ansehen, was sich dort geändert hat, werden wir sehen, dass der Zielordner hinzugefügt wurde , den wir noch durchsuchen und unsere kompilierte ImageComparator- Klasse finden können : Jetzt möchte ich ein neues Paket starten Befehl von Grund auf. Dazu führen wir den Clean- Befehl aus (zweimal klicken) : Als Ergebnis wird uns mitgeteilt, dass wir den Zielordner gelöscht haben , der alles enthielt, was nach dem Compile- Befehl erstellt wurde . Lassen Sie uns den Befehl test ausführen : Tests run: 0... aber wir haben bis zu ZWEI geschrieben. Das heißt, aus irgendeinem Grund wurden die Tests nicht ausgeführt. Live-Codierung ist so, gehen wir ins Internet) Nach 5 Minuten Googeln habe ich festgestellt, dass Sie mit JUnit5 ein weiteres Plugin hinzufügen müssen:

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

Fügen wir es dem Projekt hinzu, fügen wir die Version so gut es geht in <properties/> ein und starten wir den Test neu : Jetzt ist es eine andere Sache! Zwei Tests liefen und waren erfolgreich. Feuer! Jetzt führen wir unser Paket aus und erwarten, dass wir den Jarnik im Zielordner finden : Das heißt, wir sehen erneut, dass die Tests bestanden wurden, und danach (garantiert, dass alles im Projekt in Ordnung ist) können wir das Projekt in einem sammeln Archiv. Die Abbildung zeigt, dass es in den Maven-Startprotokollen und in der Projektstruktur ein Archiv gibt. Als nächstes müssen wir installieren . Tolles Team. Oh, bevor ich es vergesse. Es gilt als bewährte Vorgehensweise, das Projekt zu bereinigen, bevor ein neuer Befehl ausgeführt wird, indem clean ausgeführt wird . Dies erspart Ihnen in Zukunft Unsinn - das garantiere ich aus eigener Erfahrung))) Deshalb führen wir zuerst clean und dann install aus : Wo sich der Pfeil befindet, können Sie deutlich erkennen, wo sich das lokale Repository befindet. Basierend auf dem, was sie schreiben, ist dies auf meinem Weg: /Users/roman_beskrovnyi/.m2 Und das Archiv selbst wird sich hier befinden: /Users/roman_beskrovnyi/.m2/repository/com/github/javarushcommunity/maven-demo/1.0- SCHNAPPSCHUSS Und wenn wir zum Terminal gehen und versuchen, in den Ordner zu gelangen, in dem sich das Archiv befindet, dann wird es dort sein: „ Deploy“ wird uns nicht angezeigt, und die anderen brauchen Sie noch nicht …

Statt Ausgabe

Heute sind wir schnell durchgegangen, was Maven ist, was es gibt und welche Hauptbefehle es gibt. Ich habe versucht, dies einfach und anhand von Beispielen zu vermitteln. Der gesamte Quellcode für das Beispiel befindet sich in der JavaRush-Community-Organisation auf GitHub im maven-demo- Projekt . Schreiben Sie alle Fragen in die Kommentare. Wie üblich empfehle ich Ihnen, mein Konto auf Github zu abonnieren , um den neuen Code für unser JRTB-Projekt nicht zu verpassen. Wieder einmal ist er nicht tot. Er war einfach in Stasis))

Eine Liste aller Materialien der Serie finden Sie am Anfang dieses Artikels.