Maven: guida pratica

Marco Sangiorgi

21 ottobre 2009

1

Indice

1 Introduzione 3

2 Installazione e primo utilizzo 42.1 Installare Maven . . . . . . . . . . . . . . . . . . . . . . . . . 42.2 Primi passi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.3 Il file pom.xml e la struttura del progetto . . . . . . . . . . . 7

3 Approfondiamo un po’... 93.1 Gestione delle dipendenze . . . . . . . . . . . . . . . . . . . . 93.2 Dipendenze da altri repository . . . . . . . . . . . . . . . . . 103.3 Condivisione dei nostri .jar in remoto . . . . . . . . . . . . . . 103.4 Creazione di una “libreria” e suo riutilizzo in un altro progetto 12

4 Integrazione con svn 154.1 Come creare un repository . . . . . . . . . . . . . . . . . . . . 154.2 Creare tag e branch con il minimo sforzo . . . . . . . . . . . . 17

5 Maven2 e gli IDE 185.1 Integrazione con Eclipse . . . . . . . . . . . . . . . . . . . . . 195.2 Integrazione con Netbeans . . . . . . . . . . . . . . . . . . . . 20

2

1 Introduzione

Maven e un tool open source per la gestione del ciclo di vita del codice java,che aiuta a creare, organizzare, compilare e distribuire i propri progetti.Permette di gestire e automatizzare il processo di compilazione, la fase ditest, la creazione della reportistica e la documentazione a partire da un unicofile di configurazione, chiamato Project Object Model (pom.xml).

Immaginate di dover analizzare e modificare il codice java sviluppatoda un altro utente che utilizza contemporaneamente diversi progetti OpenSource, come ad esempio Apache Tomcat, FUSE Message Broker, ApacheServiceMix, FUSE Services Framework, etc. E immediato rendersi contodel fatto che il tempo richiesto per completare il download di tutte questelibrerie, la loro installazione e la configurazione dell’ambiente di runtime none certo trascurabile, senza contare che dovranno anche essere disponibili leversioni dei vari progetti utilizzati dal codice Java, le classi Java da lanciareper eseguire il codice, la versione del JDK, etc. Maven automatizza tutto ilprocesso: cio di cui avete bisogno, oltre al JDK ed eventualmente al vostroIDE preferito, sono i sorgenti del codice Java, il file pom.xml e, naturalmente,Maven .

Alcune delle funzionalita piu importanti che Maven offre sono le seguenti:

• Gestione automatizzata delle dipendenze (file jar) in un progetto, com-prese le dipendenze transitive. Con la semplice aggiunta di alcune righeal Project Object Model (pom), Maven si occupa di scaricare e rendereutilizzabili tutte le dipendenze necessarie.

• Supporto chiaro e ben definito ai progetti multimodulo. In questo casoMaven localizza i pom dei sottomoduli e li carica nel Maven Reactor,un componente in grado di analizzare le dipendenze tra i moduli estabilire l’ordine di compilazione e packaging.

• Fasi di vita del progetto ben definite, come compilazione, testing,packaging ecc.

• Facilita di ampliarne le funzionalita iniziali tramite l’utilizzo di plu-gin reperibili in rete. Sia dal sito ufficiale del progetto che da terzeparti e possibile recuperare un altissimo numero di plugin, che ci aiu-tano a sviluppare prima e meglio i nostri progetti. Il tutto possibileaggiungendo solo pochissime righe all’ormai noto pom.xml.

Riguardo all’ultimo punto in particolare, infatti, possiamo facilmentenotare come Maven occupi pochissima memoria appena installato, salvo poiscaricare le dipendenze necessarie al corretto funzionamento prelevandoledai repository da noi specificati. Tali files verranno posti, nei sistemi UNIX,nella cartella \$HOME/.m2/repository pronti per essere riutilizzati.

3

2 Installazione e primo utilizzo

2.1 Installare Maven

Essendo un tool molto utilizzato, oltre che open source, Maven e gia a dispo-sizione nei repository di molte distribuzioni linux. Per la maggior parte delledistribuzioni debian-based, quindi, per installare Maven e sufficiente eseguirein un terminale i seguenti comandi:

:˜$ sudo apt-get install maven2

mentre per le ultime versioni di Fedora, il comando da usare e:

:˜$ sudo yum install maven2

E’ comunque caldamente consigliato, prima di passare all’installazione man-uale, controllare che all’interno dei repository ufficiali della vostra distribuzionenon sia gia presente il pacchetto ricompilato.

In ogni caso e possibile effettuare l’installazione ‘manuale’ recuperan-do i sorgenti del progetto da http://maven.apache.org/download.html,scompattandoli in una directory a propria scelta e poi settando le seguentivariabili d’ambiente:

Linuxexport JAVA_HOME=path-to-javaexport M2_HOME=path-to-mavenexport PATH=$M2_HOME/bin:$JAVA_HOME/bin;$PATH

Windowsset JAVA_HOME=path-to-javaset M2_HOME=path-to-mavenset PATH=%M2_HOME%\bin;%JAVA_HOME%\bin;%PATH%

Possiamo verificare il buon fine delle nostre operazione lanciando il coman-do:

:˜$ mvn -v

Se tutto e andato bene, verranno visualizzate le versioni di Maven e di javautilizzate, come evidenziato nella figura 1:

2.2 Primi passi

Adesso che abbiamo la nostra versione di Maven installata e funzionante,vediamo come fare a creare il primo progetto, con una panoramica generale

4

Figura 1: Risultato di mvn -v

sulle funzioni basilari del programma. Una delle caratteristiche particolar-mente interessanti di Maven e quella di fornire un insieme di standard cherendono possibile l’applicazione di tutta una serie di best practises per laprogrammazione. Uno di questi standard e costituito dalla struttura delladirectory del progetto, denominata archetype (archetipo).

L’archetipo non e altro che un template di un progetto Maven che incap-sula le best practises dell’organizzazione e le struttura in una forma riusabile.Pensiamo ad esempio allo sviluppo di una libreria in un ambiente di lavorocondiviso: chi la dovra utilizzare, se vorra modificarla, riuscira a capire subitodove sono i file sorgenti, i file di documentazione e non solo; sapra rintrac-ciare immediatamente il file jar e i test effettuati, oltre che poter accedere,dando una rapida occhiata al pom.xml, a tutte le informazioni sulle dipen-denze necessarie. Vedremo comunque un esempio di tale struttura poco piuavanti.

Coerentemente con l’impostazione di Maven , applicare tali standard none obbligatorio, sebbene sia consigliabile: avere una struttura della directorydel progetto facilmente riproducibile e interpretabile da chiunque e, comespiegato, utilissimo in un numero enorme di casi.

Il comando Maven classico presenta la seguente struttura standard:

5

mvn <nome-plugin> <:> <nome-goal> <parametri>

dove nome-goal identifica il goal (l’azione) da prendere in considerazionetra tutte quelle fornite dal plugin selezionato.

Creiamo adesso il nostro primo progetto Maven , eseguendo le seguentiistruzioni in un terminale:

:˜$ cd $HOME:˜$ mvn archetype:create -DgroupId=it.tel.example -DartifactId=Hello:˜$ cd Hello:˜$ mkdir -p src/main/resources:˜$ mkdir -p src/test/resources:˜$ mvn package

Andiamo a vedere un po’ cosa e successo: Maven si e occupato di creareuna directory, chiamata con l’id artefatto che abbiamo specificato (Hello),che risulta essere la radice del nostro progetto. All’interno di essa e presenteun file, il pom.xml, il quale e il vero cuore di ogni applicazione Maven .

Il Project Object Model, infatti, e il file in cui vengono definite tuttele specifiche del nostro progetto, a partire dal nome fino ad arrivare alledipendenze di compilazione, all’indirizzo di repository ecc. ecc. Maven sipreoccupa di creare uno di base con pochissime righe, ma sufficienti percostruire il nostro primo pacchetto jar.

Maven ha creato anche una struttura di directory standard, e si e occu-pato di posizionare i file al posto giusto. Nello specifico, la struttura baseche il comando lanciato in precedenza ha creato e la seguente:

./pom.xml

./src

./src/main

./src/main/java

./src/main/java/it

./src/main/java/it/tel

./src/main/java/it/tel/example

./src/main/java/it/tel/example/App.java

./src/main/resurces

./src/test

./src/test/java

./src/test/java/it

./src/test/java/it/tel

./src/test/java/it/tel/example

./src/test/java/it/tel/example/AppTest.java

./src/test/resurces

6

Prestare attenzione al fatto che src/main/java e src/test/java de-vono contenere soltanto i file java sorgenti. Gli altri file che vogliamo incuderenel classpath andranno posizionati in src/main/resources e src/test/resourcesrispettivamente, e Maven si occupera di trattarli nel modo giusto.

Possiamo anche testare il funzionamento della nostra applet con il clas-sico modo di eseguire file jar:

:˜$ java -cp target/Hello-1.0-SNAPSHOT.jar it.tel.example.App

e vedremo stampato a terminale il nostro bellissimo Hello World, comeesplicato in figura 2.

Figura 2: Il nostro primo eseguibile con maven!

2.3 Il file pom.xml e la struttura del progetto

Nella directory root verranno ubicati i seguenti file: pom.xml, profile.xml,LICENSE.txt e README.txt. Il primo contiene la descrizione dichiarativa delprogetto, mentre profile.xml e utilizzato per definire valori che permettonodi configurare diversi elementi dell’esecuzione di Maven .

Questo file non dovrebbe contenere configurazioni relative a specificiprogetti, ne dovrebbe essere distribuito. Esempi di elementi che si possonotrovare in questo file sono l’indirizzo del respository locale e di quello remo-to, e informazioni relative all’autenticazione. I restanti due file contengono,rispettivamente, il testo della licenza e informazioni relative al progetto, utiliper gli sviluppatori.

La directory src, come e lecito attendersi, e destinata a ospitare i filesorgenti in senso ampio. L’attenzione quindi non e limitata ai soli file Javache, una volta compilati, andranno a formare il file di distribuzione (dopoessere stati spostati nella directory target/classes), bensı include anchefile di test, eventuali file di script, comandi SQL, etc.

La prima sottodirectory di src e main, destinata a ospitare i sorgenti

7

Java (java), i file di test (test), i sorgenti scritti in eventuali altri linguaggie la configurazione per il sito (site). Come da standard Sun, la directorysrc/main/java rappresenta la root dei sorgenti Java; pertanto e necessariointrodure altre sottocartelle per classificare in maniera univoca il proget-to e i relativi file. Cio si ottiene creando, in cascata, le seguenti directory:tipo dell’organizzazione (com, org, etc.), l’azienda, il dipartimento, eventual-mente il sotto-dipartimento, il nome del progetto, e cosı via. La directorysrc/main/resources memorizza eventuali file di risorse java, come per es-empio i file properties, file xml, da copiare nella directory target/classes.La regola e che Maven include nel file di distribuzione tutti i file e le direc-tory contenuti in src/main/resources con la stessa struttura con cui sonomemorizzati.

La directory site contiene informazioni utilizzate per generare la doc-umentazione relativa al progetto (a tale fine si deve utilizzare il comandomvn site) copiate nella directory target/site. Il framework utilizzato perla generazione delle informazioni e Doxia.(http://maven.apache.org/doxia/book/index.html).

La directory target, infine, ospita i vari file prodotti a partire da quel-li presenti nella direcory src. Per esempio, le classi Java, i JavaDoc, ladocumentazione del progetto, il file di distribuzione, e cosı via.

Ma guardiamo adesso un po’ piu nel dettaglio il file pom.xml, come abbi-amo gia detto il file piu importante del nostro progetto Maven : il contenutodi default che il nostro programma ci inserisce e il seguente:

<project xmlns="http://maven.apache.org/POM/4.0.0" [omissis]><modelVersion>4.0.0</modelVersion><groupId>it.tel.example</groupId><artifactId>Hello</artifactId><packaging>jar</packaging><version>1.0-SNAPSHOT</version><name>Hello</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>

</project>

Come possiamo notare, all’interno del file sono presenti tutte le infor-mazioni sensibili del nostro progetto:

8

• Una intestazione che specifica la versione del pom che stiamo usando

• L’id del gruppo a cui appartiene il progetto

• L’id dell’artefatto che stiamo costruendo

• Il tipo di pacchetto che Maven deve costruire (jar, war ecc. ecc.)

• L’attuale versione del nostro pacchetto

• Il nome della nostra applicazione

• Una semplice dipendenza di base

Queste poche righe sono sufficienti per costruire la nostra prima ap-plicazione, ma risultano subito insufficienti quando vogliamo fare qualcosadi piu rispetto ad un semplice Hello Word. Andremo quindi adesso adaddentrarci un po’ di piu nelle funzionalita di Maven .

3 Approfondiamo un po’...

3.1 Gestione delle dipendenze

Consideriamo ad esempio il caso in cui abbiamo bisogno di utilizzare nelnostro progetto le librerie commons-cli e commons-lang di apache. Sarasufficiente inserire le seguenti righe nel pom.xml e Maven si preoccupera discaricarle e di installarle nel repository Maven locale, che si trova di defaultin $HOME/.m2/repository/, al posto nostro:

<dependencies>....<dependency><groupId>commons-cli</groupId><artifactId>commons-cli</artifactId><version>1.1</version>

</dependency><dependency><groupId>commons-lang</groupId><artifactId>commons-lang</artifactId><version>2.3</version>

</dependency>....

</dipendencies>

Da notare come per ogni libreria e specificato il groupId, l’id dell’arte-fatto e la versione, in modo da poterci permettere di bloccare l’utilizzo diuna certa libreria ad una versione data, oppure di testare, modificando unasola riga, la nostra applicazione con versioni diverse.

9

3.2 Dipendenze da altri repository

Quanto specificato sopra, pero, vale soltanto per le dipendenze che Mavenpuo risolvere cercando all’interno del suo repository di default, altrimentiriceverete un errore del tipo BUILD ERROR: Missing artifact. Se infattivogliamo aggiungere dipendenze particolari al nostro progetto, all’internodella sezione <dependencies> dovremo specificare anche l’url del repositoryda cui andare a scaricarle, ad esempio:

<project>....<repositories><repository>

<id>java.net</id><name>Sun repository</name><url>http://download.java.net/maven/2/</url><layout>default</layout>

</repository></repositories>

....</project>

3.3 Condivisione dei nostri .jar in remoto

La realizzazione di un progetto spesso raggiunge il suo completamento conla sua distribuzione verso l’esterno. Mettiamo ad esempio il caso in cui sti-amo sviluppando una libreria che dovra essere utilizzata nell’ambito di unosviluppo collaborativo di una applicazione molto complessa: sara indispens-abile avere un repository in cui collocare l’ultima versione del nostro file jar,in modo che sia sempre disponibile per chiunque ne abbia bisogno.

Sempre all’interno del project object model possiamo specificare gli indi-rizzi per effettuare il deploy verso un repository esterno delle nostre librerie:

<distributionManagement><repository><id>Hello</id><name>Hello</name><url>scp://"repository-url"</url>

</repository></distributionManagement>

Eseguendo da terminale il comando:

:˜$ mvn deploy

10

Maven si preoccupera di copiare tutti i file del nostro progetto all’interno delrepository remoto, pronti per essere scaricati e riutilizzati in altri progetti.

Ovviamente e necessario avere un accesso ssh sulla macchina in cuivogliamo effettuare il deploy del nostro artefatto ed i permessi di scritturanella cartella di destinazione.

Se invece vogliamo costruire un sito di base per il nostro progetto, pos-siamo ricorrere all’utilizzo del comodissimo site plugin, che si occupera dicreare l’html necessario e di collocarlo nella destinazione da noi specificata,come possiamo vedere in figura 3.

Figura 3: la pagina plugin del nostro sito

Aggiungendo rispettivamente al pom.xml e al file $HOME/.m2/settings.xmlle seguenti righe:

<distributionManagement><site><id>Hello</id><url>scp://"site-url"</url>

</site></distributionManagement>

<servers><server><id>SERVER</id><username>USERNAME_ON_REMOTE_SERVER</username><password>PASSWORD_ON_REMOTE_SERVER</password><filePermissions>664</filePermissions><directoryPermissions>775</directoryPermissions>

</server></servers>

11

bastera lanciare il comando

:˜$ mvn site site:deploy

per veder creato un sito completo come, appunto, quello in figura 3.

3.4 Creazione di una “libreria” e suo riutilizzo in un altroprogetto

Vediamo adesso come si fa per creare una “libreria” java e riutilizzarla inun altro progetto Maven , in modo da addentrarci un po’ nell’idea di svilup-po distribuito di una applicazione. Abbiamo messo le virgolette alla parolalibreria in quanto il nostro file jar che andremo a riutilizzare conterra, persemplicita, una sola classe.

Creiamo quindi un nuovo progetto Maven , con il consueto comando:

:˜$ mvn archetype:create -DgroupId=it.tel.example -DartifactId=HelloLib

Entriamo nella root del nostro progetto e cambiamo il nome della nostraclasse da App a HelloLib:

:˜$ cd src/main/java/it/tel/example/:˜$ mv App.java HelloLib.java

Ed editiamo il file HelloLib.java in modo che contenga il seguente codice:

package it.tel.example;import java.lang.String;

public class HelloLib{String stringa;public HelloLib(){}public HelloLib(String s){this.stringa = s;StringBuffer b = new StringBuffer(s.length());for (int i = s.length() - 1; i >= 0; i--) {b.append(s.charAt(i));

}System.out.println("Rovescia="+b);

}}

Ossia una semplice classe che altro non fa che prendere la stringa che glipassiamo al momento dell’istanziazione e stamparla sullo standard outputal rovescio.

12

Facciamo il pacchetto jar con il comando:

:˜$ mvn package

e poi installiamolo nel nostro repository locale con:

:˜$ mvn install

Abbiamo quindi a disposizione una classe con cui fare qualche prova:riprendiamo in mano il nostro progetto precedente ed apportiamo alcunemodifiche.

Innanzitutto modifichiamo il file Hello.java per includere la classeappena creata e chiamare il costruttore, rendendolo quindi cosı:

package it.tel.example;import it.tel.example.HelloLib;

public class App{

public static void main( String[] args ){System.out.println( "Dritto=Hello World!" );HelloLib p = new HelloLib("Hello World!");

}}

Quindi dobbiamo aggiungere al nostro file pom.xml il package HelloLibcome dipendenza:

<dependencies>....<dependency><groupId>it.tel.example</groupId><artifactId>HelloLib</artifactId><version>1.0-SNAPSHOT</version>

</dependency>....

</dependencies>

A questo punto abbiamo fatto tutte le operazioni necessarie per effet-tuare la nostra compilazione, e quindi possiamo lanciare il comando per lacreazione del pacchetto:

:˜$ mvn package

13

Se non abbiamo sbagliato nulla, dovrebbe essere reperibile nella cartellatarget il file Hello-1.0-SNAPSHOT.jar impacchettato e pronto alla redis-tribuzione. Ancora pero non e possibile eseguire il nostro jar, in quantoquello che Maven fa al momento della compilazione, purtroppo, non avvienea runtime.

La dipendenza esplicitata non e infatti contenuta veramente nel pacchet-to, ma puo comunque essere inserita andando, ancora una volta, ad effettuareuna semplice modifica al file pom.xml: aggiungendo infatti le seguenti righe

<build><plugins><plugin><artifactId>maven-assembly-plugin</artifactId><configuration>

<descriptorRefs><descriptorRef>jar-with-dependencies</descriptorRef>

</descriptorRefs><archive><manifest>

<mainClass>it.tel.example.Hello</mainClass></manifest>

</archive></configuration><executions>

<execution><id>make-assembly</id><phase>package</phase><goals>

<goal>attached</goal></goals>

</execution></executions>

</plugin></plugins>

</build>

diciamo a Maven , al momento del packaging, di utilizzare il plugin as-sembly, che ci consente di creare un pacchetto della nostra applicazione conil suffisso jar-with-dependencies che contiene al suo interno tutte gli altrifile jar che abbiamo incluso in precedenza, in modo da rendere lo stessoeseguibile.

Non ci resta quindi che lanciare il classico

:˜$ mvn package

14

Figura 4: La nostra prima applicazione con dipendenze!

per poter poi vedere in funzione la nostra applicazione con le dipendenzeincluse. Ovviamente sara necessario lanciare il comando

:˜$ java -cp target/Hello-1.0-SNAPSHOT-jar-with-dependencies.jarit.tel.example.App

4 Integrazione con svn

Adesso che abbiamo imparato come creare i nostri progetti Maven , comegestirne le dipendenze e come condividere i nostri pacchetti con il mondoesterno, andiamo a scoprire un modo per poter sviluppare in piu persone ilsolito progetto: utilizziamo subversion.

4.1 Come creare un repository

Innanzitutto creiamo il nostro repository ed aggiungiamo i file del progetto:

:˜$ cd $HOME/Hello:˜$ svn import . url-to-svn/Hello/trunk -m ’initial import’:˜$ cd ..:˜$ mv Hello Hello.back:˜$ svn co svn://url-to-svn/Hello/trunk Hello

15

In pratica abbiamo aggiunto i nostri file ad un repository, spostato la cartel-la del progetto in una cartella di backup (per metterci al sicuro da eventualimalfunzionamenti) e quindi riscaricato sulla nostra macchina una versionedell’applicazione stavolta sotto il controllo di versione.

A questo punto dobbiamo aggiungere al file pom.xml le istruzioni neces-sarie affinche Maven possa accedere al repository svn:

<scm><connection>scm:svn:url-to-svn/Hello/trunk/</connection><developerConnection>"" "" "" "" ""</developerConnection>

</scm>

Oltre che aggiungere sempre al solito file l’indicazione di utilizzare ilplugin scm, ossia il plugin deputato da Maven alla gestione dell’integrazionedel nostro progetto con subversion:

<build>....<plugins><plugin>

<groupId>org.apache.maven.plugins</groupId><artifactId>maven-scm-plugin</artifactId><version>1.0-SNAPSHOT</version><configuration><connectionType>developerConnection</connectionType>

</configuration></plugin>

</plugins....

</build>

A questo punto bastera lanciare il comando:

:˜$ mvn scm:update

ogni qual volta vorremmo aggiornare la nostra versione del progetto all’ul-tima contenuta nel repository, e viceversa lanciare il comando:

:˜$ mvn -Dmessage=commit-log-here scm:checkin

quando vorremo fare il commit delle ultime modifiche da noi apportate aisorgenti.

16

4.2 Creare tag e branch con il minimo sforzo

Nell’utilizzare Maven e subversion ad un livello un po’ piu avanzato, ci tro-viamo di fronte a molteplici criticita: come possiamo gestire la creazione ditag e la generazione di branche di sviluppo diverse dal flusso principale? C’eun plugin che ci aiuta a risparmiare un po’ di noioso lavoro manuale? Anchein questo caso, Maven ci viene in aiuto!

Prima di entrare nei dettagli pratici, tuttavia, facciamo un breve excursussu quella che e la struttura ‘classica’ di un progetto sotto controllo di versionecon subversion.

All’interno della nostra cartella versionata avremo, tipicamente, variedirectory:

• trunk, ‘il tronco’, ossia il flusso principale di sviluppo, in cui e presentela versione piu aggiornata del nostro progetto. Solitamente si cercadi mantenere il materiale presente in questa cartella il piu possibilefunzionante, evitando di effettuare commit di feature non testate chepotrebbero inficiarne la compilazione o l’utilizzo da parte di un utentefinale.

• branches, ‘i rami’, con al suo interno altre cartelle, che contengonodelle derivazioni dal flusso di sviluppo principale. Tipicamente vienecreato un nuovo branch ogni qual volta si intende inserire all’internodel nostro software delle features nuove, che possono inficiare il correttofunzionamento del resto del progetto. In questo caso quindi si effettuaun fork dal trunk e si continua a sviluppare in parallelo, fino a che, unavolta ultimato il nostro lavoro, non si effettua un merge con il trunkstesso. Spesso sono utilizzati branch anche in progetti a cui partecipanosviluppatori poco accreditati, in modo da poter permettere anche aloro di apportare modifiche e migliorie al nostro software salvo esseresottoposti ad un giudizio dei manteiner del progetto prima di vederaggiunto al trunk il proprio lavoro.

• tags, ‘le etichette’, sono un modo per ‘fissare’ definitivamente unarevisione che ha un significato particolare, ad esempio il primo rilasciodi un progetto. Per non doversi ricordare il numero di revisione, si puoetichettare (appunto) la revisione con un nome specifico che risultimnemonico per noi.

Risulta quindi subito chiaro come effettuare operazioni quali la creazionedi branches o il rilascio di una versione taggata, se effettuate direttamenteda Maven , possono risultare molto piu veloci e pratiche.

Vediamo adesso come far funzionare il tutto: per prima cosa dobbiamodire a Maven di utilizzare il Maven-release-plugin, quindi andiamo adaggiungere, come sempre, le seguenti righe nel pom.xml:

17

<plugins>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-release-plugin</artifactId>

<version>2.0-beta-7</version>

<configuration>

<tagBase>https://svn.apache.org/repos/asf/maven/components/releases</tagBase>

</configuration>

</plugin>

</plugins>

Adesso che abbiamo dichiarato l’uso del plugin, possiamo lanciamo nel ter-minale:

:˜$ mvn release:prepare -DdryRun=true

Maven effettuera un primo ciclo, definiamolo di test, un cui possiamo verifi-care se abbiamo fatto tutto bene. A questo punto siamo pronti per creare ilnostro primo tag! Eseguiamo il seguente comando:

:˜$ mvn release:prepare -Dusername=username -Dpassword=passwd

Come possiamo vedere, Maven ha effettuato il commit di un tag con unaversione non-snapshot del nostro progetto e ha allo stesso tempo incremen-tato tutte le nostre versioni al release seguente. Ad esempio, se nel nostropom.xml abbiamo specificato 0.5.0-SNAPSHOT come versione, Maven ha ef-fettuato il commit di un tag con versione 0.5.0 e aggiornato il pom.xml deltrunk inserendo il numero successivo, ossia 0.5.1-SNAPSHOT. Ovviamente,quando utilizziamo il goal prepare, ci vengono richiesti i numeri di versioneattuale e successivo desiderati.

E’ possibile a questo punto effettuare il deploy della release e di un even-tuale sito, utilizzando il comando:

:˜$ mvn release:perform

Per creare un nuovo branch, invece, possiamo eseguire:

:˜$ mvn -DupdateBranchVersions=true –batch-mode release:branch

5 Maven2 e gli IDE

In questa sezione daremo una rapida occhiata a come fare ad utilizzareMaven insieme a tutte le comodita che il nostro IDE preferito ci mette a dis-posizione. In particolare, focalizzeremo la nostra attenzione sull’integrazione

18

di Maven con Eclipse e con Netbeans, i due IDE al momento piu diffusi almondo.

5.1 Integrazione con Eclipse

Il primo passo per far lavorare assieme Maven ed eclipse e ovviamente instal-lare il plugin apposito, reperibile sul sito http://www.m2eclipse.codehaus.org

Una volta installato il plugin, il secondo passo e quello di creare un nuovoprogetto Maven con il comando ‘Nuovo’ di eclipse. Nella prima pagina delwizard che compare selezioniamo, sotto la voce Maven, Maven project eandiamo avanti.

Figura 5: Creare un progetto maven da eclipse

Mettiamo una spunta all’opzione Create a simple project ed andi-amo ancora avanti. Ci troveremo di fronte ad una schermata come presen-tata in figura 5, in cui inseriremo i dati del progetto che vogliamo andare acreare. Metteremo quindi it.tel.example nel campo dedicato al Group id,Eclipse in quello dedicato a all’Artifact id e cosı via.

A questo punto non ci resta altro che cliccare su finish per far si cheEclipse crei il nostro nuovo progetto Maven , occupandosi di generare il filepom.xml, la classe java di base e tutto il resto.

19

Da adesso in poi sara possibile modificare dal nostro IDE non soltan-to i sorgenti java, ma anche il pom.xml con una comoda interfaccia, comepossiamo vedere in figura 6.

Figura 6: L’intuitivo editor del file pom.xml che eclipse ci mette a disposizione

5.2 Integrazione con Netbeans

Vediamo ora come fare a lavorare ad un progetto Maven all’interno dell’IDENetbeans, importando un progetto creato con il plugin archetype.

Per prima cosa, quindi, creiamo il nostro progetto Maven con il solitocomando:

:˜$ mvn archetype:create -DgroupId=it.tel.example -DartifactId=Hello

A questo punto, e necessario far si che Netbeans veda il nostro progettoappena creato: utilizziamo quindi il Netbeans Freeform project type, ovvi-amente dopo essere entrati nella directory del progetto.

:˜$ cd $HOME:˜$ mvn netbeans-freeform:generate-netbeans-project

Come possiamo vedere, e stata creata una cartella, nbproject, che con-tiene tre file necessari per poter lavorare da Netbeans sul nostro progettoMaven :

• project.xml: descrittore del progetto Netbeans freeform

20

• mavencall.xml: gestore delle chiamate Ant che eseguono Maven , datoche Netbeans utilizza Ant come strumento di build

• project.properties: file che gestisce due proprieta: local.repositoryche indica il path assoluto verso il repository Maven locale e project.directoryche contiene il path assoluto verso la directory ospitante il progetto

A questo punto siamo pronti per aprire il nostro IDE: lanciamo Netbeanse importiamo il progetto Maven appena creato, selezionando la voce di menufile --> open project e cliccando sulla cartella Hello.

Se tutto e andato a buon fine, sara adesso visibile una schermata comequella illustrata in figura 7, da cui sara possibile interagire col nostro pro-getto direttamente dalla schermata di Netbeans.

Figura 7: Il progetto Maven visto con gli occhi di Netbeans

Netbeans mette a disposizione molte shortcut per velocizzare il lavoro,ad esempio e possibile effettuare il build del nostro progetto premendo lashortcut F11, oppure eseguirlo premendo F6.

E’ inoltre possibile aggiungere alcune viste aggiuntive nella finestra delprogetto, ad esempio come aggiungere una voce nel menu contestuale pereseguire in maniera rapida un goal: sara sufficiente aggiugere, come al solito,alcune righe al nostro pom.xml:

21

<build>...<plugins><plugin>

<groupId>org.codehaus.mojo</groupId><artifactId>netbeans-freeform-maven-plugin</artifactId><version>2.0</version><configuration><additionalGoals>source:jar</additionalGoals>

</configuration></plugin>

</plugins>...

</build>

E aggiornare la vista del progetto, selezionando l’azione Refresh projectdal menu contestuale.

22