Kurs Java

Maven - Pierwsze kroki

Celem tego rozdziału jest stworzenie pierwszego projektu Maven, skonfigurowanie budowy tego projektu oraz uruchomienie tej budowy tak abyśmy na końcu otrzymali gotową do użycia paczkę.
Appa Notka. Jeśli nie masz jeszcze zainstalowanego Mavena, zalecamy rozpoczęcie nauki od rozdziału Maven - Instalacja, aby móc kontynuować z pozostałymi materiałami.
Spis treści (kliknij, aby przejść):

Stworzenie projektu w Eclipse

Eclipse to wciąż jedno z najpopularniejszych IDE do programowania w Javie. Stwórzmy projekt typu Maven używając tego narzędzia. W tym celu wykonamy trzy kroki:
Tworzenie projektu
Tworzenie projektu - kolejne kroki
1 - Otwieramy popup w Package Explorer i wybieramy opcje: New > Maven Project
2 - Dla ułatwienia zaznaczamy opcję "Create a simple project (skip archetype selection)"
3 - Definiujemy pola podobnie jak na zdjęciu. Pola te znajdą się w wygenerowanym pliku pom.xml w projekcie.
Na koniec klikamy w przycisk Finish i czekamy aż Eclipse stworzy projekt. Struktura projektu będzie zbliżona do tej, którą opisujemy w kolejnym punkcie.
Uwaga
Dokładne wyjaśnienie znaczenia pól z kroku nr 3 znajduje się niżej - w paragrafie "Typowy plik pom.xml".

Stworzenie projektu w IntelliJ

Stwórzmy teraz projekt typu Maven używając do tego IDE IntelliJ. W tym celu wykonamy następujące kroki:
Tworzenie projektu Maven w IntelliJ
Tworzenie projektu Maven w IntelliJ

Struktura projektu Maven

Przyjrzyjmy się teraz podstawowym cechom projektu typu Maven:
  • Konfiguracja projektu przetrzymywana jest głównym katalogu projektu w pliku xml o nazwie pom.xml.
  • Źródła (pliki *.java) są przechowywane w projekcie w ścieżce: src/main/java.
  • Pliki statyczne (na przykład *.html, *.properties) są przechowywane w projekcie w ścieżce: src/main/resources.

    Zwyczajowo tutaj przechowujemy źródła aplikacji, takie jak widoki w plikach *.html, pliki Javascript *.js (np. pliki AngularJS), konfiguracje w postaci plików *.properties, *.yaml, *.xml itp.
  • Testy (pliki Java z testami) są przechowywane w projekcie w ścieżce: src/test/java.
  • Pliki statyczne testów (na przykład pliki konfiguracyjne *.properties, *.yaml, *.xml itp) są przechowywane w projekcie w ścieżce: src/test/resources.
  • Jeśli używamy innych języków w projekcie to przechowujemy je analogicznie w ścieżkach: src/main/groovy, src/test/groovy.
  • Po kompilacji wynikowe pliki klas (pliki *.class) są umieszczane w katalogu target .
  • Zawartość katalogu target jest pakowana do archiwów (paczek) typu *.jar, *.war, *.ear itp., które są gotowe do wdrożenia na serwerze.
Tyle teorii. Tak to wygląda w praktyce:

Typowy plik pom.xml

Mamy więc stworzony projekt. Zobaczmy teraz co zawiera się w pliku konfiguracyjnym pom.xml:
  • Deklaracja przestrzeni nazw xml, w ramach której będziemy korzystać z tagów w pliku:
    <project xmlns="http://maven.apache.org/POM/4.0.0" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
  • Informacje o projekcie, w tym między innymi nazwa artefaktu oraz numer jego wersji (szczegóły w tabelce pod listingiem):
        <modelVersion>4.0.0</modelVersion>	
        <groupId>com.javappa</groupId>
        <artifactId>appaadmin</artifactId>
        <version>1.0.0</version>
        <name>AppaAdmin</name>
        <description>AppaAdmin</description>
    
    Nazwa taga Znaczenie
    modelVersion numer modelu zgodny z numerem w przestrzeni nazw
    groupId grupa projektowa - najczęściej odwrócona nazwa domeny firmy, dla której pracujemy,
    a jeśli to nasz prywatny projekt to możemy użyć innego formatu, np. <nazwisko>.<imie>
    artifactId nazwa identyfikująca artefakt - najczęściej nazwa naszego projektu
    version numer wersji naszego artefaktu - w najprostszej wersji jest to zbiór trzech cyfr rozdzielonych kropkami,
    natomiast w prawdziwym projekcie biznesowym do tego numeru doklejane są jeszcze postfixy
    oznaczające etap w jakim znajduje się kod projektu (np. SNAPSHOT, M1, RC1, RELEASE, Final)
    name nazwa identyfikująca artefakt - najczęściej nazwa naszego projektu napisana w eleganckiej formie
    - wyświetla się ona na konsoli podczas budowy projektu
    description opis artefaktu - krótki i zwięzły opis projektu - również wyświetla się na konsoli poczas budowy projektu
  • dependencies - zależności do innych artefaktów Mavena (najczęściej innych projektów w postaci paczek *.jar) lub bibliotek zewnętrznych:
    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.0</version>
        </dependency>
        ...
    </dependencies>
    
  • build - sekcja dodatkowych opcji uruchamianych podczas procesu budowy projektu (możemy tutaj na przykład dodać i skonfigurować wtyczki)
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            ...
        </plugins>		
    </build>
    
  • repositories - sekcja, w której możemy podać repozytoria zewnętrzne, na których Maven będzie szukał zewnętrznych artefaktów, z których korzysta projekt. Jest ona dosyć często pomijana, ze względu na to, że repozytoria częściej definiujemy globalnie dla wielu projektów poprzez plik z ustawieniami zewnętrznymi settings.xml.
    <repositories>
        <repository> 
            <id>repository.spring.release</id> 
            <name>Spring GA Repository</name> 
            <url>http://repo.spring.io/release</url> 
        </repository>
        ...
    </repositories>
    
A tak to wygląda w całości:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    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.javappa</groupId>
    <artifactId>appaadmin</artifactId>
    <version>1.0.0</version>
    <name>AppaAdmin</name>
    <description>AppaAdmin</description>
    
    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.0</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>		
    </build>
    
    <!-- Relatywnie rzadko używane w pliku pom (częściej repozytoria są przechowywane w pliku settings.xml), 
    ale warto znać taką możliwość, gdyż może się zdarzyć, że będzie ona stosowana w którymś z Waszych projektów. -->
    <repositories>
        <repository> 
            <id>repository.spring.release</id> 
            <name>Spring GA Repository</name> 
            <url>http://repo.spring.io/release</url> 
        </repository>
    </repositories>    

</project>
W sekcji build użyliśmy bardzo często używanej wtyczki (pluginu), której zadaniem jest wykonanie kompilacji zgodnie z podaną konfiguracją.

Uruchomienie za pomocą komendy mvn

Maven posiada klika predefiniowanych faz (phase), które mogą wykonać różne operacje na naszym projekcie. Uruchamiamy je tak:
mvn <NAZWA FAZY>
Najpopularniejszymi fazami są:
  • compile - kompiluje kod źródłowy oraz kopiuje zasoby do katalogu classes (w target)
  • package - tworzy paczkę typu *.jar, *.war itp. (w zależności od konfiguracji w pom.xml - domyślnie jest to *.jar)
  • install - instaluje wynikową paczkę w lokalnym repozytorium
  • clean - czyści katalog target wraz z wszystkim wygenerowanymi zasobami
  • deploy - instaluje paczkę w zewnętrznym repozytorium (poza naszą maszyną, na przykład w firmowym repozytorium)
Najczęściej używamy faz clean oraz install. Aby zbudować projekt wchodzimy do katalogu, w którym znajduje się pom.xml i odpalamy komendę mvn podając te dwie fazy:
mvn clean install
W rezultacie powinniśmy zobaczyć coś takiego jak na poniższym zdjęciu:
Sukces budowania projektu
W ten sposób udało się nam zrealizować plan stworzenia pierwszego artefaktu o nazwie: appaadmin-1.0.0.jar! Artefakt w postaci pliku jar jest dostępny w katalogu target, a także jest zainstalowany w naszym lokalnym repozytorium. Jego nazwa powstała ze złączenia artifactId, myślnika oraz version zdefiniowanych w pliku pom.xml.

Lokalne repozytorium Mavena

W rozdziale Maven - Instalacja wspomnieliśmy, że artefakty zbudowane za pomocą celu install są od razu instalowane w lokalnym repozytorium .m2\repository w katalogu domowym użytkownika. Teraz powiemy sobie nieco więcej.

Katalog .m2\repository przechowuje artefakty w specjalnej strukturze zbudowanej na podstawie groupId zarówno naszych projektów, jak i tych dociągniętych ze zdalnych repozytoriów (np. z intenetu albo sieci wewnętrznej). Tak więc, jeśli groupId naszego projektu spring-boot-materialy-praktyczne zdefiniowane jest jako com.javappa, to taką też zastaniemy strukturę katalogów. Dalej mamy nazwę artefaktu (spring-boot-materialy-praktyczne) oraz numer wersji (0.0.1-SNAPSHOT):
Java - Maven m2
Warto tu zwrócić uwagę na datę i czas stworzenia artefaktu. Przed wykonaniem komendy mvn clean install wyglądało to tak:
Kurs Javy - Maven m2
Natomiast po jej wykonaniu czas uległ zmianie:
Kurs Java - Maven m2
Przypominamy, że do zainstalowania artefaktu w repozytorium wystarczy uruchomienie komendy mvn install. Cel clean jedynie czyści przed buildem katalog target w projekcie.

Brak pliku pom.xml

Builda odpalamy w katalogu, gdzie trzymamy pom.xml. W przypadku, gdy uruchomimy komendę mavenową w katalogu bez tego pliku, otrzymamy poniższy komunikat. Warto więc zwracać uwagę na to, w jakim katalogu się znajdujemy w trakcie odpalania tej komendy.
Java - Maven błąd 1

Problem z wersją Javy

Może się zdarzyć, że wersja Javy, której używamy, nie jest zgodna z wersją wpisaną w pom.xml. Na przykład, jeśli korzystamy aktualnie z Javy 8, a w pom.xml mamy wpisaną wersję 11:
Java - Maven m2
wtedy podczas builda dostaniemy błąd podobny do tego:
Java - Maven m2
Spowodowane jest to tym, że próbujemy budować projekt Javą niższą niż ta określona w pom.xml. W takiej sytuacji albo zmieniamy wersję w pom.xml, albo instalujemy nowszą wersję Javy, tak aby obie były zgodne. Natomiast, jeśli mamy na komputerze kilka wersji Javy, możemy ustawić wersję, której tylko Maven ma używać. Możemy to ustawić w pliku mvn.bat albo mvn.cmd (w zależności od wersji) w katalogu bin Mavena - apache-maven-x.x.x\bin:
Kurs programowania w Javie - Mvn katalog
Kurs programowania w Javie - Mvn plik

Problem z celem clean

Kolejny często spotykany problem dotyczy celu clean. Chodzi o to, że podczas usuwania katalogu target, może pojawić się problem, jeśli ten katalog lub pliki w nim zawarte, są wykorzystywane przez jakiś proces. Na przykład może być tak, że w jednej z konsol cmd sami "przebywamy" właśnie w tym katalogu. W takiej i podobnych sytuacjach otrzymamy taki błąd:
Kurs Java - Maven m2
Czasem okazuje się, że sprawdziliśmy wszystko i nie możemy znaleźć tego, co tak naprawdę "trzyma" nasz katalog (blokuje przed usunięciem). Co wtedy? Restart komputera? :) Niekoniecznie. Możemy jeszcze ściągnąć program ProcessExplorer i tam wyszukać uchwyt do zblokowanego pliku lub katalogu. W ten sposób możemy go zamknąć:
Kurs Javy - Handle1


W ten sposób przedstawiliśmy trzy najczęściej spotykane problemy na początku pracy z Mavenem. Mamy nadzieję, że choć trochę ułatwiliśmy Wam życie i oszczędziliśmy nerwów :)
Mapa umiejętności programisty Java

Stale się rozwijamy, a więc bądź na bieżąco!
Na ten adres będziemy przesyłać informacje o ważniejszych aktualizacjach, a także o nowych materiałach pojawiających się na stronie.
Polub nas na Facebooku:
Nasi partnerzy: stackshare
Javappa to również profesjonalne usługi programistyczne oparte o technologie JAVA. Jeśli chesz nawiązać z nami kontakt w celu uzyskania doradztwa bądź stworzenia aplikacji webowej powinieneś poznać nasze doświadczenia.
Kliknij O nas .


Pozycjonowanie stron: Grupa TENSE