Wszystko, co chciałeś wiedzieć o Mavenie. (Część 2) - „Projekt Java od A do Z”

Wszystko o Mavenie: początek, który uwielbiam ćwiczyć. Nawet nie możesz sobie wyobrazić, jak nudne może być czasami pisanie o teorii. Niemniej jednak nie ma miejsca bez niej. Praktyka to oczywiście inna sprawa. Teraz szybko przejrzyjmy polecenia, które opisałem wcześniej i skończymy)

Konfigurowanie pliku pom.xml

Podczas gdy teoretyzowaliśmy, otrzymaliśmy całkiem niezły plik pom.xml:

Zobacz kod

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

- Ale żeby było co skompilować, trzeba to tam dodać! Logiczny? - Tak kapitanie. bgg Dlatego dodajmy klasę, która będzie miała metodę i dwa testy. Stwórzmy zwykły schemat folderów dla Mavena: W src/main/Java utworzymy pakiet, w którym będziemy pracować. Aby go poprawnie skomponować, dobrze byłoby na początku umieścić nazwę organizacji ( groupId ), a następnie nazwę projektu. W naszym przypadku będzie to wyglądało tak: com.github.javarushcommunity.mavendemo Jak dla mnie jest to bardzo dobry pakiet. Stworzymy w nim klasę ImageComparator , dla której napiszemy dwa testy.

Połączenie Mavena i całego projektu z IDEA

Aby pomysł mógł rozpoznać nasze zależności i zaproponować wykorzystanie ich w projekcie musimy zrobić kilka rzeczy:

1. Powiedz, gdzie będą źródła kodu i gdzie będą testy.
2. Dodaj projekt mav do pomysłu.

Aby osiągnąć pierwszy, musisz znaleźć tę ikonę: Kliknij na nią i przejdź do sekcji Moduły . Następnie musisz nadać utworzonym folderom wymagany znacznik, jak pokazano na poniższym rysunku: To znaczy:

• • src/main/Java - Źródła
• • src/main/resources - Zasoby
• • src/test/Java - Testy
• • src/test/resources - Zasoby testowe
• • cel – wykluczony

Wszystkie te Źródła, Zasoby, Test, Zasoby testowe i Wykluczone można znaleźć w wierszu, w którym napisano Oznacz jako . Wybierz folder i odpowiednio go oznacz. Drugim krokiem jest dodanie projektu maven do IDEA, aby mógł zadziałać. Aby to zrobić, musisz znaleźć plik pom.xml w IDEA i kliknąć prawym przyciskiem myszy, aby wybrać opcję Dodaj jako projekt Maven . I to wszystko, będziesz szczęśliwy (: Po tym, po prawej stronie pojawi się płytka Mavena , którą możesz otworzyć i uruchomić w niej polecenia Mavena.

Piszemy źródła i testy dla naszego „projektu”

Dodaliśmy więc do pomysłu Mavena, teraz opiszemy klasę, która będzie dla nas źródłem:

Komparator obrazu:

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

Stwórzmy w tym celu testy. Klasa testowana musi znajdować się w tym samym pakiecie, tylko w src/test/Java. Pomysł o tym wie i możesz skorzystać z jego możliwości. Aby to zrobić, kliknij nazwę klasy w samym pliku i wybierz opcję Utwórz test na wyświetlonej żarówce: Zostaniemy poproszeni o wybranie ustawień dla przyszłego testu. Niczego nie instalujemy, po prostu kliknij OK: Na potrzeby naszego testu porównamy obrazy testowe i umieścimy je w zasobach testowych (src/test/resource). Następnie napiszemy dwa testy. Sprawdzimy, czy te dwa zdjęcia są różne. A w drugim przekażemy ten sam obraz i oczekujemy odpowiedzi, że są takie same. Następnie otrzymujemy następujący 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);
   }
}

Testy są bardzo proste, nie będę się nad nimi rozwodzić. Jeśli jesteście zainteresowani, napiszę kiedyś artykuł o testowaniu (napiszcie o tym w komentarzach).

Wykonuj polecenia Mavena

Teraz gdy już wszystko będzie gotowe do zobaczenia pracy zespołów, wybierz nasz projekt we wtyczce Maven i otwórz w nim Lifecycle : Teraz kliknij Kompiluj i zobacz co się stało: Z tego możemy wyciągnąć dwa wnioski:

1. Nasze źródła zostały skompilowane i umieszczone w określonej ścieżce.
2. Polecenie powiodło się - BUDOWAĆ SUKCES.

I tak naprawdę, jeśli przejdziemy do struktury projektu i sprawdzimy, co się tam zmieniło, zobaczymy, że dodano folder docelowy , który nadal możemy eksplorować i znaleźć naszą skompilowaną klasę ImageComparator : Teraz chciałbym rozpocząć nowy pakiet polecenie od zera. Aby to zrobić, uruchommy (kliknij dwa razy) polecenie clean : W rezultacie zostaniemy poinformowani, że usunęliśmy folder docelowy , który zawierał wszystko, co zostało utworzone po poleceniu kompilacji . Uruchommy polecenie test : Testy działają: 0... ale napisaliśmy aż DWA. Oznacza to, że z jakiegoś powodu testy się nie odbyły. Tak wygląda kodowanie na żywo, przejdźmy do sieci) Po 5 minutach googlowania odkryłem, że w przypadku JUnit5 trzeba dodać jeszcze jedną wtyczkę:

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

Dodajmy to do projektu, umieśćmy wersję w <properties/> najlepiej jak potrafimy i zrestartujmy test : Teraz to inna sprawa! Przeprowadzono dwa testy, które zakończyły się sukcesem. Ogień! Teraz uruchamiamy nasz pakiet i oczekujemy, że znajdziemy jarnik w folderze docelowym : Oznacza to, że ponownie widzimy, że testy poszły pomyślnie, a następnie (gwarantuje, że wszystko w projekcie jest dobrze) możemy zebrać projekt do archiwum. Rysunek pokazuje, że w dziennikach uruchamiania Maven i strukturze projektu znajduje się archiwum. Następnie mamy instalację . Świetny zespół. Och, zanim zapomnę. Za dobrą praktykę uważa się oczyszczenie projektu przed wykonaniem nowego polecenia poprzez uruchomienie clean . To uratuje cię przed bzdurami w przyszłości - gwarantuję to z własnego doświadczenia))) Dlatego najpierw uruchamiamy czysto , a następnie instalujemy : Tam, gdzie znajduje się strzałka, możesz wyraźnie zobaczyć, gdzie znajduje się lokalne repozytorium. Bazując na tym co piszą, jest mi po drodze: /Users/roman_beskrovnyi/.m2 A samo archiwum będzie zlokalizowane tutaj: /Users/roman_beskrovnyi/.m2/repository/com/github/javarushcommunity/maven-demo/1.0- MIGAWKA A jeśli pójdziemy do terminala i spróbujemy dostać się do folderu, w którym znajduje się archiwum, to tam będzie: wdrożenie nie pokaże nam, a inne nie są jeszcze potrzebne…

Zamiast wyjścia

Dziś na szybko omówiliśmy czym jest Maven, co w nim jest, jakie są w nim główne polecenia. Starałem się to przekazać prosto i na przykładach. Cały kod źródłowy przykładu znajduje się w organizacji społeczności JavaRush na GitHubie w projekcie maven-demo . Napisz wszystkie pytania w komentarzach. Tradycyjnie proponuję subskrybować moje konto na Githubie, aby nie przegapić nowego kodu naszego projektu JRTB. Po raz kolejny nie umarł. Był po prostu w zastoju))

Lista wszystkich materiałów wchodzących w skład serii znajduje się na początku artykułu.