Maven - Costruisci automazione

Build Automation definisce lo scenario in cui il processo di compilazione dei progetti dipendenti viene avviato una volta che la compilazione del progetto è stata completata con successo, al fine di garantire che i progetti dipendenti siano stabili.

Example

Considera che una squadra sta sviluppando un progetto bus-core-api su cui altri due progetti app-web-ui e app-desktop-ui sono dipendenti.

app-web-ui il progetto sta usando 1.0-SNAPSHOT di bus-core-api progetto.

<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 il progetto sta usando 1.0-SNAPSHOT di bus-core-api progetto.

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

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

Ora, squadre di app-web-ui e app-desktop-ui i progetti richiedono che il loro processo di compilazione inizi ogni volta bus-core-api modifiche al progetto.

Utilizzando snapshot, garantisce che l'ultima bus-core-api project dovrebbe essere usato ma per soddisfare il requisito di cui sopra dobbiamo fare qualcosa in più.

Possiamo procedere con i seguenti due modi:

Aggiungi un obiettivo post-build in bus-core-api pom al calcio d'inizio app-web-ui e app-desktop-ui costruisce.
Utilizza un server Continuous Integration (CI) come Hudson per gestire automaticamente l'automazione della build.

Utilizzando Maven

Aggiornare bus-core-api progetto 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>

Apriamo la console dei comandi, vai al file C:\ > MVN > bus-core-api directory ed eseguire quanto segue mvn comando.

>mvn clean package -U

Maven inizierà a costruire il progetto 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] ------------------------------------------------------------------

Una volta bus-core-api build ha successo, Maven inizierà a costruire il file app-web-ui progetto.

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

Una volta app-web-ui build ha successo, Maven inizierà a costruire il file app-desktop-ui progetto.

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

Utilizzo del servizio di integrazione continua con Maven

L'utilizzo di un server CI è preferibile agli sviluppatori. Non è necessario aggiornare il filebus-core-api progetto, ogni volta che viene aggiunto un nuovo progetto (ad esempio, app-mobile-ui), come progetto dipendente da bus-core-apiprogetto. Hudsion è uno strumento di integrazione continua scritto in java, che in un contenitore servlet, come Apache tomcat e il server delle applicazioni glassfish. Hudson gestisce automaticamente l'automazione della compilazione utilizzando la gestione delle dipendenze di Maven. La seguente istantanea definirà il ruolo dello strumento Hudson.

Hudson considera ogni progetto realizzato come lavoro. Una volta che il codice di un progetto è stato archiviato su SVN (o qualsiasi strumento di gestione del codice sorgente mappato su Hudson), Hudson avvia il suo lavoro di compilazione e una volta completato questo lavoro, avvia automaticamente altri lavori dipendenti (altri progetti dipendenti).

Nell'esempio sopra, quando bus-core-uiil codice sorgente viene aggiornato in SVN, Hudson inizia la sua compilazione. Una volta completata la compilazione, Hudson cerca automaticamente i progetti dipendenti e inizia a creareapp-web-ui e app-desktop-ui progetti.