Il Blog di Fabio Collini: blog2j


Maven è uno strumento che permette di organizzare la propria applicazione in modo standard sfruttando pattern conosciuti. In pratica può essere usato al posto di Ant per compilare, creare un pacchetto jar o war ed effettuare il deploy di un'applicazione, ma può essere sfruttato per molte altre sue funzionalità. Usando Maven abbiamo molti vantaggi:

• standardizzazione della struttura di un progetto sfruttando pattern ormai consolidati, per esempio i sorgenti delle classi, dei test e dei file di properties sono nello stesso progetto ma in directory diverse;
• compilazione, test e esportazione automatizzate;
• gestione e download automatico dei jar delle varie librerie necessarie allo sviluppo;
• creazione in automatico di un semplice sito di gestione contenente informazioni sul progetto e vari report.

Maven ha una architettura modulare e può essere esteso facilmente con dei plugin. In questo breve howto vedremo come creare una Applicazione Web all'interno di Eclipse, già presente sulla nostra macchina, nella versione con WTP. E' disponibile il codice sorgente dell'esempio mostrato, per importarlo all'interno di Eclipse è necessario scompattare il file all'interno del Workspace e eseguire il comando Import -> Maven Projects.

Il primo passo è installare il plugin di Maven per Eclipse, il sito ufficiale è m2Eclipse.codehaus.org, da poco tempo è diventato un progetto in incubation phase all'interno di Eclipse.

Una volta installato il plugin creiamo un nuovo Maven Project con il comando Nuovo di Eclipse. Nella prima pagina del Wizard che compare selezioniamo Create a simple project e andiamo avanti. Nella successiva pagina scegliamo il group id e l'artifact id che insieme identificano univocamente il progetto, impostiamo come packaging pom e clicchiamo su finish. Viene creato il progetto all'interno del Workspace contenente anche un file pom.xml con all’interno tutta la configurazione utilizzata da Maven. Questo file comprende sia campi descrittivi sia informazioni che verranno utilizzati per eseguire dei comandi. 


 

Il progetto appena creato è in realtà un contenitore di moduli di Maven che corrispondono a loro volta a progetti di Eclipse, per questo motivo lo abbiamo scelto come packaging pom, in quanto questo progetto non conterrà codice e quindi non dovrà essere creato un jar corrispondente. Aggiungiamo due moduli al progetto tramite il comando New selezionando Maven Module. In questo caso impostiamo nome del modulo, parent project e selezioniamo create a simple project.




  
Il successivo modulo da creare è una Web Application, lo creiamo nel modo appena visto ma stavolta non selezioniamo Create a simple project. Nella successiva finestra ci viene chiesto di scegliere un archetype.


 
Un archetype è un template di progetto definibile in Maven, in questo caso selezioniamo Maven-archetype-webapp che ci permette di creare un dynamic web project di Eclipse e clicchiamo su finish. Abbiamo così creato due moduli, il primo contiene il codice java di business dell'applicazione mentre il secondo è la Web Application che contiene le pagine e usa il modulo di business. Per impostare questa dipendenza fra i due moduli usiamo il comando Maven -> Add dependency disponibile nel menù contestuale del progetto web. Sempre con questo comando possiamo delegare a Maven la gestione delle librerie necessarie allo sviluppo. Infatti, nella finestra che compare, si possono selezionare le librerie che si vogliono utilizzare da un lungo elenco di librerie disponibili. Cliccando su “ok”, Maven si occuperà di scaricare i jar di tutte le librerie specificate (e di quelle da cui queste librerie dipendono) e di aggiungerle nel class path. 

 
Se per effettuare un debug approfondito abbiamo bisogno dei sorgenti delle librerie scaricate, con Maven basta eseguire dal menù contestuale il comando Maven -> Download Sources. Dopo l'esecuzione di questo comando aprendo una classe contenuta in un jar sarà mostrato il codice sorgente corrispondente. 

Iniziamo a scrivere un po' di codice java all'interno del progetto, seguiamo la convenzione di Maven per cui i sorgenti devono essere salvati nella directory src/main/java. Per esempio creiamo una classe di utilità che contiene un metodo che inverte i caratteri di una stringa: 

public class StringUtils {

        public static String reverse(String s) {
                if (s == null || s.length() < 2)
                        return s;
                StringBuffer b = new StringBuffer(s.length());
                for (int i = s.length() - 1; i >= 0; i--) {
                        b.append(s.charAt(i));
                }
                return b.toString();
        }
}


Creiamo anche un test realizzato con Junit all'interno della directory src/test/java in cui verifichiamo la classe StringUtils. Questo test usa la versione 4 della libreria Junit che può essere aggiunta facilmente sfruttando il comando add dependency.
Per impostare la versione di java da usare (in questo caso la 5) aggiungiamo la seguente configurazione nel file pom.xml:
       
<build>
                <plugins>
                        <plugin>
                                <groupId>org.apache.maven.plugins</groupId>
                                <artifactId>Maven-compiler-plugin</artifactId>
                                <configuration>
                                        <source>1.5</source>
                                        <target>1.5</target>
                                </configuration>
                        </plugin>
                </plugins>
</build>

Il codice sorgente del test è il seguente:

public class StringUtilsTest {

        @Test
        public void testReverseAb() {
                assertEquals("ba", StringUtils.reverse("ab"));
        }
       
        @Test
        public void testReverseAbc() {
                assertEquals("cba", StringUtils.reverse("abc"));
        }

        @Test
        public void testReverseAbcd() {
                assertEquals("dcba", StringUtils.reverse("abcd"));
        }

}

Adesso siamo pronti a lanciare tutti i test del progetto (che nel nostro caso si riducono ad uno), con il tasto destro selezioniamo Run As -> Maven test. Così facendo abbiamo lanciato un goal di Maven. I goal disponibili sono molti, in pratica l'esecuzione di un goal può essere considerata l'equivalente di una esecuzione di un task di ant. In questo caso l'esecuzione del goal ha prodotto alcuni file all'interno della directory target. In particolare sono state compilate le classi necessarie e sono stati creati dei file in cui viene loggato il risultato del test (lo stesso risultato che viene stampato nella console di Eclipse).

Analizziamo un goal di Maven molto interessante, la creazione del sito web di un progetto. Il sito generato è statico costituito da pagine html, contiene sia pagine che descrivono il progetto sia report per analizzare il codice. Per esempio aggiungiamo all'interno del file pom.xml alcune impostazioni per poter lanciare alcuni report:

        <reporting>
                <plugins>
                        <plugin>
                                <groupId>org.apache.maven.plugins</groupId>
                                <artifactId>maven-surefire-report-plugin</artifactId>
                        </plugin>
                        <plugin>
                                <groupId>org.apache.maven.plugins</groupId>
                                <artifactId>maven-checkstyle-plugin</artifactId>
                        </plugin>
                        <plugin>
                                <groupId>org.apache.maven.plugins</groupId>
                                <artifactId>maven-jxr-plugin</artifactId>
                        </plugin>
                        <plugin>
                                <groupId>org.apache.maven.plugins</groupId>
                                <artifactId>maven-pmd-plugin</artifactId>
                        </plugin>
                        <plugin>
                                <groupId>org.codehaus.mojo</groupId>
                                <artifactId>jdepend-maven-plugin</artifactId>
                        </plugin>
                        <plugin>
                                <groupId>org.codehaus.mojo</groupId>
                                <artifactId>taglist-maven-plugin</artifactId>
                        </plugin>
                        <plugin>
                                <groupId>org.codehaus.mojo</groupId>
                                <artifactId>cobertura-maven-plugin</artifactId>
                        </plugin>
                        <plugin>
                                <groupId>org.codehaus.mojo</groupId>
                                <artifactId>findbugs-maven-plugin</artifactId>
                                <version>1.1.1</version>
                        </plugin>
                </plugins>
        </reporting>

Lanciamo la creazione del sito web eseguendo il goal site, click con il tasto destro sul progetto e poi Rus As -> Maven build... specificando site nel campo goals. Alla fine dell'esecuzione del goal abbiamo all'interno della directory target/site il sito web del nostro progetto.  Il menù principale contiene due sezioni, la prima  include informazioni generali sul progetto, la seconda i report che abbiamo impostato nel file pom.xml.

In particolare abbiamo i seguenti report:
•    Checkstyle: informazioni su utilizzi non standard di java (if senza parentesi graffe, mancanza di commenti e cose simili);
•    Cobertura: tool che analizza le classi java del progetto cercando codice non coperto con i test. Nel nostro caso si nota che un if all'interno del metodo reverse non è coperto da test;



•    PMD's Copy/Paste Detector: segnala parti di codice creati con copia incolla;
•    FindBugs: analizza il codice segnalando possibili bug;
•    JDepend: genera un report sul design delle classi in modo da capire le dipendenze fra package e classi;
•    Maven Surefire Report: report che mostra l'esito dei test evidenziando eventuali test con errori;
•    PMD: report che segnala possibili bug, codice non usato, if non necessari, codice non ottimale (per esempio l'uso di String e non di StringBuffer) e simili;
•    Source Xref: codice java di tutte le classi java riportate in pagine html;
•    Tag list: elenco di tutti i tag TODO presenti nel codice.

Adesso che abbiamo la nostra applicazione web non ci resta che creare il war per distribuirlo, per farlo basta lanciare, con il comando Run As dal menù contestuale del progetto principale, il goal package. Creando il file war con Maven e non con il comando export di Eclipse si ha il vantaggio che le classi di test non vengono esportate.

In questo esempio abbiamo visto solo una piccola parte di quello che può offrire Maven, per approfondire l'argomento è disponibile una versione online del libro Maven: The Definitive Guide.