Construção Automática Maven

Automated build defines such a scenario: after a project is successfully built, its related dependent projects start building, which can ensure the stability of the dependent projects.

for example, a team is developing a project bus-core-api, and there are other two projects app-web-ui e app-desktop-the ui depends on this project.

app-web-the ui project uses the bus-core-the api project 1.0 snapshot:

<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-the ui project uses the bus-core-the api project 1.0 snapshot:

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

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

now the app-web-ui e app-desktop-the ui project team requires regardless of the bus-core-when the api project changes, their build process should also be able to start.

Using snapshots can ensure the latest bus-core-the api project is used, but to meet the above requirements, we still need to do some additional work.

There are two ways to use:

• in the bus-core-add a post in the pom file of the api project-build a target operation to start the app-web-ui e app-desktop-The build of the ui project.

• Use a continuous integration (CI) server, such as Hudson, to manage build automation manually.

Use Maven

Modify bus-core-The pom.xml file of the api 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>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>

Open the command console, switch to C:\ > MVN > bus-core-Under the api directory, then execute the following command.

C:\MVN\bus-core-api>mvn clean package　-U

After executing the command, Maven will start building the project bus-core-api。

[INFO] Scanning for projects...
[INFO]　------------------------------------------------------------------
[INFO] Building bus-core-api
[INFO] task-segment: [clean, package]
[INFO]　------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-}
[INFO] Building jar: C:\MVN\bus-core-ui\target\
bus-core-ui-1.0-SNAPSHOT.jar
[INFO]　------------------------------------------------------------------
[INFO] CONSTRUÇÃO BEM-SUCEDIDA
[INFO]　------------------------------------------------------------------

bus-core-Após a construção bem-sucedida do api, o Maven começará a construir o app-web-projeto ui.

[INFO]　------------------------------------------------------------------
[INFO] Construção de app-web-ui　
[INFO] task-segment: [package]
[INFO]　------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-}
[INFO] Construção de jar: C:\MVN\app-web-ui\target\
app-web-ui-1.0-SNAPSHOT.jar
[INFO]　------------------------------------------------------------------
[INFO] CONSTRUÇÃO BEM-SUCEDIDA
[INFO]　------------------------------------------------------------------

app-web-Após a construção bem-sucedida da ui, o Maven começará a construir o app-desktop-projeto ui.

[INFO]　------------------------------------------------------------------
[INFO] Construção de app-desktop-ui　
[INFO] task-segment: [package]
[INFO]　------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-}
[INFO] Construção de jar: C:\MVN\app-desktop-ui\target\
app-desktop-ui-1.0-SNAPSHOT.jar
[INFO]　-------------------------------------------------------------------
[INFO] CONSTRUÇÃO BEM-SUCEDIDA
[INFO]　-------------------------------------------------------------------

Usando Servidor de Integração Contínua (CI)

Se usar um servidor CI, cada novo projeto que criamos, por exemplo, o app no exemplo-mobile-ui, adicionando como dependência o bus-core-ao criar o projeto api, os desenvolvedores não precisam atualizar o bus-core-pom do projeto api. O Hudson usará a função de gestão de dependências do Maven para implementar a criação automática do projeto.

O Hudson trata cada construção de projeto como uma tarefa. Após o código do projeto ser submetido ao SVN (ou qualquer ferramenta de gerenciamento de código mapeada ao Hudson), o Hudson começa a tarefa de construção do projeto e, assim que a tarefa de construção for concluída, o Hudson automaticamente inicia outras tarefas de construção dependentes (construção de projetos dependentes).

No exemplo acima, quando o bus-core-Após a atualização do código-fonte ui no SVN, o Hudson começa a construção do projeto. Assim que a construção for bem-sucedida, o Hudson automaticamente busca os projetos dependentes e começa a construção do app-web-ui e app-desktop-projeto ui.