Maven - Szybki przewodnik

Co to jest Maven?

Maven to narzędzie do zarządzania projektami i zrozumienia, które zapewnia programistom pełną strukturę cyklu życia kompilacji. Zespół programistów może zautomatyzować infrastrukturę kompilacji projektu w prawie krótkim czasie, ponieważ Maven używa standardowego układu katalogów i domyślnego cyklu życia kompilacji.

W przypadku środowiska wielu zespołów programistycznych, Maven może w bardzo krótkim czasie ustawić sposób pracy zgodnie ze standardami. Ponieważ większość konfiguracji projektu jest prosta i wielokrotnego użytku, Maven ułatwia życie programistom podczas tworzenia raportów, kontroli, kompilowania i testowania konfiguracji automatyzacji.

Maven zapewnia programistom sposoby zarządzania następującymi -

Builds
Documentation
Reporting
Dependencies
SCMs
Releases
Distribution
Lista mailingowa

Podsumowując, Maven upraszcza i standaryzuje proces budowania projektu. Bezproblemowo obsługuje kompilację, dystrybucję, dokumentację, współpracę zespołową i inne zadania. Maven zwiększa możliwość ponownego użycia i zajmuje się większością zadań związanych z kompilacją.

Maven Evolution

Maven został pierwotnie zaprojektowany w celu uproszczenia procesów budowlanych w projekcie Jakarta Turbine. Było kilka projektów, a każdy projekt zawierał nieco inne pliki kompilacji ANT. Pliki JAR zostały sprawdzone w CVS.

Następnie powstała grupa Apache Maven które mogą razem budować wiele projektów, publikować informacje o projektach, wdrażać projekty, udostępniać pliki JAR w kilku projektach i pomagać we współpracy zespołów.

Cel

Podstawowym celem Mavena jest zapewnienie programistom:

Kompleksowy model projektów, który można ponownie wykorzystać, konserwować i łatwiej zrozumieć.
Wtyczki lub narzędzia, które współdziałają z tym deklaratywnym modelem.

Struktura i zawartość projektu Maven są zadeklarowane w pliku xml, pom.xml, zwanym Project Object Model (POM), który jest podstawową jednostką całego systemu Maven. W kolejnych rozdziałach szczegółowo wyjaśnimy POM.

Konwencja nad konfiguracją

Maven używa Convention nad Configuration, co oznacza, że programiści nie muszą samodzielnie tworzyć procesu kompilacji.

Programiści nie muszą wspominać o każdym szczególe konfiguracji. Maven zapewnia rozsądne domyślne zachowanie dla projektów. Kiedy tworzony jest projekt Maven, Maven tworzy domyślną strukturę projektu. Programista jest zobowiązany tylko do odpowiedniego umieszczenia plików i nie musi definiować żadnej konfiguracji w pom.xml.

Na przykład w poniższej tabeli przedstawiono wartości domyślne dla plików kodu źródłowego projektu, plików zasobów i innych konfiguracji. Zarozumiały,${basedir} oznacza lokalizację projektu -

Pozycja	Domyślna
kod źródłowy	$ {basedir} / src / main / java
Zasoby	$ {basedir} / src / main / resources
Testy	$ {basedir} / src / test
Zgodny kod bajtowy	$ {basedir} / target
dystrybuowalny JAR	$ {basedir} / target / classes

Aby zbudować projekt, Maven zapewnia programistom opcje wymieniania celów cyklu życia i zależności projektu (które opierają się na możliwościach wtyczki Maven i jej domyślnych konwencjach). Wiele zadań związanych z zarządzaniem projektami i kompilacją jest obsługiwanych przez wtyczki Maven.

Programiści mogą zbudować dowolny projekt Maven bez konieczności rozumienia, jak działają poszczególne wtyczki. Szczegółowo omówimy wtyczki Maven w dalszych rozdziałach.

Funkcje Mavena

Prosta konfiguracja projektu zgodna z najlepszymi praktykami.
Spójne wykorzystanie we wszystkich projektach.
Zarządzanie zależnościami, w tym automatyczna aktualizacja.
Duże i stale rosnące repozytorium bibliotek.
Rozszerzalny, z możliwością łatwego pisania wtyczek w Javie lub językach skryptowych.
Natychmiastowy dostęp do nowych funkcji przy niewielkiej lub żadnej dodatkowej konfiguracji.
Model-based builds - Maven jest w stanie zbudować dowolną liczbę projektów w predefiniowanych typach danych wyjściowych, takich jak jar, wojna, metadane.
Coherent site of project information - Korzystając z tych samych metadanych, co w procesie kompilacji, maven jest w stanie wygenerować stronę internetową i plik PDF, w tym pełną dokumentację.
Release management and distribution publication - Bez dodatkowej konfiguracji maven zintegruje się z Twoim systemem kontroli źródła, takim jak CVS, i będzie zarządzał wydaniem projektu.
Backward Compatibility- Możesz łatwo przenieść wiele modułów projektu do Maven 3 ze starszych wersji Maven. Może obsługiwać również starsze wersje.
Automatic parent versioning - Nie ma potrzeby określania rodzica w module podrzędnym w celu konserwacji.
Parallel builds- Analizuje wykres zależności projektu i umożliwia równoległe tworzenie modułów harmonogramu. Korzystając z tego, możesz osiągnąć poprawę wydajności o 20-50%.
Better Error and Integrity Reporting - Maven poprawił raportowanie błędów i zapewnia odsyłacz do strony wiki Maven, gdzie otrzymasz pełny opis błędu.

Maven jest narzędziem opartym na Javie, więc pierwszym wymaganiem jest zainstalowanie JDK na komputerze.

Wymagania systemowe

JDK	1.7 lub nowszy.
Pamięć	Brak minimalnych wymagań.
Miejsca na dysku	Brak minimalnych wymagań.
System operacyjny	Brak minimalnych wymagań.

Krok 1 - Zweryfikuj instalację Java na swoim komputerze

Otwórz konsolę i wykonaj następujące czynności java Komenda.

OS	Zadanie	Komenda
Windows	Otwórz konsolę poleceń	c: \> java -version
Linux	Otwórz terminal poleceń	$ java -version
Prochowiec	Otwórz terminal	maszyna: ~ joseph $ java -version

Sprawdźmy dane wyjściowe dla wszystkich systemów operacyjnych -

OS	Wynik
Windows	wersja java „1.7.0_60” Java (TM) SE Runtime Environment (kompilacja 1.7.0_60-b19) Java HotSpot (TM) 64-bitowa maszyna wirtualna serwera (wersja 24.60-b09, tryb mieszany)
Linux	wersja java „1.7.0_60” Java (TM) SE Runtime Environment (kompilacja 1.7.0_60-b19) Java HotSpot (TM) 64-bitowa maszyna wirtualna serwera (wersja 24.60-b09, tryb mieszany)
Prochowiec	wersja java „1.7.0_60” Java (TM) SE Runtime Environment (kompilacja 1.7.0_60-b19) Java HotSpot (TM) 64-bitowa maszyna wirtualna serwera (wersja 24.60-b09, tryb mieszany)

Jeśli nie masz zainstalowanej Java, zainstaluj pakiet Java Software Development Kit (SDK) z https://www.oracle.com/technetwork/java/javase/downloads/index.html. Zakładamy, że Java 1.7.0.60 jest zainstalowaną wersją tego samouczka.

Krok 2 - Ustaw środowisko JAVA

Ustaw JAVA_HOMEzmienna środowiskowa wskazująca lokalizację katalogu podstawowego, w którym na komputerze jest zainstalowana Java. Na przykład -

OS	Wynik
Windows	Ustaw zmienną środowiskową JAVA_HOME na C: \ Program Files \ Java \ jdk1.7.0_60
Linux	eksportuj JAVA_HOME = / usr / local / java-current
Prochowiec	eksportuj JAVA_HOME = / Library / Java / Home

Dołącz lokalizację kompilatora Java do ścieżki systemowej.

OS	Wynik
Windows	Dołącz ciąg „; C: \ Program Files \ Java \ jdk1.7.0.60 \ bin” na końcu zmiennej systemowej Path.
Linux	eksportuj PATH =$PATH:$JAVA_HOME / bin /
Prochowiec	nie wymagane

Sprawdź instalację oprogramowania Java przy użyciu java -version polecenie, jak wyjaśniono powyżej.

Krok 3 - Pobierz archiwum Maven

Pobierz Maven 2.2.1 z https://maven.apache.org/download.cgi.

OS	Nazwa archiwum
Windows	apache-maven-3.3.1-bin.zip
Linux	apache-maven-3.3.1-bin.tar.gz
Prochowiec	apache-maven-3.3.1-bin.tar.gz

Krok 4 - Rozpakuj archiwum Mavena

Wypakuj archiwum do katalogu, w którym chcesz zainstalować Maven 3.3.1. Z archiwum zostanie utworzony podkatalog apache-maven-3.3.1.

OS	Lokalizacja (może się różnić w zależności od instalacji)
Windows	C: \ Program Files \ Apache Software Foundation \ apache-maven-3.3.1
Linux	/ usr / local / apache-maven
Prochowiec	/ usr / local / apache-maven

Krok 5 - Ustaw zmienne środowiskowe Maven

Dodaj M2_HOME, M2, MAVEN_OPTS do zmiennych środowiskowych.

OS	Wynik
Windows	Ustaw zmienne środowiskowe za pomocą właściwości systemowych. M2_HOME = C: \ Program Files \ Apache Software Foundation \ apache-maven-3.3.1 M2 =% M2_HOME% \ bin MAVEN_OPTS = -Xms256m -Xmx512m
Linux	Otwórz terminal poleceń i ustaw zmienne środowiskowe. export M2_HOME = / usr / local / apache-maven / apache-maven-3.3.1 export M2 = $ M2_HOME / bin eksport MAVEN_OPTS = -Xms256m -Xmx512m
Prochowiec	Otwórz terminal poleceń i ustaw zmienne środowiskowe. export M2_HOME = / usr / local / apache-maven / apache-maven-3.3.1 eksport M2 = $ M2_HOME / bin eksport MAVEN_OPTS = -Xms256m -Xmx512m

Krok 6 - Dodaj lokalizację katalogu bin Maven do ścieżki systemowej

Teraz dołącz zmienną M2 do ścieżki systemowej.

OS	Wynik
Windows	Dołącz ciąg;% M2% na końcu zmiennej systemowej, Path.
Linux	eksportuj PATH =$M2:$ŚCIEŻKA
Prochowiec	eksportuj PATH =$M2:$ŚCIEŻKA

Krok 7 - Zweryfikuj instalację Mavena

Teraz otwórz konsolę i wykonaj następujące czynności mvn Komenda.

OS	Zadanie	Komenda
Windows	Otwórz konsolę poleceń	c: \> mvn --version
Linux	Otwórz terminal poleceń	$ mvn --version
Prochowiec	Otwórz terminal	maszyna: ~ joseph $ mvn --version

Na koniec sprawdź wyjście powyższych poleceń, które powinny wyglądać następująco -

OS	Wynik
Windows	Apache Maven 3.3.1 (r801777; 2009-08-07 00: 46: 01 + 0530) Wersja Java: 1.7.0_60 Strona główna Java: C: \ Program Files \ Java \ jdk1.7.0_60 \ jre
Linux	Apache Maven 3.3.1 (r801777; 2009-08-07 00: 46: 01 + 0530) Wersja Java: 1.7.0_60 Strona główna Java: C: \ Program Files \ Java \ jdk1.7.0_60 \ jre
Prochowiec	Apache Maven 3.3.1 (r801777; 2009-08-07 00: 46: 01 + 0530) Wersja Java: 1.7.0_60 Strona główna Java: C: \ Program Files \ Java \ jdk1.7.0_60 \ jre

POM oznacza Project Object Model. To podstawowa jednostka pracy w Maven. Jest to plik XML, który znajduje się w katalogu podstawowym projektu jako pom.xml.

POM zawiera informacje o projekcie i różne szczegóły konfiguracji używane przez Maven do tworzenia projektów.

POM zawiera również cele i wtyczki. Wykonując zadanie lub cel, Maven szuka POM w bieżącym katalogu. Odczytuje POM, pobiera potrzebne informacje konfiguracyjne, a następnie realizuje cel. Niektóre z konfiguracji, które można określić w POM, są następujące:

zależności projektu
plugins
goals
budować profile
wersja projektu
developers
Lista mailingowa

Przed utworzeniem POM należy najpierw zdecydować o projekcie group (groupId), jego name (artifactId) i jego wersja jako te atrybuty pomagają w unikalnej identyfikacji projektu w repozytorium.

Przykład POM

<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.companyname.project-group</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
</project>

Należy zauważyć, że dla każdego projektu powinien istnieć jeden plik POM.

Wszystkie pliki POM wymagają rozszerzenia project element i trzy obowiązkowe pola: groupId, artifactId, version.
Zapis projektów w repozytorium to groupId:artifactId:version.
Minimalne wymagania dla POM -

Sr.No.	Węzeł i opis
1	Project root To jest tag główny projektu. Musisz określić podstawowe ustawienia schematu, takie jak schemat Apache i specyfikacja w3.org.
2	Model version Wersja modelu powinna być 4.0.0.
3	groupId To jest identyfikator grupy projektu. Jest to na ogół unikalne w przypadku organizacji lub projektu. Na przykład grupa bankowa spółka.firma.bank ma wszystkie projekty związane z bankiem.
4	artifactId To jest identyfikator projektu. To jest ogólnie nazwa projektu. Na przykład bankowość konsumencka. Wraz z groupId, artifactId definiuje lokalizację artefaktu w repozytorium.
5	version To jest wersja projektu. Wraz z groupId jest używany w repozytorium artefaktu, aby oddzielić od siebie wersje. Na przykład - com.company.bank:consumer-banking:1.0 com.company.bank:consumer-banking:1.1.

Super POM

Super POM to domyślny POM Maven. Wszystkie POMs dziedziczą po rodzicu lub wartości domyślnej (pomimo wyraźnej definicji lub nie). Ten podstawowy POM jest znany jakoSuper POM, i zawiera wartości dziedziczone domyślnie.

Maven używa efektywnego POM (konfiguracja z super pom plus konfiguracja projektu) do realizacji odpowiedniego celu. Pomaga programistom określić minimalne szczegóły konfiguracji w jego / jej pom.xml. Chociaż konfiguracje można łatwo zastąpić.

Łatwym sposobem przyjrzenia się domyślnym konfiguracjom super POM jest uruchomienie następującego polecenia: mvn help:effective-pom

Stwórz plik pom.xml w dowolnym katalogu na swoim komputerze i skorzystaj z zawartości wspomnianego powyżej przykładu pom.

W poniższym przykładzie utworzyliśmy pom.xml w folderze C: \ MVN \ project.

Teraz otwórz konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvn Komenda.

C:\MVN\project>mvn help:effective-pom

Maven rozpocznie przetwarzanie i wyświetli efektywny-pom.

[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'help'.
[INFO] ------------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.project-group:project-name:jar:1.0
[INFO]    task-segment: [help:effective-pom] (aggregator-style)
[INFO] ------------------------------------------------------------------------
[INFO] [help:effective-pom {execution: default-cli}]
[INFO]

.....

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: < 1 second
[INFO] Finished at: Thu Jul 05 11:41:51 IST 2012
[INFO] Final Memory: 6M/15M
[INFO] ------------------------------------------------------------------------

Efektywny POM wyświetlany jako wynik w konsoli, po dziedziczeniu, interpolacja i profile są stosowane.

<?xml version="1.0" encoding="UTF-8"?>
<!-- ============================================== -->
<!-- -->
<!-- Generated by Maven Help Plugin on 2015-04-09T11:41:51 -->
<!-- See: http://maven.apache.org/plugins/maven-help-plugin/ -->
<!-- -->
<!-- ==============================================-->

<!-- ==============================================-->
<!-- -->
<!-- Effective POM for project -->
<!-- 'com.companyname.project-group:project-name:jar:1.0' -->
<!-- -->
<!-- ============================================== -->

<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.companyname.project-group</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <build>
      <sourceDirectory>C:\MVN\project\src\main\java</sourceDirectory>
      <scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>

      <testSourceDirectory>C:\MVN\project\src\test\java</testSourceDirectory>
      <outputDirectory>C:\MVN\project\target\classes</outputDirectory>
      <testOutputDirectory>C:\MVN\project\target\test-classes</testOutputDirectory>
      <resources>
         <resource>
            <mergeId>resource-0</mergeId>
            <directory>C:\MVN\project\src\main\resources</directory>
         </resource>
      </resources>
      <testResources>
         <testResource>
            <mergeId>resource-1</mergeId>
            <directory>C:\MVN\project\src\test\resources</directory>
         </testResource>
      </testResources>
      <directory>C:\MVN\project\target</directory>
      <finalName>project-1.0</finalName>
   
      <pluginManagement>
         <plugins>
            <plugin>
               <artifactId>maven-antrun-plugin</artifactId>
               <version>1.3</version>
            </plugin>
            <plugin>
               <artifactId>maven-assembly-plugin<  /artifactId>
               <version>2.2-beta-2</version>
            </plugin>
            <plugin>
               <artifactId>maven-clean-plugin<  /artifactId>
               <version>2.2</version>
            </plugin>
         
            <plugin>
               <artifactId>maven-compiler-plugin</artifactId>
               <version>2.0.2</version>
            </plugin>
            <plugin>
               <artifactId>maven-dependency-plugin</artifactId>     
               <version>2.0</version>
            </plugin>
            <plugin>
               <artifactId>maven-deploy-plugin</artifactId>
               <version>2.4</version>
            </plugin>
         
            <plugin>
               <artifactId>maven-ear-plugin</artifactId>
               <version>2.3.1</version>
            </plugin>
            <plugin>
               <artifactId>maven-ejb-plugin</artifactId>
               <version>2.1</version>
            </plugin>
            <plugin>
               <artifactId>maven-install-plugin</artifactId>
               <version>2.2</version>
            </plugin>
         
            <plugin>
               <artifactId>maven-jar-plugin</artifactId>
               <version>2.2</version>
            </plugin>
            <plugin>
               <artifactId>maven-javadoc-plugin</artifactId>
               <version>2.5</version>
            </plugin>
            <plugin>
               <artifactId>maven-plugin-plugin</artifactId>
               <version>2.4.3</version>
            </plugin>
         
            <plugin>
               <artifactId>maven-rar-plugin</artifactId>
               <version>2.2</version>
            </plugin>
            <plugin>
               <artifactId>maven-release-plugin</artifactId>
               <version>2.0-beta-8</version>
            </plugin>
            <plugin>
               <artifactId>maven-resources-plugin</artifactId>
               <version>2.3</version>
            </plugin>
         
            <plugin>
               <artifactId>maven-site-plugin</artifactId>
               <version>2.0-beta-7</version>
            </plugin>
            <plugin>
               <artifactId>maven-source-plugin</artifactId>
               <version>2.0.4</version>
            </plugin>
            <plugin>
               <artifactId>maven-surefire-plugin</artifactId>
               <version>2.4.3</version>
            </plugin>
            <plugin>
               <artifactId>maven-war-plugin</artifactId>
               <version>2.1-alpha-2</version>
            </plugin>
         </plugins>
      </pluginManagement>
   
      <plugins>
         <plugin>
            <artifactId>maven-help-plugin</artifactId>
            <version>2.1.1</version>
         </plugin>
      </plugins>
   </build>
   
   <repositories>
      <repository>
         <snapshots>
            <enabled>false</enabled>
         </snapshots>
         <id>central</id>
         <name>Maven Repository Switchboard</name>
         <url>http://repo1.maven.org/maven2</url>
      </repository>
   </repositories>
   <pluginRepositories>
      <pluginRepository>
         <releases>
            <updatePolicy>never</updatePolicy>
         </releases>
         <snapshots>
            <enabled>false</enabled>
         </snapshots>
         <id>central</id>
         <name>Maven Plugin Repository</name>
         <url>http://repo1.maven.org/maven2</url>
      </pluginRepository>
   </pluginRepositories>
   <reporting>
      <outputDirectory>C:\MVN\project\target/site</outputDirectory>
   </reporting>
</project>

W powyższym pom.xml możesz zobaczyć domyślną strukturę folderów źródłowych projektu, katalog wyjściowy, wymagane wtyczki, repozytoria, katalog raportowania, którego Maven będzie używał podczas wykonywania pożądanych celów.

Maven pom.xml również nie musi być napisany ręcznie. Maven udostępnia liczne wtyczki archetypowe do tworzenia projektów, które w kolejności tworzą strukturę projektu i pom.xml

Co to jest cykl życia kompilacji?

Cykl kompilacji to dobrze zdefiniowana sekwencja faz, które definiują kolejność, w jakiej cele mają być realizowane. Tutaj faza reprezentuje etap w cyklu życia. Na przykład typowy plikMaven Build Lifecycle składa się z następującej sekwencji faz.

Faza	Uchwyty	Opis
przygotowanie zasobów	kopiowanie zasobów	W tej fazie można dostosować kopiowanie zasobów.
uprawomocnić	Walidacja informacji	Sprawdza, czy projekt jest poprawny i czy wszystkie niezbędne informacje są dostępne.
skompilować	kompilacja	W tej fazie wykonywana jest kompilacja kodu źródłowego.
Test	Testowanie	Testuje skompilowany kod źródłowy odpowiedni do testowania frameworka.
pakiet	opakowanie	W tej fazie tworzony jest pakiet JAR / WAR, jak wspomniano na opakowaniu w POM.xml.
zainstalować	instalacja	Ta faza instaluje pakiet w lokalnym / zdalnym repozytorium maven.
Rozmieścić	Wdrażanie	Kopiuje ostateczny pakiet do zdalnego repozytorium.

Są zawsze pre i post fazy do zarejestrowania goals, który musi przebiegać przed lub po określonej fazie.

Kiedy Maven zaczyna budować projekt, przechodzi przez określoną sekwencję faz i wykonuje cele, które są rejestrowane w każdej fazie.

Maven ma następujące trzy standardowe cykle życia -

clean
domyślny (lub kompilacja)
site

ZA goalreprezentuje określone zadanie, które przyczynia się do tworzenia i zarządzania projektem. Może być ograniczona do zera lub większej liczby faz budowy. Cel, który nie jest powiązany z żadną fazą kompilacji, może zostać wykonany poza cyklem życia kompilacji przez bezpośrednie wywołanie.

Kolejność wykonywania zależy od kolejności, w jakiej są wywoływane cele i fazy tworzenia. Na przykład rozważ poniższe polecenie. Plikclean i package argumenty są fazami kompilacji, podczas gdy dependency:copy-dependencies jest celem.

mvn clean dependency:copy-dependencies package

Tutaj najpierw zostanie wykonana faza czyszczenia , a następniedependency:copy-dependencies goal, a na końcu zostanie wykonana faza pakietu .

Czysty cykl życia

Kiedy wykonujemy polecenie mvn post-clean , Maven wywołuje czysty cykl życia składający się z następujących faz.

pre-clean
clean
post-clean

Maven czysty cel (czysty: czysty) jest związany z czystej fazy cyklu życia w czystym. Jegoclean:cleangoalusuwa dane wyjściowe kompilacji, usuwając katalog kompilacji. Tak więc, gdy wykonuje się polecenie mvn clean , Maven usuwa katalog kompilacji.

Możemy dostosować to zachowanie, wymieniając cele w dowolnej z powyższych faz czystego cyklu życia.

W poniższym przykładzie dołączymy maven-antrun-plugin: run goal do faz przed czyszczeniem, czyszczenia i po czyszczeniu. Pozwoli nam to na powtórzenie wiadomości tekstowych wyświetlających fazy czystego cyklu życia.

Utworzyliśmy plik pom.xml w folderze C: \ MVN \ project.

<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.companyname.projectgroup</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-antrun-plugin</artifactId>
            <version>1.1</version>
            <executions>
               <execution>
                  <id>id.pre-clean</id>
                  <phase>pre-clean</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>pre-clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.clean</id>
                  <phase>clean</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.post-clean</id>
                  <phase>post-clean</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>post-clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Teraz otwórz konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvn Komenda.

C:\MVN\project>mvn post-clean

Maven rozpocznie przetwarzanie i wyświetlanie wszystkich faz czystego cyklu życia.

[INFO] Scanning for projects...
[INFO] -----------------------------------------------------------------
-
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [post-clean]
[INFO] ------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-clean}]
[INFO] Executing tasks
[echo] pre-clean phase
[INFO] Executed tasks
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
[echo] clean phase
[INFO] Executed tasks
[INFO] [antrun:run {execution: id.post-clean}]
[INFO] Executing tasks
[echo] post-clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: > 1 second
[INFO] Finished at: Sat Jul 07 13:38:59 IST 2012
[INFO] Final Memory: 4M/44M
[INFO] ------------------------------------------------------------------

Możesz spróbować dostroić mvn clean polecenie, które wyświetli pre-cleani czysty. Za nic nie zostanie straconepost-clean faza.

Domyślny (lub kompilacja) cykl życia

To jest podstawowy cykl życia Mavena i jest używany do tworzenia aplikacji. Ma następujące 21 faz.

Sr.No.	Faza cyklu życia i opis
1	validate Sprawdza, czy projekt jest poprawny i czy dostępne są wszystkie informacje niezbędne do ukończenia procesu kompilacji.
2	initialize Inicjuje stan kompilacji, na przykład właściwości zestawu.
3	generate-sources Wygeneruj dowolny kod źródłowy, który zostanie uwzględniony w fazie kompilacji.
4	process-sources Przetwórz kod źródłowy, na przykład filtruj dowolną wartość.
5	generate-resources Wygeneruj zasoby, które zostaną uwzględnione w pakiecie.
6	process-resources Skopiuj i przetwórz zasoby do katalogu docelowego, gotowe do fazy pakowania.
7	compile Skompiluj kod źródłowy projektu.
8	process-classes Przetwarzaj końcowe pliki z kompilacji, na przykład w celu ulepszenia / optymalizacji kodu bajtowego w klasach Java.
9	generate-test-sources Wygeneruj dowolny testowy kod źródłowy, który zostanie uwzględniony w fazie kompilacji.
10	process-test-sources Przetwórz kod źródłowy testu, na przykład filtruj dowolne wartości.
11	test-compile Skompiluj kod źródłowy testu do katalogu docelowego testu.
12	process-test-classes Przetwarzaj wygenerowane pliki z kompilacji pliku kodu testowego.
13	test Uruchom testy przy użyciu odpowiedniego środowiska do testów jednostkowych (jednym z nich jest Junit).
14	prepare-package Wykonaj wszelkie czynności niezbędne do przygotowania paczki przed faktycznym zapakowaniem.
15	package Weź skompilowany kod i spakuj go w formacie przeznaczonym do dystrybucji, takim jak plik JAR, WAR lub EAR.
16	pre-integration-test Wykonaj czynności wymagane przed wykonaniem testów integracyjnych. Na przykład skonfigurowanie wymaganego środowiska.
17	integration-test Przetwórz i w razie potrzeby wdróż pakiet w środowisku, w którym można uruchomić testy integracji.
18	post-integration-test Wykonaj czynności wymagane po wykonaniu testów integracyjnych. Na przykład sprzątanie środowiska.
19	verify Przeprowadź wszelkie kontrole, aby sprawdzić, czy pakiet jest ważny i spełnia kryteria jakości.
20	install Zainstaluj pakiet w lokalnym repozytorium, które może być używane lokalnie jako zależność w innych projektach.
21	deploy Kopiuje ostateczny pakiet do zdalnego repozytorium w celu udostępnienia innym programistom i projektom.

Istnieje kilka ważnych pojęć związanych z Maven Lifecycles, o których warto wspomnieć -

Na przykład, gdy faza jest wywoływana komendą Mavena mvn compile, będą wykonywane tylko fazy do tej fazy włącznie.
Różne cele mavena będą powiązane z różnymi fazami cyklu życia Mavena w zależności od rodzaju opakowania (JAR / WAR / EAR).

W poniższym przykładzie dołączymy maven-antrun-plugin: run goal do kilku faz cyklu życia kompilacji. Umożliwi nam to echo wiadomości tekstowych wyświetlających fazy cyklu życia.

Zaktualizowaliśmy pom.xml w folderze C: \ MVN \ project.

<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.companyname.projectgroup</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-antrun-plugin</artifactId>
            <version>1.1</version>
            <executions>
               <execution>
                  <id>id.validate</id>
                  <phase>validate</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>validate phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.compile</id>
                  <phase>compile</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>compile phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.test</id>
                  <phase>test</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>test phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.package</id>
                  <phase>package</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>package phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.deploy</id>
                  <phase>deploy</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>deploy phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Teraz otwórz konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvn Komenda.

C:\MVN\project>mvn compile

Maven rozpocznie przetwarzanie i wyświetlanie faz cyklu życia kompilacji, aż do fazy kompilacji.

[INFO] Scanning for projects...
[INFO] -----------------------------------------------------------------
-
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [compile]
[INFO] -----------------------------------------------------------------
-
[INFO] [antrun:run {execution: id.validate}]
[INFO] Executing tasks
[echo] validate phase
[INFO] Executed tasks
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered
resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory
C:\MVN\project\src\main\resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Nothing to compile - all classes are up to date
[INFO] [antrun:run {execution: id.compile}]
[INFO] Executing tasks
[echo] compile phase
[INFO] Executed tasks
[INFO] -----------------------------------------------------------------
-
[INFO] BUILD SUCCESSFUL
[INFO] -----------------------------------------------------------------
-
[INFO] Total time: 2 seconds
[INFO] Finished at: Sat Jul 07 20:18:25 IST 2012
[INFO] Final Memory: 7M/64M
[INFO] -----------------------------------------------------------------
-

Cykl życia witryny

Wtyczka Maven Site jest zwykle używana do tworzenia nowej dokumentacji w celu tworzenia raportów, wdrażania witryny itp. Ma następujące fazy -

pre-site
site
post-site
site-deploy

W poniższym przykładzie załączymy maven-antrun-plugin:runcel do wszystkich faz cyklu życia Witryny. Umożliwi nam to echo wiadomości tekstowych wyświetlających fazy cyklu życia.

Zaktualizowaliśmy pom.xml w folderze C: \ MVN \ project.

<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.companyname.projectgroup</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-antrun-plugin</artifactId>
            <version>1.1</version>
            <executions>
               <execution>
                  <id>id.pre-site</id>
                  <phase>pre-site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>pre-site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.site</id>
                  <phase>site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.post-site</id>
                  <phase>post-site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>post-site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.site-deploy</id>
                  <phase>site-deploy</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>site-deploy phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Teraz otwórz konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvn Komenda.

C:\MVN\project>mvn site

Maven rozpocznie przetwarzanie i wyświetlanie faz cyklu życia witryny, aż do fazy witryny.

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [site]
[INFO] ------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-site}]
[INFO] Executing tasks
[echo] pre-site phase
[INFO] Executed tasks
[INFO] [site:site {execution: default-site}]

[INFO] Generating "About" report.
[INFO] Generating "Issue Tracking" report.
[INFO] Generating "Project Team" report.
[INFO] Generating "Dependencies" report.
[INFO] Generating "Project Plugins" report.
[INFO] Generating "Continuous Integration" report.
[INFO] Generating "Source Repository" report.
[INFO] Generating "Project License" report.
[INFO] Generating "Mailing Lists" report.
[INFO] Generating "Plugin Management" report.
[INFO] Generating "Project Summary" report.

[INFO] [antrun:run {execution: id.site}]
[INFO] Executing tasks
[echo] site phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Sat Jul 07 15:25:10 IST 2012
[INFO] Final Memory: 24M/149M
[INFO] ------------------------------------------------------------------

Co to jest profil kompilacji?

Profil kompilacji to zestaw wartości konfiguracyjnych, których można użyć do ustawienia lub zastąpienia domyślnych wartości kompilacji Maven. Korzystając z profilu kompilacji, można dostosować kompilację do różnych środowisk, takich jak środowiska produkcyjne v / s programistyczne.

Profile są określane w pliku pom.xml za pomocą elementów activeProfiles / profiles i są wyzwalane na różne sposoby. Profile modyfikują POM w czasie kompilacji i są używane do nadawania parametrom różnych środowisk docelowych (na przykład ścieżki serwera bazy danych w środowiskach programistycznych, testowych i produkcyjnych).

Rodzaje profili kompilacji

Profile kompilacji dzielą się głównie na trzy typy.

Rodzaj	Gdzie to jest zdefiniowane
Na projekt	Zdefiniowany w pliku POM projektu, pom.xml
Na użytkownika	Zdefiniowane w pliku xml ustawień Maven (% USER_HOME% /. M2 / settings.xml)
Światowy	Zdefiniowane w pliku xml globalnych ustawień Maven (% M2_HOME% / conf / settings.xml)

Aktywacja profilu

Profil budowania Mavena można aktywować na różne sposoby.

Jawnie przy użyciu danych wejściowych konsoli poleceń.
Poprzez ustawienia maven.
Na podstawie zmiennych środowiskowych (zmienne użytkownika / systemu).
Ustawienia systemu operacyjnego (na przykład rodzina Windows).
Obecne / brakujące pliki.

Przykłady aktywacji profilu

Załóżmy następującą strukturę katalogów Twojego projektu -

Teraz pod src/main/resourcesistnieją trzy pliki specyficzne dla środowiska -

Sr.No.	Nazwa i opis pliku
1	env.properties domyślna konfiguracja używana, jeśli nie wymieniono żadnego profilu.
2	env.test.properties konfiguracja testowa, gdy używany jest profil testowy.
3	env.prod.properties konfiguracja produkcji, gdy używany jest profil produkcyjny.

Jawna aktywacja profilu

W poniższym przykładzie dołączymy maven-antrun-plugin: run goal, aby przetestować fazę. Umożliwi nam to echo wiadomości tekstowych dla różnych profili. Będziemy używać pom.xml do definiowania różnych profili i aktywujemy profil w konsoli poleceń za pomocą polecenia maven.

Załóżmy, że utworzyliśmy następujący plik pom.xml w folderze C: \ MVN \ project.

<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.companyname.projectgroup</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <profiles>
      <profile>
         <id>test</id>
         <build>
            <plugins>
               <plugin>
                  <groupId>org.apache.maven.plugins</groupId>
                  <artifactId>maven-antrun-plugin</artifactId>
                  <version>1.1</version>
                  <executions>
                     <execution>
                        <phase>test</phase>
                        <goals>
                           <goal>run</goal>
                        </goals>
                        <configuration>
                           <tasks>
                              <echo>Using env.test.properties</echo>
                              <copy file="src/main/resources/env.test.properties"
                                 tofile="${project.build.outputDirectory}
                                 /env.properties"/>
                           </tasks>
                        </configuration>
                     </execution>
                  </executions>
               </plugin>
            </plugins>
         </build>
      </profile>
   </profiles>
</project>

Teraz otwórz konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvnKomenda. Przekaż nazwę profilu jako argument za pomocą opcji -P.

C:\MVN\project>mvn test -Ptest

Maven rozpocznie przetwarzanie i wyświetlanie wyników profilu kompilacji testowej.

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [test]
[INFO] ------------------------------------------------------------------
[INFO] [resources:resources {execution: default-resources}]

[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!

[INFO] Copying 3 resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Nothing to compile - all classes are up to date
[INFO] [resources:testResources {execution: default-testResources}]

[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!

[INFO] skip non existing resourceDirectory C:\MVN\project\src\test\resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] Nothing to compile - all classes are up to date
[INFO] [surefire:test {execution: default-test}]
[INFO] Surefire report directory: C:\MVN\project\target\surefire-reports

-------------------------------------------------------
T E S T S
-------------------------------------------------------

There are no tests to run.
Results :
Tests run: 0, Failures: 0, Errors: 0, Skipped: 0
[INFO] [antrun:run {execution: default}]
[INFO] Executing tasks
[echo] Using env.test.properties
[INFO] Executed tasks

[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------

[INFO] Total time: 1 second
[INFO] Finished at: Sun Jul 08 14:55:41 IST 2012
[INFO] Final Memory: 8M/64M
[INFO] ------------------------------------------------------------------

Teraz jako ćwiczenie możesz wykonać następujące kroki -

Dodaj kolejny element profilu do elementu profiles w pom.xml (skopiuj istniejący element profilu i wklej go tam, gdzie kończą się elementy profilu).
Zaktualizuj identyfikator tego elementu profilu z test do normalnego.
Zaktualizuj sekcję zadań, aby wyświetlić echo env.properties i skopiuj env.properties do katalogu docelowego.
Ponownie powtórz powyższe trzy kroki, zaktualizuj identyfikator do sekcji produktu i zadań dla env.prod.properties.
To wszystko. Teraz masz gotowe trzy profile kompilacji (normalne / testowe / produkcyjne).

Teraz otwórz konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvnpolecenia. Przekaż nazwy profili jako argumenty za pomocą opcji -P.

C:\MVN\project>mvn test -Pnormal

C:\MVN\project>mvn test -Pprod

Sprawdź dane wyjściowe kompilacji, aby zobaczyć różnicę.

Aktywacja profilu poprzez ustawienia Mavena

Otwórz Maven settings.xml plik dostępny w katalogu% USER_HOME% /. m2 gdzie %USER_HOME%reprezentuje katalog osobisty użytkownika. Jeśli nie ma pliku settings.xml, utwórz nowy.

Dodaj profil testowy jako aktywny profil przy użyciu węzła aktywnych profili, jak pokazano poniżej w przykładzie.

<settings 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/settings-1.0.0.xsd">
   <mirrors>
      <mirror>
         <id>maven.dev.snaponglobal.com</id>
         <name>Internal Artifactory Maven repository</name>
         <url>http://repo1.maven.org/maven2/</url>
         <mirrorOf>*</mirrorOf>
      </mirror>
   </mirrors>
   <activeProfiles>
      <activeProfile>test</activeProfile>
   </activeProfiles>
</settings>

Teraz otwórz konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvnKomenda. Nie przekazuj nazwy profilu za pomocą opcji -P. Maven wyświetli wynik badania profilu będącego profilem aktywnym.

C:\MVN\project>mvn test

Aktywacja profilu za pomocą zmiennych środowiskowych

Teraz usuń aktywny profil z maven settings.xml i zaktualizuj profil testowy wymieniony w pom.xml. Dodaj element aktywacyjny do elementu profilu, jak pokazano poniżej.

Profil testowy zostanie wyzwolony, gdy właściwość systemowa „env” zostanie określona wartością „test”. Utwórz zmienną środowiskową „env” i ustaw jej wartość jako „test”.

<profile>
   <id>test</id>
   <activation>
      <property>
         <name>env</name>
         <value>test</value>
      </property>
   </activation>
</profile>

Otwórzmy konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvn Komenda.

C:\MVN\project>mvn test

Aktywacja profilu za pośrednictwem systemu operacyjnego

Element aktywacyjny zawierający szczegóły systemu operacyjnego, jak pokazano poniżej. Ten profil testowy zostanie uruchomiony, gdy systemem jest Windows XP.

<profile>
   <id>test</id>
   <activation>
      <os>
         <name>Windows XP</name>
         <family>Windows</family>
         <arch>x86</arch>
         <version>5.1.2600</version>
      </os>
   </activation>
</profile>

Teraz otwórz konsolę poleceń, przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvnpolecenia. Nie przekazuj nazwy profilu za pomocą opcji -P. Maven wyświetli wynik badania profilu będącego profilem aktywnym.

C:\MVN\project>mvn test

Aktywacja profilu poprzez obecny / brakujący plik

Teraz element aktywacyjny zawierający szczegóły systemu operacyjnego, jak pokazano poniżej. Profil testowy zostanie uruchomiony, kiedytarget/generated-sources/axistools/wsdl2java/com/companyname/group brakuje.

<profile>
   <id>test</id>
   <activation>
      <file>
         <missing>target/generated-sources/axistools/wsdl2java/
           com/companyname/group</missing>
      </file>
   </activation>
</profile>

C:\MVN\project>mvn test

Co to jest repozytorium Maven?

W terminologii Maven repozytorium to katalog, w którym wszystkie pliki JAR projektu, pliki jar biblioteki, wtyczki lub inne artefakty specyficzne dla projektu są przechowywane i mogą być łatwo używane przez Maven.

Istnieją trzy typy repozytoriów Maven. Poniższa ilustracja daje wyobrażenie o tych trzech typach.

local
central
remote

Repozytorium lokalne

Repozytorium lokalne Maven to lokalizacja folderu na twoim komputerze. Jest tworzony po pierwszym uruchomieniu dowolnego polecenia maven.

Lokalne repozytorium Maven przechowuje wszystkie zależności projektu (pliki słoików bibliotek, pliki słoików wtyczek itp.). Po uruchomieniu kompilacji Mavena Maven automatycznie pobiera wszystkie pliki JAR zależności do lokalnego repozytorium. Pomaga to uniknąć odniesień do zależności przechowywanych na komputerze zdalnym za każdym razem, gdy budowany jest projekt.

Lokalne repozytorium Mavena jest domyślnie tworzone przez Mavena w katalogu% USER_HOME%. Aby zastąpić domyślną lokalizację, podaj inną ścieżkę w pliku Maven settings.xml dostępnym w katalogu% M2_HOME% \ conf.

<settings xmlns = "http://maven.apache.org/SETTINGS/1.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/SETTINGS/1.0.0 
   http://maven.apache.org/xsd/settings-1.0.0.xsd">
   <localRepository>C:/MyLocalRepository</localRepository>
</settings>

Po uruchomieniu polecenia Maven, Maven pobierze zależności do ścieżki niestandardowej.

Centralne repozytorium

Centralne repozytorium Maven to repozytorium dostarczane przez społeczność Maven. Zawiera dużą liczbę powszechnie używanych bibliotek.

Gdy Maven nie znajdzie żadnej zależności w repozytorium lokalnym, rozpoczyna wyszukiwanie w repozytorium centralnym przy użyciu następującego adresu URL - https://repo1.maven.org/maven2/

Kluczowe koncepcje centralnego repozytorium są następujące -

To repozytorium jest zarządzane przez społeczność Maven.
Konfiguracja nie jest wymagana.
Wymaga dostępu do internetu.

Aby przeglądać zawartość centralnego repozytorium maven, społeczność maven podała adres URL - https://search.maven.org/#browse. Korzystając z tej biblioteki, programista może przeszukiwać wszystkie dostępne biblioteki w centralnym repozytorium.

Zdalne repozytorium

Czasami Maven nie znajduje również wspomnianej zależności w centralnym repozytorium. Następnie zatrzymuje proces kompilacji i wysyła komunikat o błędzie do konsoli. Aby zapobiec takiej sytuacji, Maven zapewnia koncepcjęRemote Repository, które jest własnym repozytorium dewelopera zawierającym wymagane biblioteki lub inne pliki JAR projektu.

Na przykład, korzystając ze wspomnianego poniżej POM.xml, Maven pobierze zależność (niedostępną w centralnym repozytorium) ze zdalnych repozytoriów wymienionych w tym samym pom.xml.

<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.companyname.projectgroup</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <dependencies>
      <dependency>
         <groupId>com.companyname.common-lib</groupId>
         <artifactId>common-lib</artifactId>
         <version>1.0.0</version>
      </dependency>
   <dependencies>
   <repositories>
      <repository>
         <id>companyname.lib1</id>
         <url>http://download.companyname.org/maven2/lib1</url>
      </repository>
      <repository>
         <id>companyname.lib2</id>
         <url>http://download.companyname.org/maven2/lib2</url>
      </repository>
   </repositories>
</project>

Sekwencja wyszukiwania zależności Mavena

Kiedy wykonujemy polecenia kompilacji Mavena, Maven zaczyna szukać bibliotek zależności w następującej kolejności -

Step 1 - Zależność wyszukiwania w repozytorium lokalnym, jeśli nie zostanie znaleziona, przejdź do kroku 2, w przeciwnym razie wykonaj dalsze przetwarzanie.
Step 2 - Zależność wyszukiwania w centralnym repozytorium, jeśli nie zostanie znaleziona, a zdalne repozytorium / repozytoria jest / są wymienione, przejdź do kroku 4. W przeciwnym razie jest pobierany do lokalnego repozytorium do wykorzystania w przyszłości.
Step 3 - Jeśli nie wspomniano o zdalnym repozytorium, Maven po prostu przerywa przetwarzanie i zgłasza błąd (Nie można znaleźć zależności).
Step 4- Zależność wyszukiwania w zdalnym repozytorium lub repozytoriach, jeśli zostanie znaleziona, jest pobierana do repozytorium lokalnego w celu wykorzystania w przyszłości. W przeciwnym razie Maven zatrzymuje przetwarzanie i zgłasza błąd (nie można znaleźć zależności).

Czym są wtyczki Maven?

Maven to właściwie framework do wykonywania wtyczek, w którym każde zadanie jest faktycznie wykonywane przez wtyczki. Wtyczki Maven są zwykle używane do -

utwórz plik jar
utwórz plik wojenny
kompilować pliki kodu
jednostkowe testowanie kodu
stworzyć dokumentację projektową
tworzyć raporty projektów

Wtyczka generalnie zapewnia zestaw celów, które można wykonać przy użyciu następującej składni -

mvn [plugin-name]:[goal-name]

Na przykład projekt Java można skompilować z celem kompilacji maven-compiler-plugin, uruchamiając następujące polecenie.

mvn compiler:compile

Typy wtyczek

Maven dostarczył następujące dwa typy wtyczek -

Sr.No.	Typ i opis
1	Build plugins Są one wykonywane podczas procesu kompilacji i należy je skonfigurować w elemencie <build /> pliku pom.xml.
2	Reporting plugins Wykonują się one podczas procesu generowania strony i należy je skonfigurować w elemencie <reportaż /> pliku pom.xml.

Poniżej znajduje się lista kilku popularnych wtyczek -

Sr.No.	Wtyczka i opis
1	clean Oczyszcza cel po kompilacji. Usuwa katalog docelowy.
2	compiler Kompiluje pliki źródłowe Java.
3	surefire Uruchamia testy jednostkowe JUnit. Tworzy raporty z testów.
4	jar Tworzy plik JAR z bieżącego projektu.
5	war Tworzy plik WAR na podstawie bieżącego projektu.
6	javadoc Generuje Javadoc dla projektu.
7	antrun Uruchamia zestaw zadań Ant z dowolnej wspomnianej fazy kompilacji.

Example

Użyliśmy maven-antrun-pluginobszernie w naszych przykładach, aby wydrukować dane na konsoli. Zobacz rozdział Profile budowania. Zrozummy to lepiej i stwórzmy pom.xml w folderze C: \ MVN \ project.

<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.companyname.projectgroup</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-antrun-plugin</artifactId>
            <version>1.1</version>
            <executions>
               <execution>
                  <id>id.clean</id>
                  <phase>clean</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>     
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Następnie otwórz konsolę poleceń i przejdź do folderu zawierającego pom.xml i wykonaj następujące czynności mvn Komenda.

C:\MVN\project>mvn clean

Maven rozpocznie przetwarzanie i wyświetlanie czystej fazy cyklu czystego życia.

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO]    task-segment: [post-clean]
[INFO] ------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
     [echo] clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: < 1 second
[INFO] Finished at: Sat Jul 07 13:38:59 IST 2012
[INFO] Final Memory: 4M/44M
[INFO] ------------------------------------------------------------------

Powyższy przykład ilustruje następujące kluczowe pojęcia -

Wtyczki są określone w pom.xml za pomocą elementu plugins.
Każda wtyczka może mieć wiele celów.
Możesz zdefiniować fazę, od której wtyczka powinna rozpocząć przetwarzanie za pomocą elementu fazy. Użyliśmyclean faza.
Możesz skonfigurować zadania do wykonania, wiążąc je z celami wtyczki. Związaliśmy sięecho zadanie z runcel maven-antrun-plugin .
Maven pobierze następnie wtyczkę, jeśli nie jest dostępna w lokalnym repozytorium i rozpocznie jej przetwarzanie.

Maven używa archetypewtyczki do tworzenia projektów. Aby stworzyć prostą aplikację java, użyjemy wtyczki maven-archetype-quickstart. W poniższym przykładzie utworzymy projekt aplikacji Java oparty na maven w folderze C: \ MVN.

Otwórzmy konsolę poleceń, przejdź do katalogu C: \ MVN i wykonaj następujące czynności mvn Komenda.

C:\MVN>mvn archetype:generate
-DgroupId = com.companyname.bank 
-DartifactId = consumerBanking 
-DarchetypeArtifactId = maven-archetype-quickstart 
-DinteractiveMode = false

Maven rozpocznie przetwarzanie i utworzy pełną strukturę projektu aplikacji Java.

[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] -------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO] task-segment: [archetype:generate] (aggregator-style)
[INFO] -------------------------------------------------------------------
[INFO] Preparing archetype:generate
[INFO] No goals needed for project - skipping
[INFO] [archetype:generate {execution: default-cli}]
[INFO] Generating project in Batch mode
[INFO] -------------------------------------------------------------------
[INFO] Using following parameters for creating project
from Old (1.x) Archetype: maven-archetype-quickstart:1.0
[INFO] -------------------------------------------------------------------

[INFO] Parameter: groupId, Value: com.companyname.bank
[INFO] Parameter: packageName, Value: com.companyname.bank
[INFO] Parameter: package, Value: com.companyname.bank
[INFO] Parameter: artifactId, Value: consumerBanking
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT

[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\consumerBanking
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: 14 seconds
[INFO] Finished at: Tue Jul 10 15:38:58 IST 2012
[INFO] Final Memory: 21M/124M
[INFO] ------------------------------------------------------------------

Teraz przejdź do katalogu C: / MVN. Zobaczysz utworzony projekt aplikacji Java o nazwie Consumer Banking (zgodnie z artifactId). Maven używa standardowego układu katalogów, jak pokazano poniżej -

Korzystając z powyższego przykładu, możemy zrozumieć następujące kluczowe pojęcia -

Sr.No.	Struktura i opis folderów
1	consumerBanking zawiera folder src i pom.xml
2	src/main/java zawiera pliki kodu java w strukturze pakietu (com / nazwa firmy / bank).
3	src/main/test zawiera testowe pliki kodu java w strukturze pakietu (com / nazwa firmy / bank).
4	src/main/resources zawiera obrazy / pliki właściwości (w powyższym przykładzie musimy utworzyć tę strukturę ręcznie).

Jeśli zauważysz, zauważysz, że Maven utworzył również przykładowy plik źródłowy Java i plik testowy Java. Otwórz folder C: \ MVN \ consumerBanking \ src \ main \ java \ com \ nazwa_firmy \ bank, zobaczysz plik App.java.

package com.companyname.bank;

/**
 * Hello world!
 *
 */
public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Otwórz folder C: \ MVN \ consumerBanking \ src \ test \ java \ com \ companyname \ bank, aby wyświetlić plik AppTest.java.

package com.companyname.bank;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * Unit test for simple App.
 */
public class AppTest extends TestCase {
   /**
      * Create the test case
      *
      * @param testName name of the test case
   */
   public AppTest( String testName ) {
      super( testName );
   }

   /**
      * @return the suite of tests being tested
   */
   public static Test suite() {
      return new TestSuite( AppTest.class );
   }

   /**
      * Rigourous Test :-)
   */
   public void testApp() {
      assertTrue( true );
   }
}

Deweloperzy są zobowiązani do umieszczania swoich plików, jak wspomniano w powyższej tabeli, a Maven obsługuje wszystkie zawiłości związane z kompilacją.

W następnym rozdziale omówimy, jak zbudować i przetestować projekt za pomocą maven Build and Test Project.

W rozdziale o tworzeniu projektów dowiedzieliśmy się, jak stworzyć aplikację Java za pomocą Mavena. Teraz zobaczymy, jak zbudować i przetestować aplikację.

Przejdź do katalogu C: / MVN, w którym utworzyłeś swoją aplikację java. otwartyconsumerBankingteczka. Zobaczysz plikPOM.xml plik z następującą zawartoś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.companyname.projectgroup</groupId>
   <artifactId>project</artifactId>
   <version>1.0</version>
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
      </dependency>
   </dependencies>  
</project>

Tutaj możesz zobaczyć, Maven dodał już Junit jako framework testowy. Domyślnie Maven dodaje plik źródłowyApp.java i plik testowy AppTest.java w domyślnej strukturze katalogów, jak omówiono w poprzednim rozdziale.

Otwórzmy konsolę poleceń, przejdź do katalogu C: \ MVN \ consumerBanking i wykonaj następujące czynności mvn Komenda.

C:\MVN\consumerBanking>mvn clean package

Maven rozpocznie budowę projektu.

[INFO] Scanning for projects...
[INFO] -------------------------------------------------------------------
[INFO] Building consumerBanking
[INFO] task-segment: [clean, package]
[INFO] -------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] Deleting directory C:\MVN\consumerBanking\target
[INFO] [resources:resources {execution: default-resources}]

[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!

[INFO] skip non existing resourceDirectory C:\MVN\consumerBanking\src\main\resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Compiling 1 source file to C:\MVN\consumerBanking\target\classes
[INFO] [resources:testResources {execution: default-testResources}]

[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!

[INFO] skip non existing resourceDirectory C:\MVN\consumerBanking\src\test\resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] Compiling 1 source file to C:\MVN\consumerBanking\target\test-classes
[INFO] [surefire:test {execution: default-test}]
[INFO] Surefire report directory: C:\MVN\consumerBanking\target\surefire-reports

-----------------------------------------------------
T E S T S
-----------------------------------------------------

Running com.companyname.bank.AppTest

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.027 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\consumerBanking\target\
consumerBanking-1.0-SNAPSHOT.jar

[INFO]-----------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO]-----------------------------------------------

[INFO] Total time: 2 seconds
[INFO] Finished at: Tue Jul 10 16:52:18 IST 2012
[INFO] Final Memory: 16M/89M
[INFO]-----------------------------------------------

Zbudowałeś swój projekt i utworzyłeś ostateczny plik jar, poniżej znajdują się kluczowe koncepcje edukacyjne -

Dajemy mavenowi dwa cele: najpierw wyczyść katalog docelowy (wyczyść), a następnie spakuj wynik kompilacji projektu jako jar (pakiet).
Zapakowany plik jar jest dostępny w folderze ConsumerBanking \ target jako consumerBanking-1.0-SNAPSHOT.jar.
Raporty z testów są dostępne w folderze ConsumerBanking \ target \ surefire-reports.
Maven kompiluje plik (i) kodu źródłowego, a następnie testuje pliki z kodem źródłowym.
Następnie Maven uruchamia przypadki testowe.
Wreszcie Maven tworzy pakiet.

Teraz otwórz konsolę poleceń, przejdź do katalogu C: \ MVN \ consumerBanking \ target \ classes i wykonaj następujące polecenie java.

>java com.companyname.bank.App

Zobaczysz wynik w następujący sposób -

Hello World!

Dodawanie plików źródłowych Java

Zobaczmy, jak możemy dodać dodatkowe pliki Java w naszym projekcie. Otwórz folder C: \ MVN \ consumerBanking \ src \ main \ java \ com \ companyname \ bank, utwórz w nim klasę Util jako Util.java.

package com.companyname.bank;

public class Util {
   public static void printMessage(String message){
      System.out.println(message);
   }
}

Zaktualizuj klasę App, aby używała klasy Util.

package com.companyname.bank;

/**
   * Hello world!
   *
*/

public class App {
   public static void main( String[] args ){
      Util.printMessage("Hello World!");
   }
}

Teraz otwórz konsolę poleceń, przejdź do C:\MVN\consumerBanking katalogu i wykonaj następujące czynności mvn Komenda.

>mvn clean compile

Po pomyślnym zbudowaniu Mavena przejdź do katalogu C: \ MVN \ consumerBanking \ target \ classes i wykonaj następujące polecenie java.

>java -cp com.companyname.bank.App

Zobaczysz wynik w następujący sposób -

Hello World!

Jak wiesz, Maven zarządza zależnościami przy użyciu koncepcji repozytoriów. Ale co się stanie, jeśli zależność nie jest dostępna w żadnym ze zdalnych repozytoriów ani w centralnym repozytorium? Maven dostarcza odpowiedzi na taki scenariusz używając pojęciaExternal Dependency.

Na przykład, zróbmy następujące zmiany w projekcie utworzonym w rozdziale „Tworzenie projektu Java”.

Dodaj lib do folderu src.
Skopiuj dowolny jar do folderu lib. Użyliśmyldapjdk.jar, która jest biblioteką pomocniczą dla operacji LDAP.

Teraz struktura naszego projektu powinna wyglądać następująco -

Tutaj masz własną bibliotekę, specyficzną dla projektu, co jest typowym przypadkiem i zawiera pliki jar, które mogą nie być dostępne w żadnym repozytorium dla mavena do pobrania. Jeśli Twój kod używa tej biblioteki z Maven, kompilacja Maven zakończy się niepowodzeniem, ponieważ nie może pobrać ani odwołać się do tej biblioteki w fazie kompilacji.

Aby poradzić sobie z tą sytuacją, dodajmy tę zewnętrzną zależność do maven pom.xml w następujący sposób.

<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/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.companyname.bank</groupId>
   <artifactId>consumerBanking</artifactId>
   <packaging>jar</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>consumerBanking</name>
   <url>http://maven.apache.org</url>

   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>

      <dependency>
         <groupId>ldapjdk</groupId>
         <artifactId>ldapjdk</artifactId>
         <scope>system</scope>
         <version>1.0</version>
         <systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
      </dependency>
   </dependencies>

</project>

Spójrz na drugi element zależności w obszarze zależności w powyższym przykładzie, który wyjaśnia następujące kluczowe pojęcia dotyczące External Dependency.

Zależności zewnętrzne (lokalizacja jar biblioteki) można skonfigurować w pom.xml w taki sam sposób, jak inne zależności.
Określ identyfikator grupy taki sam, jak nazwa biblioteki.
Określ artifactId taki sam, jak nazwa biblioteki.
Określ zakres jako system.
Określ ścieżkę systemową względem położenia projektu.

Mam nadzieję, że teraz masz jasność co do zależności zewnętrznych i będziesz mógł określić zależności zewnętrzne w swoim projekcie Maven.

Ten samouczek nauczy Cię, jak za jednym zamachem stworzyć dokumentację aplikacji. Więc zacznijmy, przejdź do katalogu C: / MVN, w którym utworzyłeś swoją javaconsumerBankingzastosowanie na przykładach podanych w poprzednich rozdziałach. otwartyconsumerBanking folder i wykonaj następujące czynności mvn Komenda.

C:\MVN>mvn site

Maven rozpocznie budowę projektu.

[INFO] Scanning for projects...
[INFO]-----------------------------------------------
[INFO] Building consumerBanking
[INFO] task-segment: [site]
[INFO]-----------------------------------------------
[INFO] [site:site {execution: default-site}]
[INFO] artifact org.apache.maven.skins:maven-default-skin:
checking for updates from central

[INFO] Generating "About" report.
[INFO] Generating "Issue Tracking" report.
[INFO] Generating "Project Team" report.
[INFO] Generating "Dependencies" report.
[INFO] Generating "Continuous Integration" report.
[INFO] Generating "Source Repository" report.
[INFO] Generating "Project License" report.
[INFO] Generating "Mailing Lists" report.
[INFO] Generating "Plugin Management" report.
[INFO] Generating "Project Summary" report.

[INFO]-----------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO]-----------------------------------------------

[INFO] Total time: 16 seconds
[INFO] Finished at: Wed Jul 11 18:11:18 IST 2012
[INFO] Final Memory: 23M/148M
[INFO]-----------------------------------------------

Twoja dokumentacja projektowa jest już gotowa. Maven utworzył witrynę w katalogu docelowym.

Otwórz folder C: \ MVN \ consumerBanking \ target \ site. Kliknij index.html, aby zobaczyć dokumentację.

Maven tworzy dokumentację za pomocą silnika przetwarzania dokumentacji o nazwie Doxia, który wczytuje wiele formatów źródłowych do wspólnego modelu dokumentu. Aby napisać dokumentację dla swojego projektu, możesz napisać treść w kilku następujących powszechnie używanych formatach, które są analizowane przez Doxia.

Nazwa formatu	Opis	Odniesienie
XDoc	Format dokumentacji Maven 1.x.	https://jakarta.apache.org/site
FML	Używany do dokumentów FAQ	https://maven.apache.org

Maven udostępnia użytkownikom bardzo dużą listę różnych typów szablonów projektów (614 w liczbach) wykorzystujących koncepcję Archetype. Maven pomaga użytkownikom szybko rozpocząć nowy projekt Java za pomocą następującego polecenia.

mvn archetype:generate

Co to jest Archetyp?

Archetype to wtyczka Maven, której zadaniem jest stworzenie struktury projektu zgodnie z jego szablonem. Zamierzamy użyć wtyczki archetypu quickstart do stworzenia tutaj prostej aplikacji java.

Korzystanie z szablonu projektu

Otwórzmy konsolę poleceń, przejdź do C:\ > MVN katalogu i wykonaj następujące czynności mvn Komenda.

C:\MVN>mvn archetype:generate

Maven rozpocznie przetwarzanie i poprosi o wybranie wymaganego archetypu.

[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] -------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO] task-segment: [archetype:generate] (aggregator-style)
[INFO] -------------------------------------------------------------------
[INFO] Preparing archetype:generate
...

600: remote −> org.trailsframework:trails-archetype (-)
601: remote −> org.trailsframework:trails-secure-archetype (-)
602: remote −> org.tynamo:tynamo-archetype (-)
603: remote −> org.wicketstuff.scala:wicket-scala-archetype (-)
604: remote −> org.wicketstuff.scala:wicketstuff-scala-archetype

Basic setup for a project that combines Scala and Wicket,
depending on the Wicket-Scala project.
Includes an example Specs test.)

605: remote −> org.wikbook:wikbook.archetype (-)
606: remote −> org.xaloon.archetype:xaloon-archetype-wicket-jpa-glassfish (-)
607: remote −> org.xaloon.archetype:xaloon-archetype-wicket-jpa-spring (-)
608: remote −> org.xwiki.commons:xwiki-commons-component-archetype
   (Make it easy to create a maven project for creating XWiki Components.)
609: remote −> org.xwiki.rendering:xwiki-rendering-archetype-macro
   (Make it easy to create a maven project for creating XWiki Rendering Macros.)
610: remote −> org.zkoss:zk-archetype-component (The ZK Component archetype)
611: remote −> org.zkoss:zk-archetype-webapp (The ZK wepapp archetype)
612: remote −> ru.circumflex:circumflex-archetype (-)
613: remote −> se.vgregion.javg.maven.archetypes:javg-minimal-archetype (-)
614: remote −> sk.seges.sesam:sesam-annotation-archetype (-)
Choose a number or apply filter
(format: [groupId:]artifactId, case sensitive contains): 203:

Naciśnij Enter, aby wybrać opcję domyślną (203: maven-archetype-quickstart)

Maven zapyta o konkretną wersję archetypu.

Choose org.apache.maven.archetypes:maven-archetype-quickstart version:
1: 1.0-alpha-1
2: 1.0-alpha-2
3: 1.0-alpha-3
4: 1.0-alpha-4
5: 1.0
6: 1.1
Choose a number: 6:

Naciśnij Enter, aby wybrać opcję domyślną (6: maven-archetype-quickstart: 1.1)

Maven zapyta o szczegóły projektu. Wprowadź szczegóły projektu zgodnie z zapytaniem. Naciśnij klawisz Enter, jeśli podano wartość domyślną. Możesz je zmienić, wprowadzając własną wartość.

Define value for property 'groupId': : com.companyname.insurance
Define value for property 'artifactId': : health
Define value for property 'version': 1.0-SNAPSHOT:
Define value for property 'package': com.companyname.insurance:

Maven poprosi o potwierdzenie szczegółów projektu. Naciśnij enter lub naciśnij Y.

Confirm properties configuration:
groupId: com.companyname.insurance
artifactId: health
version: 1.0-SNAPSHOT
package: com.companyname.insurance
Y:

Teraz Maven rozpocznie tworzenie struktury projektu i wyświetli:

[INFO]-----------------------------------------------
[INFO] Using following parameters for creating project
from Old (1.x) Archetype: maven-archetype-quickstart:1.1
[INFO]-----------------------------------------------

[INFO] Parameter: groupId, Value: com.companyname.insurance
[INFO] Parameter: packageName, Value: com.companyname.insurance
[INFO] Parameter: package, Value: com.companyname.insurance
[INFO] Parameter: artifactId, Value: health
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT

[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\health
[INFO]-----------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO]-----------------------------------------------
[INFO] Total time: 4 minutes 12 seconds
[INFO] Finished at: Fri Jul 13 11:10:12 IST 2012
[INFO] Final Memory: 20M/90M
[INFO]-----------------------------------------------

Utworzony projekt

Teraz idź do C:\ > MVNinformator. Zobaczysz utworzony projekt aplikacji Java o nazwiehealth, który został podany jako artifactIdw momencie tworzenia projektu. Maven utworzy standardowy układ katalogu dla projektu, jak pokazano poniżej -

Utworzono POM.xml

Maven generuje plik POM.xml dla projektu, jak pokazano poniżej -

<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.companyname.insurance</groupId>
   <artifactId>health</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>health</name>
   <url>http://maven.apache.org</url>
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
   <dependencies>
      <dependency>
      <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
</project>

Utworzono App.java

Maven generuje przykładowy plik źródłowy Java, App.java dla projektu, jak pokazano poniżej -

Lokalizacja: C:\ > MVN > health > src > main > java > com > companyname > insurance > App.java.

package com.companyname.insurance;

/**
   * Hello world!
   *
*/
public class App {
   public static void main( String[] args ) {
      System.out.println( "Hello World!" );
   }
}

Utworzono AppTest.java

Maven generuje przykładowy plik testowy źródła Java, AppTest.java dla projektu, jak pokazano poniżej -

Lokalizacja: C:\ > MVN > health > src > test > java > com > companyname > insurance > AppTest.java.

package com.companyname.insurance;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
   * Unit test for simple App.
*/
public class AppTest extends TestCase {
   /**
      * Create the test case
      *
     * @param testName name of the test case
   */
   public AppTest( String testName ) {
      super( testName );
   }
   /**
      * @return the suite of tests being tested
   */
   public static Test suite() {
      return new TestSuite( AppTest.class );
   }
   /**
      * Rigourous Test :-)
   */
   public void testApp() {
      assertTrue( true );
   }
}

Teraz możesz zobaczyć moc Mavena. Możesz stworzyć dowolny projekt za pomocą jednego polecenia w maven i możesz przyspieszyć rozwój.

Różne archetypy

Sr.No.	Identyfikatory i opis artefaktów archetypu
1	maven-archetype-archetype Archetyp, który zawiera przykładowy archetyp.
2	maven-archetype-j2ee-simple Archetyp zawierający uproszczoną przykładową aplikację J2EE.
3	maven-archetype-mojo Archetyp, który zawiera próbkę przykładowej wtyczki Maven.
4	maven-archetype-plugin Archetyp zawierający przykładową wtyczkę Maven.
5	maven-archetype-plugin-site Archetyp, który zawiera przykładową witrynę wtyczki Maven.
6	maven-archetype-portlet Archetyp zawierający przykładowy portlet JSR-268.
7	maven-archetype-quickstart Archetyp zawierający przykładowy projekt Mavena.
8	maven-archetype-simple Archetyp zawierający prosty projekt Mavena.
9	maven-archetype-site Archetyp, który zawiera przykładową witrynę Mavena, aby zademonstrować niektóre z obsługiwanych typów dokumentów, takich jak APT, XDoc i FML, oraz demonstruje, jak i18n swoją witrynę.
10	maven-archetype-site-simple Archetyp zawierający przykładową witrynę Maven.
11	maven-archetype-webapp Archetyp zawierający przykładowy projekt Maven Webapp.

Duża aplikacja składa się na ogół z wielu modułów i jest to typowy scenariusz, w którym wiele zespołów pracuje nad różnymi modułami tej samej aplikacji. Załóżmy na przykład, że zespół pracuje nad frontonem aplikacji jako projekt app-ui (app-ui.jar: 1.0) i używa projektu usługi danych (data-service.jar: 1.0).

Teraz może się zdarzyć, że zespół pracujący nad usługą danych jest w trakcie naprawiania błędów lub ulepszeń w szybkim tempie i prawie co drugi dzień wypuszcza bibliotekę do zdalnego repozytorium.

Teraz, jeśli zespół obsługi danych przesyła nową wersję co drugi dzień, pojawią się następujące problemy -

zespół obsługi danych powinien informować zespół app-ui za każdym razem, gdy opublikuje zaktualizowany kod.
Zespół app-ui musiał regularnie aktualizować plik pom.xml, aby uzyskać zaktualizowaną wersję.

Aby poradzić sobie w takiej sytuacji, SNAPSHOT pojawia się koncepcja.

Co to jest SNAPSHOT?

SNAPSHOT to specjalna wersja, która wskazuje aktualną kopię rozwojową. W przeciwieństwie do zwykłych wersji, Maven szuka nowej wersji SNAPSHOT w zdalnym repozytorium dla każdej kompilacji.

Teraz zespół obsługi danych będzie publikował SNAPSHOT zaktualizowanego kodu za każdym razem do repozytorium, powiedzmy data-service: 1.0-SNAPSHOT, zastępując starszy jar SNAPSHOT.

Migawka a wersja

W przypadku wersji, jeśli Maven raz ściągnął wspomnianą wersję, powiedzmy data-service: 1.0, nigdy nie będzie próbował pobrać nowszej wersji 1.0 dostępnej w repozytorium. Aby pobrać zaktualizowany kod, należy zaktualizować wersję usługi danych do 1.1.

W przypadku SNAPSHOT, Maven automatycznie pobierze najnowszy SNAPSHOT (usługa danych: 1.0-SNAPSHOT) za każdym razem, gdy zespół app-ui buduje swój projekt.

app-ui pom.xml

app-ui Project używa 1.0-SNAPSHOT usługi danych.

<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>app-ui</groupId>
   <artifactId>app-ui</artifactId>
   <version>1.0</version>
   <packaging>jar</packaging>
   <name>health</name>
   <url>http://maven.apache.org</url>
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
   <dependencies>
      <dependency>
      <groupId>data-service</groupId>
         <artifactId>data-service</artifactId>
         <version>1.0-SNAPSHOT</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
</project>

usługa danych pom.xml

data-service project wypuszcza 1.0-SNAPSHOT dla każdej drobnej zmiany.

<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>data-service</groupId>
   <artifactId>data-service</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>health</name>
   <url>http://maven.apache.org</url>
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
</project>

Chociaż w przypadku SNAPSHOT, Maven automatycznie pobiera najnowszy SNAPSHOT codziennie, możesz zmusić mavena do pobrania najnowszej wersji migawki za pomocą przełącznika -U do dowolnego polecenia maven.

mvn clean package -U

Otwórzmy konsolę poleceń, przejdź do C:\ > MVN > app-ui katalogu i wykonaj następujące czynności mvn Komenda.

C:\MVN\app-ui>mvn clean package -U

Maven rozpocznie tworzenie projektu po pobraniu najnowszego SNAPSHOTa usługi danych.

[INFO] Scanning for projects...
[INFO]--------------------------------------------
[INFO] Building consumerBanking
[INFO]    task-segment: [clean, package]
[INFO]--------------------------------------------
[INFO] Downloading data-service:1.0-SNAPSHOT
[INFO] 290K downloaded.
[INFO] [clean:clean {execution: default-clean}]
[INFO] Deleting directory C:\MVN\app-ui\target
[INFO] [resources:resources {execution: default-resources}]

[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!

[INFO] skip non existing resourceDirectory C:\MVN\app-ui\src\main\resources
[INFO] [compiler:compile {execution:default-compile}]
[INFO] Compiling 1 source file to C:\MVN\app-ui\target\classes
[INFO] [resources:testResources {execution: default-testResources}]

[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!

[INFO] skip non existing resourceDirectory C:\MVN\app-ui\src\test\resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] Compiling 1 source file to C:\MVN\app-ui\target\test-classes
[INFO] [surefire:test {execution: default-test}]
[INFO] Surefire report directory: C:\MVN\app-ui\target\
surefire-reports

--------------------------------------------------
 T E S T S
--------------------------------------------------

Running com.companyname.bank.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.027 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\app-ui\target\
app-ui-1.0-SNAPSHOT.jar
[INFO]--------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO]--------------------------------------------------------
[INFO] Total time: 2 seconds
[INFO] Finished at: 2015-09-27T12:30:02+05:30
[INFO] Final Memory: 16M/89M
[INFO]------------------------------------------------------------------------

Automatyzacja kompilacji definiuje scenariusz, w którym proces budowania projektów zależnych rozpoczyna się po pomyślnym zakończeniu budowania projektu, w celu zapewnienia, że projekty zależne są stabilne.

Example

Rozważ, że zespół opracowuje projekt bus-core-api na których dwa inne projekty app-web-ui i app-desktop-ui są zależni.

app-web-ui projekt używa 1.0-SNAPSHOT z bus-core-api projekt.

<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>app-web-ui</groupId>
   <artifactId>app-web-ui</artifactId>
   <version>1.0</version>
   <packaging>jar</packaging>
   <dependencies>
      <dependency>
         <groupId>bus-core-api</groupId>
            <artifactId>bus-core-api</artifactId>
            <version>1.0-SNAPSHOT</version>
      </dependency>
   </dependencies>
</project>

app-desktop-ui projekt używa 1.0-SNAPSHOT z bus-core-api projekt.

<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>app_desktop_ui</groupId>
   <artifactId>app_desktop_ui</artifactId>
   <version>1.0</version>
   <packaging>jar</packaging>
   <name>app_desktop_ui</name>
   <url>http://maven.apache.org</url>
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>bus_core_api</groupId>
         <artifactId>bus_core_api</artifactId>
         <version>1.0-SNAPSHOT</version>
         <scope>system</scope>
         <systemPath>C:\MVN\bus_core_api\target\bus_core_api-1.0-SNAPSHOT.jar</systemPath>
      </dependency>
   </dependencies>
</project>

bus-core-api projekt -

<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>bus_core_api</groupId>
   <artifactId>bus_core_api</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>   
</project>

Teraz zespoły app-web-ui i app-desktop-ui projekty wymagają, aby ich proces kompilacji rozpoczynał się w dowolnym momencie bus-core-api zmiany w projekcie.

Korzystanie z migawki zapewnia, że najnowszy plik bus-core-api należy użyć projektu, ale aby spełnić powyższe wymaganie, musimy zrobić coś dodatkowego.

Możemy postępować na dwa sposoby -

Dodaj cel po kompilacji w pompie bus-core-api, aby rozpocząć app-web-ui i app-desktop-ui buduje.
Użyj serwera Continuous Integration (CI), takiego jak Hudson, do automatycznego zarządzania automatyzacją kompilacji.

Korzystanie z Maven

Aktualizacja bus-core-api projekt pom.xml.

<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>bus-core-api</groupId>
   <artifactId>bus-core-api</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <build>
      <plugins>
         <plugin>
         <artifactId>maven-invoker-plugin</artifactId>
         <version>1.6</version>
         <configuration>
            <debug>true</debug>
            <pomIncludes>
               <pomInclude>app-web-ui/pom.xml</pomInclude>
               <pomInclude>app-desktop-ui/pom.xml</pomInclude>
            </pomIncludes>
         </configuration>
         <executions>
            <execution>
               <id>build</id>
               <goals>
                  <goal>run</goal>
               </goals>
            </execution>
         </executions>
         </plugin>
      </plugins>
   <build>
</project>

Otwórzmy konsolę poleceń, przejdź do C:\ > MVN > bus-core-api katalogu i wykonaj następujące czynności mvn Komenda.

>mvn clean package -U

Maven rozpocznie budowę projektu bus-core-api.

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building bus-core-api
[INFO] task-segment: [clean, package]
[INFO] ------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\bus-core-ui\target\
bus-core-ui-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------

Pewnego razu bus-core-api kompilacja zakończyła się pomyślnie, Maven rozpocznie tworzenie pliku app-web-ui projekt.

[INFO] ------------------------------------------------------------------
[INFO] Building app-web-ui
[INFO] task-segment: [package]
[INFO] ------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\app-web-ui\target\
app-web-ui-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------

Pewnego razu app-web-ui kompilacja zakończyła się pomyślnie, Maven rozpocznie tworzenie pliku app-desktop-ui projekt.

[INFO] ------------------------------------------------------------------
[INFO] Building app-desktop-ui
[INFO] task-segment: [package]
[INFO] ------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\app-desktop-ui\target\
app-desktop-ui-1.0-SNAPSHOT.jar
[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] -------------------------------------------------------------------

Korzystanie z usługi ciągłej integracji z Maven

Korzystanie z serwera CI jest bardziej korzystne dla programistów. Nie jest wymagana aktualizacjabus-core-api projekt, za każdym razem, gdy dodawany jest nowy projekt (na przykład app-mobile-ui), jako projekt zależny od bus-core-apiprojekt. Hudsion to narzędzie do ciągłej integracji napisane w Javie, które w kontenerze serwletów, takim jak Apache tomcat i serwer aplikacji glassfish. Hudson automatycznie zarządza automatyzacją kompilacji za pomocą zarządzania zależnościami Maven. Poniższa migawka określi rolę narzędzia Hudson.

Hudson traktuje każdą kompilację projektu jako pracę. Gdy kod projektu zostanie zarejestrowany w SVN (lub dowolnym narzędziu do zarządzania źródłami zmapowanym do Hudson), Hudson rozpoczyna pracę kompilacji, a po zakończeniu tego zadania automatycznie rozpoczyna inne zadania zależne (inne projekty zależne).

W powyższym przykładzie, kiedy bus-core-uikod źródłowy jest aktualizowany w SVN, Hudson rozpoczyna jego budowę. Gdy kompilacja się powiedzie, Hudson automatycznie wyszukuje zależne projekty i zaczyna budowaćapp-web-ui i app-desktop-ui projektowanie.

Jedną z podstawowych funkcji Maven jest zarządzanie zależnościami. Zarządzanie zależnościami to trudne zadanie, gdy mamy do czynienia z projektami wielomodułowymi (składającymi się z setek modułów / podprojektów). Maven zapewnia wysoki stopień kontroli przy zarządzaniu takimi scenariuszami.

Wykrywanie zależności przechodnich

Dość często jest tak, że biblioteka, powiedzmy A, zależy od innej biblioteki, powiedzmy B. W przypadku, gdy inny projekt C chce użyć A, to ten projekt również wymaga użycia biblioteki B.

Maven pomaga uniknąć takich wymagań, aby odkryć wszystkie wymagane biblioteki. Maven robi to, czytając pliki projektu (pom.xml) zależności, ustalając ich zależności i tak dalej.

Musimy tylko zdefiniować bezpośrednią zależność w każdym projekcie pom. Maven zajmuje się resztą automatycznie.

W przypadku zależności przechodnich wykres dołączonych bibliotek może szybko i szybko się rozrosnąć. Przypadki mogą wystąpić, gdy istnieją zduplikowane biblioteki. Maven udostępnia kilka funkcji do kontrolowania zakresu zależności przechodnich.

Sr.No.	Funkcja i opis
1	Dependency mediation Określa, która wersja zależności ma być używana w przypadku napotkania wielu wersji artefaktu. Jeśli dwie wersje zależności znajdują się na tej samej głębokości w drzewie zależności, zostanie użyta pierwsza zadeklarowana zależność.
2	Dependency management Bezpośrednio określ wersje artefaktów, które mają być używane, gdy zostaną napotkane w zależnościach przechodnich. Na przykład projekt C może zawierać B jako zależność w sekcji zarządzania zależnościami i bezpośrednio kontrolować, która wersja B ma być używana, gdy kiedykolwiek zostanie przywołana.
3	Dependency scope Zawiera zależności zgodnie z bieżącym etapem kompilacji.
4	Excluded dependencies Wszelkie zależności przechodnie można wykluczyć za pomocą elementu „exclusion”. Na przykład A zależy od B i B zależy od C, a następnie A może oznaczyć C jako wykluczone.
5	Optional dependencies Każda zależność przechodnia może być oznaczona jako opcjonalna przy użyciu elementu „opcjonalnego”. Na przykład A zależy od B, a B zależy od C. Teraz B oznaczono C jako opcjonalne. Wtedy A nie użyje C.

Zakres zależności

Wykrywanie zależności przechodnich można ograniczyć przy użyciu różnych zakresów zależności, jak wspomniano poniżej.

Sr.No.	Zakres i opis
1	compile Ten zakres wskazuje, że zależność jest dostępna w ścieżce klasy projektu. Jest to zakres domyślny.
2	provided Ten zakres wskazuje, że zależność ma być zapewniana przez JDK lub serwer sieciowy / kontener w czasie wykonywania.
3	runtime Ten zakres wskazuje, że zależność nie jest wymagana do kompilacji, ale jest wymagana podczas wykonywania.
4	test Ten zakres wskazuje, że zależność jest dostępna tylko dla fazy kompilacji testów i wykonywania.
5	system Ten zakres wskazuje, że musisz podać ścieżkę systemową.
6	import Ten zakres jest używany tylko wtedy, gdy zależność jest typu pom. Ten zakres wskazuje, że określony POM powinien zostać zastąpiony zależnościami w sekcji <dependencyManagement> POM.

Zarządzanie zależnościami

Zwykle mamy zestaw projektów w ramach wspólnego projektu. W takim przypadku możemy stworzyć wspólny pom mający wszystkie wspólne zależności, a następnie uczynić go rodzicem pomów podprojektu. Poniższy przykład pomoże ci zrozumieć tę koncepcję.

Poniżej przedstawiono szczegóły powyższego wykresu zależności -

App-UI-WAR zależy od App-Core-lib i App-Data-lib.
Root jest rodzicem App-Core-lib i App-Data-lib.
Root definiuje Lib1, lib2, Lib3 jako zależności w swojej sekcji zależności.

App-UI-WAR

<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.companyname.groupname</groupId>
   <artifactId>App-UI-WAR</artifactId>
   <version>1.0</version>
   <packaging>war</packaging>
   <dependencies>
      <dependency>
         <groupId>com.companyname.groupname</groupId>
         <artifactId>App-Core-lib</artifactId>
         <version>1.0</version>
      </dependency>
   </dependencies>  
   <dependencies>
      <dependency>
         <groupId>com.companyname.groupname</groupId>
         <artifactId>App-Data-lib</artifactId>
         <version>1.0</version>
      </dependency>
   </dependencies>  
</project>

App-Core-lib

<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">
   <parent>
      <artifactId>Root</artifactId>
      <groupId>com.companyname.groupname</groupId>
      <version>1.0</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.companyname.groupname</groupId>
   <artifactId>App-Core-lib</artifactId>
   <version>1.0</version> 
   <packaging>jar</packaging>
</project>

App-Data-lib

<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">
   <parent>
      <artifactId>Root</artifactId>
      <groupId>com.companyname.groupname</groupId>
      <version>1.0</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.companyname.groupname</groupId>
   <artifactId>App-Data-lib</artifactId>
   <version>1.0</version>   
   <packaging>jar</packaging>
</project>

Root

<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.companyname.groupname</groupId>
   <artifactId>Root</artifactId>
   <version>1.0</version>
   <packaging>pom</packaging>
   <dependencies>
      <dependency>
         <groupId>com.companyname.groupname1</groupId>
         <artifactId>Lib1</artifactId>
         <version>1.0</version>
      </dependency>
   </dependencies>  
   <dependencies>
      <dependency>
         <groupId>com.companyname.groupname2</groupId>
         <artifactId>Lib2</artifactId>
         <version>2.1</version>
      </dependency>
   </dependencies>  
   <dependencies>
      <dependency>
         <groupId>com.companyname.groupname3</groupId>
         <artifactId>Lib3</artifactId>
         <version>1.1</version>
      </dependency>
   </dependencies>  
</project>

Teraz, gdy tworzymy projekt App-UI-WAR, Maven odkryje wszystkie zależności, przechodząc przez wykres zależności i budując aplikację.

Z powyższego przykładu możemy nauczyć się następujących kluczowych pojęć -

Typowe zależności można umieścić w jednym miejscu, używając koncepcji macierzystego pom. ZależnościApp-Data-lib i App-Core-libprojekty są wymienione w Root project (Zobacz rodzaj opakowania Root. To jest POM).
Nie ma potrzeby określania Lib1, lib2, Lib3 jako zależności w App-UI-WAR. Maven używaTransitive Dependency Mechanism zarządzać takimi szczegółami.

Podczas opracowywania projektu zwykle proces wdrażania składa się z następujących kroków -

Wpisz kod z całego projektu w toku do SVN (system kontroli wersji) lub repozytorium kodu źródłowego i otaguj go.
Pobierz pełny kod źródłowy z SVN.
Zbuduj aplikację.
Zapisz wynik kompilacji jako plik WAR lub EAR we wspólnej lokalizacji sieciowej.
Pobierz plik z sieci i wdróż go w witrynie produkcyjnej.
Zaktualizowano dokumentację o datę i zaktualizowany numer wersji aplikacji.

Stwierdzenie problemu

W powyższym procesie wdrażania zwykle zaangażowanych jest wiele osób. Jeden zespół może obsłużyć zaewidencjonowanie kodu, inny może zająć się kompilacją i tak dalej. Jest bardzo prawdopodobne, że jakikolwiek krok może zostać pominięty ze względu na wysiłek ręczny i środowisko wielozespołowe. Na przykład starszej kompilacji nie można zastąpić na komputerze sieciowym, a zespół wdrożeniowy ponownie wdrożył starszą kompilację.

Rozwiązanie

Zautomatyzuj proces wdrażania, łącząc następujące elementy -

Maven do tworzenia i wydawania projektów.
SubVersion, repozytorium kodu źródłowego, do zarządzania kodem źródłowym.
Remote Repository Manager (Jfrog / Nexus) do zarządzania plikami binarnymi projektu.

Zaktualizuj projekt POM.xml

Będziemy używać wtyczki Maven Release do tworzenia automatycznego procesu wydawania.

Na przykład: projekt bus-core-api POM.xml.

<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>bus-core-api</groupId>
   <artifactId>bus-core-api</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging> 
   <scm>
      <url>http://www.svn.com</url>
      <connection>scm:svn:http://localhost:8080/svn/jrepo/trunk/
      Framework</connection>
      <developerConnection>scm:svn:${username}/${password}@localhost:8080:
      common_core_api:1101:code</developerConnection>
   </scm>
   <distributionManagement>
      <repository>
         <id>Core-API-Java-Release</id>
         <name>Release repository</name>
         <url>http://localhost:8081/nexus/content/repositories/
         Core-Api-Release</url>
      </repository>
   </distributionManagement>
   <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-release-plugin</artifactId>
            <version>2.0-beta-9</version>
            <configuration>
               <useReleaseProfile>false</useReleaseProfile>
               <goals>deploy</goals>
               <scmCommentPrefix>[bus-core-api-release-checkin]-<
               /scmCommentPrefix>
            </configuration>
         </plugin>
      </plugins>
   </build>
</project>

W Pom.xml poniżej znajdują się ważne elementy, których użyliśmy -

Sr.No.	Element i opis
1	SCM Konfiguruje lokalizację SVN, z której Maven pobierze kod źródłowy.
2	Repositories Miejsce, w którym zbudowany zostanie WAR / EAR / JAR lub jakikolwiek inny artefakt po pomyślnym zbudowaniu kodu.
3	Plugin maven-release-plugin jest skonfigurowany do automatyzacji procesu wdrażania.

Wtyczka Maven Release

Maven wykonuje następujące przydatne zadania przy użyciu maven-release-plugin.

mvn release:clean

Czyści obszar roboczy na wypadek, gdyby ostatni proces wydania nie powiódł się.

mvn release:rollback

Wycofaj zmiany wprowadzone w kodzie obszaru roboczego i konfiguracji w przypadku niepowodzenia ostatniego procesu wydania.

mvn release:prepare

Wykonuje wiele operacji, takich jak -

Sprawdza, czy są jakieś niezatwierdzone zmiany lokalne, czy nie.
Zapewnia, że nie ma żadnych zależności SNAPSHOT.
Zmienia wersję aplikacji i usuwa SNAPSHOT z wersji w celu wydania.
Zaktualizuj pliki pom do SVN.
Uruchom przypadki testowe.
Zatwierdź zmodyfikowane pliki POM.
Oznacz kod w Subversion
Zwiększ numer wersji i dołącz SNAPSHOT do przyszłej wersji.
Zatwierdź zmodyfikowane pliki POM do SVN.

mvn release:perform

Sprawdza kod przy użyciu wcześniej zdefiniowanego tagu i uruchamia cel wdrożenia Maven, aby wdrożyć wojnę lub zbudowany artefakt w repozytorium.

Otwórzmy konsolę poleceń, przejdź do C:\ > MVN >bus-core-api katalogu i wykonaj następujące czynności mvn Komenda.

>mvn release:prepare

Maven rozpocznie budowę projektu. Po pomyślnym zakończeniu kompilacji uruchom następującemvn Komenda.

>mvn release:perform

Gdy kompilacja się powiedzie, możesz zweryfikować przesłany plik JAR w swoim repozytorium.

W tym rozdziale dowiesz się, jak zarządzać projektem internetowym za pomocą Maven. Tutaj dowiesz się, jak stworzyć / zbudować / wdrożyć i uruchomić aplikację internetową.

Utwórz aplikację internetową

Aby stworzyć prostą aplikację internetową java, użyjemy maven-archetype-webapppodłącz. Otwórzmy więc konsolę poleceń, przejdź doC:\MVN katalogu i wykonaj następujące czynności mvn Komenda.

C:\MVN>mvn archetype:generate 
-DgroupId = com.companyname.automobile 
-DartifactId = trucks
-DarchetypeArtifactId = maven-archetype-webapp 
-DinteractiveMode = false

Maven rozpocznie przetwarzanie i utworzy pełną strukturę projektu aplikacji internetowej Java w następujący sposób -

[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] -------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO] task-segment: [archetype:generate] (aggregator-style)
[INFO] -------------------------------------------------------------------
[INFO] Preparing archetype:generate
[INFO] No goals needed for project - skipping
[INFO] [archetype:generate {execution: default-cli}]
[INFO] Generating project in Batch mode
[INFO] --------------------------------------------------------------------
[INFO] Using following parameters for creating project
from Old (1.x) Archetype: maven-archetype-webapp:1.0
[INFO] --------------------------------------------------------------------

[INFO] Parameter: groupId, Value: com.companyname.automobile
[INFO] Parameter: packageName, Value: com.companyname.automobile
[INFO] Parameter: package, Value: com.companyname.automobile
[INFO] Parameter: artifactId, Value: trucks
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT

[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\trucks

[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] -------------------------------------------------------------------

[INFO] Total time: 16 seconds
[INFO] Finished at: Tue Jul 17 11:00:00 IST 2012
[INFO] Final Memory: 20M/89M
[INFO] -------------------------------------------------------------------

Teraz przejdź do katalogu C: / MVN. Zobaczysz utworzony projekt aplikacji Java o nazwie Trucks (zgodnie z artifactId), jak określono w poniższej migawce. Następująca struktura katalogów jest zwykle używana w aplikacjach internetowych -

Maven używa standardowego układu katalogów. Korzystając z powyższego przykładu, możemy zrozumieć następujące kluczowe pojęcia -

Sr.No.	Struktura i opis folderów
1	trucks zawiera folder src i pom.xml.
2	src/main/webapp zawiera index.jsp i folder WEB-INF.
3	src/main/webapp/WEB-INF zawiera plik web.xml
4	src/main/resources zawiera pliki obrazów / właściwości.

POM.xml

<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/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.companyname.automobile</groupId>
   <artifactId>trucks</artifactId>
   <packaging>war</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>trucks Maven Webapp</name>
   <url>http://maven.apache.org</url>
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
       </dependency>
   </dependencies>
   <build>
      <finalName>trucks</finalName>
   </build>
</project>

Jeśli zauważysz, zauważysz, że Maven utworzył również przykładowy plik źródłowy JSP.

otwarty C:\ > MVN > trucks > src > main > webapp > folder, aby zobaczyć index.jsp z następującym kodem -

<html>
   <body>
      <h2>Hello World!</h2>
   </body>
</html>

Utwórz aplikację internetową

Otwórzmy konsolę poleceń, przejdź do katalogu C: \ MVN \ Trucks i wykonaj następujące czynności mvn Komenda.

C:\MVN\trucks>mvn clean package

Maven rozpocznie budowę projektu.

[INFO] Scanning for projects...
[INFO] -------------------------------------------------------------------
[INFO] Building trucks Maven Webapp
[INFO] task-segment: [clean, package]
[INFO] -------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] [resources:resources {execution: default-resources}]

[WARNING] Using platform encoding (Cp1252 actually) to
copy filtered resources,i.e. build is platform dependent!

[INFO] Copying 0 resource
[INFO] [compiler:compile {execution: default-compile}]
[INFO] No sources to compile
[INFO] [resources:testResources {execution: default-testResources}]

[WARNING] Using platform encoding (Cp1252 actually) to
copy filtered resources,i.e. build is platform dependent!

[INFO] skip non existing resourceDirectory
C:\MVN\trucks\src\test\resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] No sources to compile
[INFO] [surefire:test {execution: default-test}]
[INFO] No tests to run.
[INFO] [war:war {execution: default-war}]
[INFO] Packaging webapp
[INFO] Assembling webapp[trucks] in [C:\MVN\trucks\target\trucks]
[INFO] Processing war project
[INFO] Copying webapp resources[C:\MVN\trucks\src\main\webapp]
[INFO] Webapp assembled in[77 msecs]
[INFO] Building war: C:\MVN\trucks\target\trucks.war
[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] -------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Tue Jul 17 11:22:45 IST 2012
[INFO] Final Memory: 11M/85M
[INFO] -------------------------------------------------------------------

Wdróż aplikację internetową

Teraz skopiuj trucks.war Utworzony w C:\ > MVN > trucks > target > folder do katalogu aplikacji sieci web serwera WWW i uruchom ponownie serwer WWW.

Testuj aplikację internetową

Uruchom aplikację internetową przy użyciu adresu URL: http://<server-name>:<port-number>/trucks/index.jsp.

Sprawdź dane wyjściowe.

Eclipse zapewnia doskonałą wtyczkę m2eclipse, która bezproblemowo integruje Maven i Eclipse.

Poniżej wymieniono niektóre funkcje m2eclipse -

Możesz uruchomić cele Maven z Eclipse.
Możesz przeglądać dane wyjściowe poleceń Mavena wewnątrz Eclipse, używając jego własnej konsoli.
Możesz aktualizować zależności maven za pomocą IDE.
Możesz uruchamiać kompilacje Mavena z poziomu Eclipse.
Zarządza zależnościami dla ścieżki kompilacji Eclipse na podstawie pom.xml Mavena.
Rozwiązuje zależności Maven z obszaru roboczego Eclipse bez instalowania do lokalnego repozytorium Maven (wymaga, aby projekt zależności znajdował się w tym samym obszarze roboczym).
Automatycznie pobiera wymagane zależności i źródła ze zdalnych repozytoriów Maven.
Zapewnia kreatory do tworzenia nowych projektów Maven, pom.xml i umożliwia obsługę Maven w istniejących projektach
Zapewnia szybkie wyszukiwanie zależności w zdalnych repozytoriach Maven.

Instalowanie wtyczki m2eclipse

Użyj jednego z poniższych linków, aby zainstalować m2eclipse -

Zaćmienie	URL
Eclipse 3.5 (Gallileo)	Instalowanie m2eclipse w Eclipse 3.5 (Gallileo)
Eclipse 3.6 (Helios)	Instalowanie m2eclipse w Eclipse 3.6 (Helios)

Poniższy przykład pomoże Ci wykorzystać zalety integracji Eclipse i Mavena.

Zaimportuj projekt Mavena w Eclipse

Otwórz Eclipse.
Wybierz File > Import > opcja.
Wybierz opcję Maven Projekty. Kliknij przycisk Dalej.

Wybierz lokalizację projektu, w której projekt został utworzony za pomocą Maven. W poprzednich rozdziałach stworzyliśmy bankowość konsumencką projektu Java. Przejdź do rozdziału „Tworzenie projektu w języku Java”, aby zobaczyć, jak stworzyć projekt za pomocą Mavena.
Kliknij przycisk Zakończ.

Teraz możesz zobaczyć projekt maven w zaćmieniu.

Teraz spójrz na consumer Bankingwłaściwości projektu. Możesz zobaczyć, że Eclipse dodał zależności Maven do ścieżki budowania java.

Teraz nadszedł czas, aby zbudować ten projekt przy użyciu możliwości maven zaćmienia.

Kliknij prawym przyciskiem myszy projekt ConsumerBanking, aby otworzyć menu kontekstowe.
Wybierz opcję Uruchom jako.
Następnie opcja pakietu Maven.

Maven rozpocznie budowę projektu. Możesz zobaczyć dane wyjściowe w Konsoli Eclipse w następujący sposób -

[INFO] Scanning for projects...
[INFO] -------------------------------------------------------------------
[INFO] Building consumerBanking
[INFO]
[INFO] Id: com.companyname.bank:consumerBanking:jar:1.0-SNAPSHOT
[INFO] task-segment: [package]
[INFO] -------------------------------------------------------------------
[INFO] [resources:resources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:compile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [resources:testResources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:testCompile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [surefire:test]
[INFO] Surefire report directory:
C:\MVN\consumerBanking\target\surefire-reports

-------------------------------------------------------
T E S T S
-------------------------------------------------------

Running com.companyname.bank.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.047 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] [jar:jar]

[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] -------------------------------------------------------------------

[INFO] Total time: 1 second
[INFO] Finished at: Thu Jul 12 18:18:24 IST 2012
[INFO] Final Memory: 2M/15M
[INFO] -------------------------------------------------------------------

Teraz kliknij prawym przyciskiem myszy App.java. WybierzRun Asopcja. Następnie wybierzJava Application.

Zobaczysz wynik w następujący sposób -

Hello World!

NetBeans 6.7 i nowsze mają wbudowaną obsługę Maven. W przypadku poprzedniej wersji wtyczka Maven jest dostępna w menedżerze wtyczek. W tym przykładzie używamy NetBeans 6.9.

Niektóre funkcje NetBeans są wymienione poniżej -

Możesz uruchamiać cele Maven z NetBeans.
Możesz przeglądać dane wyjściowe poleceń Mavena wewnątrz NetBeans za pomocą własnej konsoli.
Możesz aktualizować zależności maven za pomocą IDE.
Możesz uruchamiać kompilacje Maven z poziomu NetBeans.
NetBeans automatycznie zarządza zależnościami na podstawie pom.xml Mavena.
NetBeans rozwiązuje zależności Maven ze swojego obszaru roboczego bez instalacji do lokalnego repozytorium Maven (wymaga, aby projekt zależności znajdował się w tym samym obszarze roboczym).
NetBeans automatycznie pobiera wymagane zależności i źródła ze zdalnych repozytoriów Maven.
NetBeans udostępnia kreatory do tworzenia nowych projektów Maven, pom.xml.
NetBeans udostępnia przeglądarkę Maven Repository, która umożliwia przeglądanie lokalnego repozytorium i zarejestrowanych zewnętrznych repozytoriów Maven.

Poniższy przykład pomoże Ci wykorzystać zalety integracji NetBeans i Maven.

Otwórz projekt Maven w NetBeans

Otwórz NetBeans.
Wybierz File Menu > Open Project opcja.
Wybierz lokalizację projektu, w której projekt został utworzony za pomocą Maven. Stworzyliśmy ConsumerBanking Projektu Java. Przejdź do rozdziału „Tworzenie projektu w języku Java”, aby zobaczyć, jak stworzyć projekt za pomocą Mavena.

Teraz możesz zobaczyć projekt maven w NetBeans. Zapoznaj się z bibliotekami projektów ConsumerBanking i bibliotekami testowymi. Możesz zobaczyć, że NetBeans dodał zależności Maven do swojej ścieżki budowania.

Zbuduj projekt maven w NetBeans

Teraz nadszedł czas, aby zbudować ten projekt przy użyciu możliwości NetBeans Maven.

Kliknij prawym przyciskiem myszy projekt ConsumerBanking, aby otworzyć menu kontekstowe.
Wybierz opcję Wyczyść i zbuduj jako opcję.

Maven rozpocznie budowę projektu. Możesz zobaczyć dane wyjściowe w konsoli NetBeans w następujący sposób -

NetBeans: Executing 'mvn.bat -Dnetbeans.execution = true clean install'
NetBeans:      JAVA_HOME = C:\Program Files\Java\jdk1.6.0_21
Scanning for projects...
------------------------------------------------------------------------
Building consumerBanking
   task-segment: [clean, install]
------------------------------------------------------------------------
[clean:clean]
[resources:resources]
[WARNING] Using platform encoding (Cp1252 actually)
to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory C:\MVN\consumerBanking\src\main\resources
[compiler:compile]
Compiling 2 source files to C:\MVN\consumerBanking\target\classes
[resources:testResources]
[WARNING] Using platform encoding (Cp1252 actually)
to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory C:\MVN\consumerBanking\src\test\resources
[compiler:testCompile]
Compiling 1 source file to C:\MVN\consumerBanking\target\test-classes
[surefire:test]
Surefire report directory: C:\MVN\consumerBanking\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.companyname.bank.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.023 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[jar:jar]
Building jar: C:\MVN\consumerBanking\target\consumerBanking-1.0-SNAPSHOT.jar
[install:install]
Installing C:\MVN\consumerBanking\target\consumerBanking-1.0-SNAPSHOT.jar
to C:\Users\GB3824\.m2\repository\com\companyname\bank\consumerBanking\
1.0-SNAPSHOT\consumerBanking-1.0-SNAPSHOT.jar
------------------------------------------------------------------------
BUILD SUCCESSFUL
------------------------------------------------------------------------
Total time: 9 seconds
Finished at: Thu Jul 19 12:57:28 IST 2012
Final Memory: 16M/85M
------------------------------------------------------------------------

Uruchom aplikację w NetBeans

Teraz kliknij prawym przyciskiem myszy App.java. WybierzRun Filejako opcja. Wynik zobaczysz w konsoli NetBeans.

NetBeans: Executing 'mvn.bat -Dexec.classpathScope = runtime 
-Dexec.args = -classpath %classpath com.companyname.bank.App 
-Dexec.executable = C:\Program Files\Java\jdk1.6.0_21\bin\java.exe 
-Dnetbeans.execution = true process-classes 
org.codehaus.mojo:exec-maven-plugin:1.1.1:exec'
NetBeans:      JAVA_HOME = C:\Program Files\Java\jdk1.6.0_21
Scanning for projects...
------------------------------------------------------------------------
Building consumerBanking
   task-segment: [process-classes, 
   org.codehaus.mojo:exec-maven-plugin:1.1.1:exec]
------------------------------------------------------------------------
[resources:resources]
[WARNING] Using platform encoding (Cp1252 actually) 
to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory C:\MVN\consumerBanking\src\main\resources
[compiler:compile]
Nothing to compile - all classes are up to date
[exec:exec]
Hello World!
------------------------------------------------------------------------
BUILD SUCCESSFUL
------------------------------------------------------------------------
Total time: 1 second
Finished at: Thu Jul 19 14:18:13 IST 2012
Final Memory: 7M/64M
------------------------------------------------------------------------

IntelliJ IDEA ma wbudowaną obsługę Maven. W tym przykładzie używamy IntelliJ IDEA Community Edition 11.1.

Niektóre funkcje IntelliJ IDEA są wymienione poniżej -

Możesz uruchomić cele Maven z IntelliJ IDEA.
Możesz przeglądać dane wyjściowe poleceń Maven wewnątrz IntelliJ IDEA przy użyciu własnej konsoli.
Możesz aktualizować zależności maven w IDE.
Możesz uruchamiać kompilacje Maven z poziomu IntelliJ IDEA.
IntelliJ IDEA automatycznie zarządza zależnościami w oparciu o pom.xml Mavena.
IntelliJ IDEA rozwiązuje zależności Maven z jego obszaru roboczego bez instalacji do lokalnego repozytorium Maven (wymaga, aby projekt zależności znajdował się w tym samym obszarze roboczym).
IntelliJ IDEA automatycznie pobiera wymagane zależności i źródła ze zdalnych repozytoriów Maven.
IntelliJ IDEA zapewnia kreatory do tworzenia nowych projektów Maven, pom.xml.

Poniższy przykład pomoże Ci wykorzystać zalety integracji IntelliJ IDEA i Maven.

Utwórz nowy projekt w IntelliJ IDEA

Zaimportujemy projekt Maven za pomocą Kreatora nowego projektu.

Otwórz IntelliJ IDEA.
Wybierz File Menu > New Project Opcja.
Wybierz projekt importu z istniejącego modelu.

Wybierz opcję Maven

Wybierz lokalizację projektu, w której projekt został utworzony za pomocą Maven. Stworzyliśmy ConsumerBanking Projektu Java. Przejdź do rozdziału „Tworzenie projektu w języku Java”, aby zobaczyć, jak stworzyć projekt za pomocą Mavena.

Wybierz projekt Maven do zaimportowania.

Wpisz nazwę projektu i kliknij Zakończ.

Teraz możesz zobaczyć projekt maven w IntelliJ IDEA. Zapoznaj się z zewnętrznymi bibliotekami projektu ConsumerBanking. Możesz zobaczyć, że IntelliJ IDEA dodał zależności Maven do swojej ścieżki kompilacji w sekcji Maven.

Zbuduj projekt maven w IntelliJ IDEA

Teraz nadszedł czas, aby zbudować ten projekt z wykorzystaniem możliwości IntelliJ IDEA.

Wybierz projekt ConsumerBanking.
Wybierz Buid menu > Rebuild Project Opcja

Możesz zobaczyć dane wyjściowe w konsoli IntelliJ IDEA

4:01:56 PM Compilation completed successfully

Uruchom aplikację w IntelliJ IDEA

Wybierz projekt ConsumerBanking.
Kliknij prawym przyciskiem myszy plik App.java, aby otworzyć menu kontekstowe.
Wybierz Run App.main()

Wynik zobaczysz w konsoli IntelliJ IDEA.

"C:\Program Files\Java\jdk1.6.0_21\bin\java"
-Didea.launcher.port=7533 
"-Didea.launcher.bin.path=
C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 11.1.2\bin"
-Dfile.encoding=UTF-8 
-classpath "C:\Program Files\Java\jdk1.6.0_21\jre\lib\charsets.jar;

C:\Program Files\Java\jdk1.6.0_21\jre\lib\deploy.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\javaws.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\jce.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\jsse.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\management-agent.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\plugin.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\resources.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\rt.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\dnsns.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\localedata.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\sunjce_provider.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\sunmscapi.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\sunpkcs11.jar

C:\MVN\consumerBanking\target\classes;
C:\Program Files\JetBrains\
IntelliJ IDEA Community Edition 11.1.2\lib\idea_rt.jar" 
com.intellij.rt.execution.application.AppMain com.companyname.bank.App
Hello World!

Process finished with exit code 0