Maven - Guia Rápido

O que é Maven?

Maven é uma ferramenta de gerenciamento e compreensão de projetos que fornece aos desenvolvedores uma estrutura completa de ciclo de vida de construção. A equipe de desenvolvimento pode automatizar a infraestrutura de construção do projeto em quase nenhum momento, pois o Maven usa um layout de diretório padrão e um ciclo de vida de construção padrão.

No caso de ambiente com várias equipes de desenvolvimento, o Maven pode configurar a maneira de trabalhar de acordo com os padrões em um tempo muito curto. Como a maioria das configurações do projeto são simples e reutilizáveis, o Maven facilita a vida do desenvolvedor ao criar relatórios, verificações, construir e testar configurações de automação.

O Maven fornece aos desenvolvedores maneiras de gerenciar o seguinte -

• Builds
• Documentation
• Reporting
• Dependencies
• SCMs
• Releases
• Distribution
• Lista de correio

Para resumir, o Maven simplifica e padroniza o processo de construção do projeto. Ele lida com compilação, distribuição, documentação, colaboração em equipe e outras tarefas perfeitamente. O Maven aumenta a capacidade de reutilização e cuida da maioria das tarefas relacionadas à construção.

Evolução Maven

O Maven foi originalmente projetado para simplificar os processos de construção no projeto Jakarta Turbine. Havia vários projetos e cada projeto continha arquivos de construção ANT ligeiramente diferentes. Os JARs foram verificados no CVS.

O grupo Apache então desenvolveu Maven que pode construir vários projetos juntos, publicar informações de projetos, implantar projetos, compartilhar JARs em vários projetos e ajudar na colaboração de equipes.

Objetivo

O objetivo principal do Maven é fornecer ao desenvolvedor o seguinte -

• Um modelo abrangente para projetos, que pode ser reutilizado, mantido e mais fácil de compreender.

• Plugins ou ferramentas que interagem com este modelo declarativo.

A estrutura e o conteúdo do projeto Maven são declarados em um arquivo xml, pom.xml, referido como Project Object Model (POM), que é a unidade fundamental de todo o sistema Maven. Em capítulos posteriores, explicaremos o POM em detalhes.

Convenção sobre configuração

Maven usa Convention sobre Configuration, o que significa que os desenvolvedores não precisam criar eles próprios o processo de construção.

Os desenvolvedores não precisam mencionar todos os detalhes de configuração. O Maven fornece um comportamento padrão sensato para projetos. Quando um projeto Maven é criado, o Maven cria uma estrutura de projeto padrão. O desenvolvedor só precisa colocar os arquivos de acordo e não precisa definir nenhuma configuração em pom.xml.

Como exemplo, a tabela a seguir mostra os valores padrão para arquivos de código-fonte do projeto, arquivos de recursos e outras configurações. Assumindo,${basedir} denota a localização do projeto -

Item	Padrão
Código fonte	$ {basedir} / src / main / java
Recursos	$ {basedir} / src / main / resources
Testes	$ {basedir} / src / test
Código de byte cumprido	$ {basedir} / alvo
JAR distribuível	$ {basedir} / target / classes

Para construir o projeto, o Maven oferece aos desenvolvedores opções para mencionar os objetivos do ciclo de vida e as dependências do projeto (que dependem dos recursos do plugin Maven e de suas convenções padrão). Muito do gerenciamento de projetos e tarefas relacionadas à construção são mantidas pelos plug-ins Maven.

Os desenvolvedores podem construir qualquer projeto Maven sem a necessidade de entender como os plug-ins individuais funcionam. Discutiremos os plug-ins Maven em detalhes nos capítulos posteriores.

Características do Maven

• Configuração simples do projeto que segue as melhores práticas.

• Uso consistente em todos os projetos.

• Gerenciamento de dependências incluindo atualização automática.

• Um grande e crescente repositório de bibliotecas.

• Extensível, com a capacidade de escrever plug-ins facilmente em Java ou linguagens de script.

• Acesso instantâneo a novos recursos com pouca ou nenhuma configuração extra.

• Model-based builds - O Maven é capaz de construir qualquer número de projetos em tipos de saída predefinidos, como jar, war, metadata.

• Coherent site of project information - Usando os mesmos metadados do processo de construção, o maven é capaz de gerar um site e um PDF incluindo a documentação completa.

• Release management and distribution publication - Sem configuração adicional, o maven se integrará ao seu sistema de controle de origem, como o CVS, e gerenciará o lançamento de um projeto.

• Backward Compatibility- Você pode transportar facilmente os vários módulos de um projeto para o Maven 3 a partir de versões anteriores do Maven. Também pode suportar as versões mais antigas.

• Automatic parent versioning - Não há necessidade de especificar o pai no submódulo para manutenção.

• Parallel builds- Analisa o gráfico de dependência do projeto e permite construir módulos de cronograma em paralelo. Usando isso, você pode obter melhorias de desempenho de 20-50%.

• Better Error and Integrity Reporting - O Maven melhorou o relatório de erros e fornece um link para a página wiki do Maven, onde você obterá a descrição completa do erro.

O Maven é uma ferramenta baseada em Java, então o primeiro requisito é ter o JDK instalado em sua máquina.

Requisitos do sistema

JDK	1.7 ou superior.
Memória	Sem requisitos mínimos.
Espaço em disco	Sem requisitos mínimos.
Sistema operacional	Sem requisitos mínimos.

Etapa 1 - Verifique a instalação do Java em sua máquina

Abra o console e execute o seguinte java comando.

SO	Tarefa	Comando
janelas	Abrir console de comando	c: \> versão java
Linux	Abra o terminal de comando	$ java -version
Mac	Terminal aberto	máquina: ~ joseph $ java -version

Vamos verificar a saída de todos os sistemas operacionais -

SO	Resultado
janelas	versão java "1.7.0_60" Java (TM) SE Runtime Environment (build 1.7.0_60-b19) Java HotSpot (TM) Servidor VM de 64 bits (versão 24.60-b09, modo misto)
Linux	versão java "1.7.0_60" Java (TM) SE Runtime Environment (build 1.7.0_60-b19) Java HotSpot (TM) Servidor VM de 64 bits (versão 24.60-b09, modo misto)
Mac	versão java "1.7.0_60" Java (TM) SE Runtime Environment (build 1.7.0_60-b19) Java HotSpot (TM) Servidor VM de 64 bits (versão 24.60-b09, modo misto)

Se você não tiver o Java instalado, instale o Java Software Development Kit (SDK) de https://www.oracle.com/technetwork/java/javase/downloads/index.html. Estamos assumindo o Java 1.7.0.60 como a versão instalada para este tutorial.

Etapa 2 - Definir o ambiente JAVA

Colocou o JAVA_HOMEvariável de ambiente para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo -

SO	Resultado
janelas	Defina a variável de ambiente JAVA_HOME para C: \ Program Files \ Java \ jdk1.7.0_60
Linux	export JAVA_HOME = / usr / local / java-current
Mac	export JAVA_HOME = / Library / Java / Home

Anexe a localização do compilador Java ao caminho do sistema.

SO	Resultado
janelas	Anexe a string “; C: \ Arquivos de programas \ Java \ jdk1.7.0.60 \ bin” ao final da variável do sistema, Caminho.
Linux	exportar PATH =$PATH:$JAVA_HOME / bin /
Mac	não requerido

Verifique a instalação do Java usando java -version comando conforme explicado acima.

Etapa 3 - Baixe o arquivo Maven

Baixe o Maven 2.2.1 de https://maven.apache.org/download.cgi.

SO	Nome do arquivo
janelas	apache-maven-3.3.1-bin.zip
Linux	apache-maven-3.3.1-bin.tar.gz
Mac	apache-maven-3.3.1-bin.tar.gz

Etapa 4 - Extraia o arquivo Maven

Extraia o arquivo para o diretório em que deseja instalar o Maven 3.3.1. O subdiretório apache-maven-3.3.1 será criado a partir do arquivo.

SO	Localização (pode ser diferente com base na sua instalação)
janelas	C: \ Arquivos de programas \ Apache Software Foundation \ apache-maven-3.3.1
Linux	/ usr / local / apache-maven
Mac	/ usr / local / apache-maven

Etapa 5 - Definir as variáveis ​​de ambiente Maven

Adicione M2_HOME, M2, MAVEN_OPTS às variáveis ​​de ambiente.

SO	Resultado
janelas	Defina as variáveis ​​de ambiente usando propriedades do sistema. M2_HOME = C: \ Arquivos de programas \ Apache Software Foundation \ apache-maven-3.3.1 M2 =% M2_HOME% \ bin MAVEN_OPTS = -Xms256m -Xmx512m
Linux	Abra o terminal de comando e defina as variáveis ​​de ambiente. export M2_HOME = / usr / local / apache-maven / apache-maven-3.3.1 export M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m
Mac	Abra o terminal de comando e defina as variáveis ​​de ambiente. export M2_HOME = / usr / local / apache-maven / apache-maven-3.3.1 exportar M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m

Etapa 6 - Adicionar local do diretório bin do Maven ao caminho do sistema

Agora anexe a variável M2 ao caminho do sistema.

SO	Resultado
janelas	Anexe a string;% M2% ao final da variável do sistema, Caminho.
Linux	exportar PATH =$M2:$CAMINHO
Mac	exportar PATH =$M2:$CAMINHO

Etapa 7 - Verificar a instalação do Maven

Agora abra o console e execute o seguinte mvn comando.

SO	Tarefa	Comando
janelas	Abrir console de comando	c: \> mvn --version
Linux	Abra o terminal de comando	$ mvn --version
Mac	Terminal aberto	máquina: ~ joseph $ mvn --version

Finalmente, verifique a saída dos comandos acima, que devem ser os seguintes -

SO	Resultado
janelas	Apache Maven 3.3.1 (r801777; 07/08/2009 00: 46: 01 + 0530) Versão Java: 1.7.0_60 Página inicial do Java: C: \ Arquivos de programas \ Java \ jdk1.7.0_60 \ jre
Linux	Apache Maven 3.3.1 (r801777; 07/08/2009 00: 46: 01 + 0530) Versão Java: 1.7.0_60 Página inicial do Java: C: \ Arquivos de programas \ Java \ jdk1.7.0_60 \ jre
Mac	Apache Maven 3.3.1 (r801777; 07/08/2009 00: 46: 01 + 0530) Versão Java: 1.7.0_60 Página inicial do Java: C: \ Arquivos de programas \ Java \ jdk1.7.0_60 \ jre

POM significa Modelo de Objeto do Projeto. É uma unidade de trabalho fundamental no Maven. É um arquivo XML que reside no diretório base do projeto como pom.xml.

O POM contém informações sobre o projeto e vários detalhes de configuração usados ​​pelo Maven para construir o (s) projeto (s).

O POM também contém os objetivos e plug-ins. Ao executar uma tarefa ou objetivo, o Maven procura o POM no diretório atual. Ele lê o POM, obtém as informações de configuração necessárias e, em seguida, executa a meta. Algumas das configurações que podem ser especificadas no POM são as seguintes -

• dependências do projeto
• plugins
• goals
• construir perfis
• versão do projeto
• developers
• lista de correio

Antes de criar um POM, devemos primeiro decidir o projeto group (groupId), é name (artifactId) e sua versão como esses atributos ajudam a identificar exclusivamente o projeto no repositório.

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

Deve-se observar que deve haver um único arquivo POM para cada projeto.

• Todos os arquivos POM requerem o project elemento e três campos obrigatórios: groupId, artifactId, version.

• A notação de projetos no repositório é groupId:artifactId:version.

• Requisitos mínimos para um POM -

Sr. Não.	Nó e descrição
1	Project root Esta é a tag raiz do projeto. Você precisa especificar as configurações básicas do esquema, como esquema apache e especificação w3.org.
2	Model version A versão do modelo deve ser 4.0.0.
3	groupId Este é um Id do grupo do projeto. Geralmente, isso é único em uma organização ou projeto. Por exemplo, um grupo bancário com.company.bank tem todos os projetos relacionados a bancos.
4	artifactId Este é um Id do projeto. Geralmente é o nome do projeto. Por exemplo, banco de consumo. Junto com o groupId, o artifactId define a localização do artefato no repositório.
5	version Esta é a versão do projeto. Junto com o groupId, ele é usado dentro do repositório de um artefato para separar as versões umas das outras. Por exemplo - com.company.bank:consumer-banking:1.0 com.company.bank:consumer-banking:1.1.

Super POM

O Super POM é o POM padrão do Maven. Todos os POMs herdam de um pai ou padrão (apesar de explicitamente definido ou não). Este POM básico é conhecido como oSuper POMe contém valores herdados por padrão.

O Maven usa o POM efetivo (configuração do super pom mais configuração do projeto) para executar o objetivo relevante. Ajuda os desenvolvedores a especificar detalhes mínimos de configuração em seu pom.xml. Embora as configurações possam ser substituídas facilmente.

Uma maneira fácil de ver as configurações padrão do super POM é executar o seguinte comando: mvn help:effective-pom

Crie um pom.xml em qualquer diretório em seu computador. Use o conteúdo do exemplo pom mencionado acima.

No exemplo abaixo, criamos um pom.xml na pasta C: \ MVN \ project.

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvn comando.

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

O Maven iniciará o processamento e exibirá o pom efetivo.

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

O POM efetivo é exibido como resultado no console, após a aplicação de herança, interpolação e perfis.

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

No pom.xml acima, você pode ver a estrutura de pastas de origem do projeto padrão, diretório de saída, plug-ins necessários, repositórios, diretório de relatório, que o Maven usará ao executar os objetivos desejados.

Maven pom.xml também não precisa ser escrito manualmente. Maven fornece vários plug-ins de arquétipo para criar projetos, que, em ordem, criam a estrutura do projeto e pom.xml

O que é Build Lifecycle?

Um Build Lifecycle é uma sequência bem definida de fases, que definem a ordem em que os objetivos devem ser executados. Aqui, a fase representa um estágio do ciclo de vida. Por exemplo, um típicoMaven Build Lifecycle consiste na seguinte sequência de fases.

Fase	Alças	Descrição
prepare-resources	cópia de recursos	A cópia de recursos pode ser personalizada nesta fase.
validar	Validando a informação	Valida se o projeto está correto e se todas as informações necessárias estão disponíveis.
compilar	compilação	A compilação do código-fonte é feita nesta fase.
Teste	Testando	Testa o código-fonte compilado adequado para a estrutura de teste.
pacote	embalagem	Esta fase cria o pacote JAR / WAR conforme mencionado no pacote em POM.xml.
instalar	instalação	Esta fase instala o pacote no repositório maven local / remoto.
Implantar	Implantando	Copia o pacote final para o repositório remoto.

Sempre têm pre e post fases para registrar goals, que deve ser executado antes ou depois de uma fase específica.

Quando o Maven começa a construir um projeto, ele passa por uma sequência definida de fases e executa metas, que são registradas em cada fase.

O Maven tem os três ciclos de vida padrão a seguir -

• clean
• padrão (ou build)
• site

UMA goalrepresenta uma tarefa específica que contribui para a construção e gestão de um projeto. Ele pode estar limitado a zero ou mais fases de construção. Um objetivo não vinculado a nenhuma fase de construção pode ser executado fora do ciclo de vida de construção por invocação direta.

A ordem de execução depende da ordem em que o (s) objetivo (s) e as fases de construção são chamados. Por exemplo, considere o comando abaixo. oclean e package argumentos são fases de construção, enquanto o dependency:copy-dependencies é uma meta.

mvn clean dependency:copy-dependencies package

Aqui, a fase de limpeza será executada primeiro, seguida peladependency:copy-dependencies goale, finalmente , a fase do pacote será executada.

Ciclo de vida limpo

Quando executamos o comando mvn pós-limpeza , o Maven invoca o ciclo de vida de limpeza que consiste nas seguintes fases.

• pre-clean
• clean
• post-clean

A meta de limpeza do Maven (clean: clean) está vinculada à fase de limpeza no ciclo de vida limpo. Estáclean:cleangoalexclui a saída de uma construção excluindo o diretório de construção. Portanto, quando o comando mvn clean é executado, o Maven exclui o diretório de construção.

Podemos personalizar esse comportamento mencionando objetivos em qualquer uma das fases acima do ciclo de vida limpo.

No exemplo a seguir, vamos anexar maven-antrun-plugin: run goal às fases de pré-limpeza, limpeza e pós-limpeza. Isso nos permitirá ecoar mensagens de texto exibindo as fases do ciclo de vida limpo.

Criamos um pom.xml na pasta 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>

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvn comando.

C:\MVN\project>mvn post-clean

O Maven começará a processar e exibir todas as fases do ciclo de vida limpo.

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

Você pode tentar afinar mvn clean comando, que exibirá pre-cleanE limpo. Nada será executado porpost-clean fase.

Ciclo de vida padrão (ou construção)

Este é o ciclo de vida principal do Maven e é usado para construir o aplicativo. Tem as seguintes 21 fases.

Sr. Não.	Fase e descrição do ciclo de vida
1	validate Valida se o projeto está correto e todas as informações necessárias estão disponíveis para concluir o processo de construção.
2	initialize Inicializa o estado de construção, por exemplo definir propriedades.
3	generate-sources Gere qualquer código-fonte a ser incluído na fase de compilação.
4	process-sources Processe o código-fonte, por exemplo, filtre qualquer valor.
5	generate-resources Gere recursos a serem incluídos no pacote.
6	process-resources Copie e processe os recursos no diretório de destino, pronto para a fase de empacotamento.
7	compile Compile o código fonte do projeto.
8	process-classes Pós-processe os arquivos gerados a partir da compilação, por exemplo, para fazer aprimoramento / otimização de bytecode em classes Java.
9	generate-test-sources Gere qualquer código-fonte de teste a ser incluído na fase de compilação.
10	process-test-sources Processe o código-fonte de teste, por exemplo, filtre quaisquer valores.
11	test-compile Compile o código-fonte do teste no diretório de destino do teste.
12	process-test-classes Processe os arquivos gerados a partir da compilação do arquivo de código de teste.
13	test Execute testes usando uma estrutura de teste de unidade adequada (Junit é uma delas).
14	prepare-package Execute todas as operações necessárias para preparar um pacote antes da embalagem real.
15	package Pegue o código compilado e empacote-o em seu formato distribuível, como um arquivo JAR, WAR ou EAR.
16	pre-integration-test Execute as ações necessárias antes que os testes de integração sejam executados. Por exemplo, configurando o ambiente necessário.
17	integration-test Processe e implante o pacote, se necessário, em um ambiente onde os testes de integração possam ser executados.
18	post-integration-test Execute as ações necessárias após a execução dos testes de integração. Por exemplo, limpar o meio ambiente.
19	verify Execute qualquer verificação para verificar se o pacote é válido e atende aos critérios de qualidade.
20	install Instale o pacote no repositório local, que pode ser usado como uma dependência em outros projetos localmente.
21	deploy Copia o pacote final para o repositório remoto para compartilhamento com outros desenvolvedores e projetos.

Existem alguns conceitos importantes relacionados ao Maven Lifecycles, que vale a pena mencionar -

• Quando uma fase é chamada via comando Maven, por exemplo mvn compile, apenas as fases até e incluindo essa fase serão executadas.

• Diferentes objetivos do maven serão vinculados a diferentes fases do ciclo de vida do Maven, dependendo do tipo de embalagem (JAR / WAR / EAR).

No exemplo a seguir, iremos anexar maven-antrun-plugin: run goal a algumas das fases do ciclo de vida do Build. Isso nos permitirá ecoar mensagens de texto exibindo as fases do ciclo de vida.

Atualizamos pom.xml na pasta 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>

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvn comando.

C:\MVN\project>mvn compile

O Maven iniciará o processamento e exibirá as fases do ciclo de vida da construção até a fase de compilação.

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

Ciclo de Vida do Site

O plugin do site Maven é geralmente usado para criar documentação nova para criar relatórios, implantar o site, etc. Ele tem as seguintes fases -

• pre-site
• site
• post-site
• site-deploy

No exemplo a seguir, vamos anexar maven-antrun-plugin:runobjetivo para todas as fases do ciclo de vida do site. Isso nos permitirá ecoar mensagens de texto exibindo as fases do ciclo de vida.

Atualizamos pom.xml na pasta 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>

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvn comando.

C:\MVN\project>mvn site

O Maven começará a processar e exibir as fases do ciclo de vida do site até a fase do site.

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

O que é Build Profile?

Um perfil de construção é um conjunto de valores de configuração, que pode ser usado para definir ou substituir os valores padrão da construção Maven. Usando um perfil de construção, você pode customizar a construção para diferentes ambientes, como ambientes de Produção v / s Desenvolvimento.

Os perfis são especificados no arquivo pom.xml usando seus elementos activeProfiles / profiles e são acionados de várias maneiras. Os perfis modificam o POM no momento da construção e são usados ​​para fornecer aos parâmetros diferentes ambientes de destino (por exemplo, o caminho do servidor de banco de dados nos ambientes de desenvolvimento, teste e produção).

Tipos de Perfil de Construção

Perfis de construção são principalmente de três tipos.

Tipo	Onde está definido
Por Projeto	Definido no arquivo POM do projeto, pom.xml
Por usuário	Definido no arquivo xml de configurações do Maven (% USER_HOME% /. M2 / settings.xml)
Global	Definido no arquivo xml de configurações globais Maven (% M2_HOME% / conf / settings.xml)

Ativação de Perfil

Um perfil de construção Maven pode ser ativado de várias maneiras.

• Usando explicitamente a entrada do console de comando.
• Por meio de configurações de maven.
• Baseado em variáveis ​​de ambiente (variáveis ​​de usuário / sistema).
• Configurações do sistema operacional (por exemplo, família Windows).
• Arquivos presentes / ausentes.

Exemplos de ativação de perfil

Vamos supor a seguinte estrutura de diretório do seu projeto -

Agora, sob src/main/resources, existem três arquivos específicos do ambiente -

Sr. Não.	Nome e descrição do arquivo
1	env.properties configuração padrão usada se nenhum perfil for mencionado.
2	env.test.properties configuração de teste quando o perfil de teste é usado.
3	env.prod.properties configuração de produção quando o perfil de produção é usado.

Ativação explícita de perfil

No exemplo a seguir, vamos anexar maven-antrun-plugin: run goal para testar a fase. Isso nos permitirá ecoar mensagens de texto para diferentes perfis. Estaremos usando pom.xml para definir perfis diferentes e vamos ativar o perfil no console de comando usando o comando maven.

Suponha que criamos o seguinte pom.xml na pasta 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>

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvncomando. Passe o nome do perfil como argumento usando a opção -P.

C:\MVN\project>mvn test -Ptest

O Maven começará a processar e exibir o resultado do perfil de construção de teste.

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

Agora, como exercício, você pode realizar as seguintes etapas -

• Adicione outro elemento de perfil ao elemento de perfis de pom.xml (copie o elemento de perfil existente e cole-o onde os elementos de perfil terminam).

• Atualize a id deste elemento de perfil de teste para normal.

• Atualize a seção da tarefa para echo env.properties e copie env.properties para o diretório de destino.

• Repita novamente as três etapas acima, atualize a id para a seção prod e task para env.prod.properties.

• Isso é tudo. Agora você tem três perfis de construção prontos (normal / teste / prod).

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvncomandos. Passe os nomes dos perfis como argumento usando a opção -P.

C:\MVN\project>mvn test -Pnormal

C:\MVN\project>mvn test -Pprod

Verifique a saída da construção para ver a diferença.

Ativação do perfil por meio das configurações do Maven

Abra o Maven settings.xml arquivo disponível no diretório% USER_HOME% /. m2 onde %USER_HOME%representa o diretório inicial do usuário. Se o arquivo settings.xml não estiver lá, crie um novo.

Adicione o perfil de teste como um perfil ativo usando o nó Perfis ativos, conforme mostrado abaixo no exemplo.

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

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvncomando. Não passe o nome do perfil usando a opção -P. O Maven exibirá o resultado do perfil de teste sendo um perfil ativo.

C:\MVN\project>mvn test

Ativação de perfil por meio de variáveis ​​de ambiente

Agora remova o perfil ativo do maven settings.xml e atualize o perfil de teste mencionado em pom.xml. Adicione o elemento de ativação ao elemento de perfil conforme mostrado abaixo.

O perfil de teste será acionado quando a propriedade do sistema "env" for especificada com o valor "test". Crie uma variável de ambiente "env" e defina seu valor como "teste".

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

Vamos abrir o console de comando, ir para a pasta que contém pom.xml e executar o seguinte mvn comando.

C:\MVN\project>mvn test

Ativação de perfil via sistema operacional

Elemento de ativação para incluir detalhes do sistema operacional conforme mostrado abaixo. Este perfil de teste será acionado quando o sistema for 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>

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvncomandos. Não passe o nome do perfil usando a opção -P. O Maven exibirá o resultado do perfil de teste sendo um perfil ativo.

C:\MVN\project>mvn test

Ativação de perfil via arquivo presente / ausente

Agora, elemento de ativação para incluir detalhes do sistema operacional, conforme mostrado abaixo. O perfil de teste será acionado quandotarget/generated-sources/axistools/wsdl2java/com/companyname/group está desaparecido.

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

Agora abra o console de comando, vá para a pasta que contém pom.xml e execute o seguinte mvncomandos. Não passe o nome do perfil usando a opção -P. O Maven exibirá o resultado do perfil de teste sendo um perfil ativo.

C:\MVN\project>mvn test

O que é um repositório Maven?

Na terminologia do Maven, um repositório é um diretório onde todos os jars do projeto, jar da biblioteca, plug-ins ou quaisquer outros artefatos específicos do projeto são armazenados e podem ser usados ​​pelo Maven facilmente.

O repositório Maven é de três tipos. A ilustração a seguir dará uma idéia sobre esses três tipos.

• local
• central
• remote

Repositório Local

O repositório local Maven é um local de pasta em sua máquina. Ele é criado quando você executa qualquer comando maven pela primeira vez.

O repositório local Maven mantém todas as dependências do seu projeto (jars de biblioteca, jars de plug-in etc.). Quando você executa uma compilação do Maven, o Maven baixa automaticamente todos os jars de dependência para o repositório local. Isso ajuda a evitar referências a dependências armazenadas na máquina remota sempre que um projeto é construído.

O repositório local Maven por padrão é criado pelo Maven no diretório% USER_HOME%. Para substituir o local padrão, mencione outro caminho no arquivo Maven settings.xml disponível no diretório% 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>

Quando você executa o comando Maven, o Maven baixa as dependências para seu caminho personalizado.

Repositório central

O repositório central Maven é um repositório fornecido pela comunidade Maven. Ele contém um grande número de bibliotecas comumente usadas.

Quando o Maven não encontra nenhuma dependência no repositório local, ele começa a pesquisar no repositório central usando a seguinte URL - https://repo1.maven.org/maven2/

Os principais conceitos do repositório central são os seguintes -

• Este repositório é gerenciado pela comunidade Maven.
• Não é necessário configurar.
• Requer acesso à Internet para ser pesquisado.

Para navegar pelo conteúdo do repositório central maven, a comunidade maven forneceu uma URL - https://search.maven.org/#browse. Usando esta biblioteca, um desenvolvedor pode pesquisar todas as bibliotecas disponíveis no repositório central.

Repositório Remoto

Às vezes, o Maven também não encontra uma dependência mencionada no repositório central. Em seguida, ele para o processo de construção e envia uma mensagem de erro para o console. Para evitar tal situação, Maven fornece conceito deRemote Repository, que é o repositório customizado do próprio desenvolvedor que contém as bibliotecas necessárias ou outros jars de projeto.

Por exemplo, usando o POM.xml mencionado abaixo, o Maven baixará a dependência (não disponível no repositório central) dos Repositórios Remotos mencionados no mesmo 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>

Sequência de pesquisa de dependência Maven

Quando executamos comandos de construção do Maven, o Maven começa a procurar bibliotecas de dependência na seguinte sequência -

• Step 1 - Procure dependência no repositório local, se não for encontrada, vá para a etapa 2, caso contrário, execute o processamento adicional.

• Step 2 - Pesquise a dependência no repositório central, se não for encontrada e o repositório / repositórios remotos for / forem mencionados, vá para a etapa 4. Caso contrário, é baixado para o repositório local para referência futura.

• Step 3 - Se um repositório remoto não for mencionado, o Maven simplesmente interrompe o processamento e gera um erro (não foi possível encontrar dependência).

• Step 4- Pesquise a dependência em repositório ou repositórios remotos, se encontrada, ela é baixada para o repositório local para referência futura. Caso contrário, o Maven interrompe o processamento e gera um erro (não foi possível encontrar a dependência).

O que são plug-ins Maven?

O Maven é, na verdade, uma estrutura de execução de plug-ins em que todas as tarefas são realizadas por plug-ins. Os plug-ins Maven geralmente são usados ​​para -

• criar arquivo jar
• criar arquivo de guerra
• compilar arquivos de código
• teste de unidade de código
• criar documentação do projeto
• criar relatórios de projeto

Um plugin geralmente fornece um conjunto de objetivos, que podem ser executados usando a seguinte sintaxe -

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

Por exemplo, um projeto Java pode ser compilado com o objetivo de compilação do maven-compiler-plugin's, executando o seguinte comando.

mvn compiler:compile

Tipos de plug-in

Maven forneceu os seguintes dois tipos de plug-ins -

Sr. Não.	Tipo e descrição
1	Build plugins Eles são executados durante o processo de construção e devem ser configurados no elemento <build /> de pom.xml.
2	Reporting plugins Eles são executados durante o processo de geração do site e devem ser configurados no elemento <reporting /> do pom.xml.

A seguir está a lista de alguns plug-ins comuns -

Sr. Não.	Plugin e descrição
1	clean Limpa o alvo após a construção. Exclui o diretório de destino.
2	compiler Compila arquivos de origem Java.
3	surefire Executa os testes de unidade JUnit. Cria relatórios de teste.
4	jar Constrói um arquivo JAR do projeto atual.
5	war Constrói um arquivo WAR a partir do projeto atual.
6	javadoc Gera Javadoc para o projeto.
7	antrun Executa um conjunto de tarefas de formigas de qualquer fase mencionada da construção.

Example

Nós usamos maven-antrun-pluginextensivamente em nossos exemplos para imprimir dados no console. Consulte o capítulo Build Profiles. Vamos entender melhor e criar um pom.xml na pasta 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>

Em seguida, abra o console de comando e vá para a pasta que contém pom.xml e execute o seguinte mvn comando.

C:\MVN\project>mvn clean

O Maven iniciará o processamento e a exibição da fase limpa do ciclo de vida limpo.

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

O exemplo acima ilustra os seguintes conceitos-chave -

• Os plug-ins são especificados em pom.xml usando o elemento plug-ins.

• Cada plugin pode ter vários objetivos.

• Você pode definir a fase de onde o plugin deve iniciar seu processamento usando seu elemento de fase. Nós usamosclean fase.

• Você pode configurar tarefas a serem executadas vinculando-as aos objetivos do plugin. Nós ligamosecho tarefa com runobjetivo do maven-antrun-plugin .

• O Maven fará o download do plugin se não estiver disponível no repositório local e iniciará seu processamento.

Maven usa archetypeplugins para criar projetos. Para criar um aplicativo Java simples, usaremos o plugin maven-archetype-quickstart. No exemplo abaixo, criaremos um projeto de aplicativo Java baseado em maven na pasta C: \ MVN.

Vamos abrir o console de comando, ir para o diretório C: \ MVN e executar o seguinte mvn comando.

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

O Maven iniciará o processamento e criará a estrutura completa do projeto do aplicativo 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] ------------------------------------------------------------------

Agora vá para o diretório C: / MVN. Você verá um projeto de aplicativo java criado, denominado Consumer Banking (conforme especificado em artifactId). O Maven usa um layout de diretório padrão, conforme mostrado abaixo -

Usando o exemplo acima, podemos entender os seguintes conceitos-chave -

Sr. Não.	Estrutura e descrição da pasta
1	consumerBanking contém a pasta src e pom.xml
2	src/main/java contém arquivos de código java na estrutura do pacote (com / companyName / bank).
3	src/main/test contém arquivos de código Java de teste na estrutura do pacote (com / companyName / bank).
4	src/main/resources ele contém arquivos de imagens / propriedades (no exemplo acima, precisamos criar essa estrutura manualmente).

Se você observar, verá que o Maven também criou um arquivo de código-fonte Java de amostra e um arquivo de teste Java. Abra a pasta C: \ MVN \ consumerBanking \ src \ main \ java \ com \ companyname \ bank, você verá App.java.

package com.companyname.bank;

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

Abra a pasta C: \ MVN \ consumerBanking \ src \ test \ java \ com \ companyname \ bank para ver 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 );
   }
}

Os desenvolvedores devem colocar seus arquivos conforme mencionado na tabela acima e o Maven lida com todas as complexidades relacionadas à construção.

No próximo capítulo, discutiremos como construir e testar o projeto usando o maven Build and Test Project.

O que aprendemos no capítulo Criação de projeto é como criar um aplicativo Java usando Maven. Agora veremos como construir e testar o aplicativo.

Vá para o diretório C: / MVN onde você criou seu aplicativo java. AbrirconsumerBankingpasta. Você verá oPOM.xml arquivo com o seguinte conteúdo.

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

Aqui você pode ver, o Maven já adicionou o Junit como framework de teste. Por padrão, o Maven adiciona um arquivo de origemApp.java e um arquivo de teste AppTest.java em sua estrutura de diretório padrão, conforme discutido no capítulo anterior.

Vamos abrir o console de comando, vá para o diretório C: \ MVN \ consumerBanking e execute o seguinte mvn comando.

C:\MVN\consumerBanking>mvn clean package

Maven começará a construir o projeto.

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

Você construiu seu projeto e criou o arquivo jar final, a seguir estão os principais conceitos de aprendizagem -

• Damos ao maven dois objetivos, primeiro limpar o diretório de destino (limpar) e, em seguida, empacotar a saída de construção do projeto como jar (pacote).

• O jar empacotado está disponível na pasta consumerBanking \ target como consumerBanking-1.0-SNAPSHOT.jar.

• Os relatórios de teste estão disponíveis na pasta consumerBanking \ target \ surefire-reports.

• O Maven compila o (s) arquivo (s) de código-fonte e, em seguida, testa os arquivos de código-fonte.

• Em seguida, o Maven executa os casos de teste.

• Finalmente, o Maven cria o pacote.

Agora abra o console de comando, vá para o diretório C: \ MVN \ consumerBanking \ target \ classes e execute o seguinte comando java.

>java com.companyname.bank.App

Você verá o resultado da seguinte forma -

Hello World!

Adicionar arquivos de origem Java

Vamos ver como podemos adicionar arquivos Java adicionais em nosso projeto. Abra a pasta C: \ MVN \ consumerBanking \ src \ main \ java \ com \ companyname \ bank, crie a classe Util nela como Util.java.

package com.companyname.bank;

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

Atualize a classe App para usar a classe Util.

package com.companyname.bank;

/**
   * Hello world!
   *
*/

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

Agora abra o console de comando, vá para C:\MVN\consumerBanking diretório e execute o seguinte mvn comando.

>mvn clean compile

Depois que a construção do Maven for bem-sucedida, vá para o diretório C: \ MVN \ consumerBanking \ target \ classes e execute o seguinte comando java.

>java -cp com.companyname.bank.App

Você verá o resultado da seguinte forma -

Hello World!

Como você sabe, o Maven faz o gerenciamento de dependências usando o conceito de Repositórios. Mas o que acontece se a dependência não estiver disponível em nenhum dos repositórios remotos e no repositório central? Maven fornece resposta para tal cenário usando o conceito deExternal Dependency.

Por exemplo, vamos fazer as seguintes alterações no projeto criado no capítulo 'Criando projeto Java'.

• Adicionar lib pasta para a pasta src.

• Copie qualquer jar para a pasta lib. Nós usamosldapjdk.jar, que é uma biblioteca auxiliar para operações LDAP.

Agora, a estrutura do nosso projeto deve se parecer com o seguinte -

Aqui você tem sua própria biblioteca, específica para o projeto, que é um caso usual e contém jars, que podem não estar disponíveis em nenhum repositório para download do maven. Se o seu código estiver usando esta biblioteca com o Maven, a compilação do Maven falhará, pois não pode fazer download ou consultar esta biblioteca durante a fase de compilação.

Para lidar com a situação, vamos adicionar esta dependência externa ao maven pom.xml usando a seguinte maneira.

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

Observe o segundo elemento de dependência em dependências no exemplo acima, que limpa os seguintes conceitos-chave sobre External Dependency.

• Dependências externas (localização do jar da biblioteca) podem ser configuradas em pom.xml da mesma forma que outras dependências.

• Especifique groupId igual ao nome da biblioteca.

• Especifique artifactId igual ao nome da biblioteca.

• Especifique o escopo como sistema.

• Especifique o caminho do sistema relativo ao local do projeto.

Espero que agora você esteja claro sobre as dependências externas e seja capaz de especificar dependências externas em seu projeto Maven.

Este tutorial irá ensiná-lo a criar a documentação do aplicativo de uma vez. Então vamos começar, vá para o diretório C: / MVN onde você criou seu javaconsumerBankingaplicação usando os exemplos dados nos capítulos anteriores. AbrirconsumerBanking pasta e execute o seguinte mvn comando.

C:\MVN>mvn site

Maven começará a construir o projeto.

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

A documentação do seu projeto agora está pronta. O Maven criou um site dentro do diretório de destino.

Abra a pasta C: \ MVN \ consumerBanking \ target \ site. Clique em index.html para ver a documentação.

O Maven cria a documentação usando um mecanismo de processamento de documentação chamado Doxia, que lê vários formatos de origem em um modelo de documento comum. Para escrever documentação para seu projeto, você pode escrever seu conteúdo nos seguintes formatos comumente usados ​​que são analisados ​​pelo Doxia.

Nome do formato	Descrição	Referência
XDoc	Um formato de documentação Maven 1.x	https://jakarta.apache.org/site
FML	Usado para documentos de FAQ	https://maven.apache.org

O Maven fornece aos usuários uma lista muito grande de diferentes tipos de modelos de projeto (614 em números) usando o conceito de Archetype. O Maven ajuda os usuários a iniciar rapidamente um novo projeto java usando o seguinte comando.

mvn archetype:generate

O que é arquétipo?

Archetype é um plugin Maven cuja tarefa é criar uma estrutura de projeto de acordo com seu modelo. Vamos usar o plugin de início rápido de arquétipo para criar um aplicativo Java simples aqui.

Usando modelo de projeto

Vamos abrir o console de comando, vá para o C:\ > MVN diretório e execute o seguinte mvn comando.

C:\MVN>mvn archetype:generate

O Maven iniciará o processamento e pedirá para escolher o arquétipo necessário.

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

Pressione Enter para escolher a opção padrão (203: maven-archetype-quickstart)

O Maven pedirá uma versão particular do arquétipo.

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:

Pressione Enter para escolher a opção padrão (6: maven-archetype-quickstart: 1.1)

O Maven pedirá os detalhes do projeto. Insira os detalhes do projeto conforme solicitado. Pressione Enter se o valor padrão for fornecido. Você pode substituí-los inserindo seu próprio valor.

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:

O Maven pedirá a confirmação dos detalhes do projeto. Pressione Enter ou Y.

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

Agora o Maven começará a criar a estrutura do projeto e exibirá o seguinte -

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

Projeto Criado

Agora vá para C:\ > MVNdiretório. Você verá um projeto de aplicativo java criado, denominadohealth, que foi dado como artifactIdno momento da criação do projeto. O Maven criará um layout de diretório padrão para o projeto, conforme mostrado abaixo -

POM.xml criado

O Maven gera um arquivo POM.xml para o projeto conforme listado abaixo -

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

App.java criado

O Maven gera um arquivo de origem java de amostra, App.java, para o projeto, conforme listado abaixo -

Localização: 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!" );
   }
}

AppTest.java criado

O Maven gera um arquivo de teste fonte java de amostra, AppTest.java para o projeto, conforme listado abaixo -

Localização: 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 );
   }
}

Agora você pode ver o poder do Maven. Você pode criar qualquer tipo de projeto usando um único comando no maven e pode iniciar seu desenvolvimento.

Diferentes Arquétipos

Sr. Não.	Archetype ArtifactIds e descrição
1	maven-archetype-archetype Um arquétipo, que contém um arquétipo de amostra.
2	maven-archetype-j2ee-simple Um arquétipo, que contém um aplicativo J2EE de amostra simplificado.
3	maven-archetype-mojo Um arquétipo, que contém uma amostra de um plug-in Maven de amostra.
4	maven-archetype-plugin Um arquétipo, que contém um plugin de amostra do Maven.
5	maven-archetype-plugin-site Um arquétipo, que contém um exemplo de site de plug-in Maven.
6	maven-archetype-portlet Um arquétipo, que contém um Portlet JSR-268 de amostra.
7	maven-archetype-quickstart Um arquétipo, que contém um projeto Maven de amostra.
8	maven-archetype-simple Um arquétipo, que contém um projeto Maven simples.
9	maven-archetype-site Um arquétipo, que contém um site Maven de amostra para demonstrar alguns dos tipos de documentos suportados, como APT, XDoc e FML, e como i18n seu site.
10	maven-archetype-site-simple Um arquétipo, que contém um site Maven de amostra.
11	maven-archetype-webapp Um arquétipo, que contém uma amostra do projeto Maven Webapp.

Um grande aplicativo de software geralmente consiste em vários módulos e é um cenário comum onde várias equipes estão trabalhando em diferentes módulos do mesmo aplicativo. Por exemplo, considere que uma equipe está trabalhando no front-end do aplicativo como um projeto app-ui (app-ui.jar: 1.0) e está usando um projeto de serviço de dados (data-service.jar: 1.0).

Agora pode acontecer que a equipe que trabalha no serviço de dados esteja passando por correções de bugs ou melhorias em um ritmo rápido e eles estejam liberando a biblioteca para um repositório remoto quase todos os dias.

Agora, se a equipe de serviço de dados fizer upload de uma nova versão a cada dois dias, surgirão os seguintes problemas -

• a equipe de serviço de dados deve avisar a equipe app-ui sempre que lançar um código atualizado.

• A equipe app-ui precisa atualizar seu pom.xml regularmente para obter a versão atualizada.

Para lidar com esse tipo de situação, SNAPSHOT conceito entra em jogo.

O que é SNAPSHOT?

SNAPSHOT é uma versão especial que indica uma cópia de desenvolvimento atual. Ao contrário das versões regulares, o Maven verifica se há uma nova versão do SNAPSHOT em um repositório remoto para cada construção.

Agora a equipe de serviço de dados liberará SNAPSHOT de seu código atualizado todas as vezes para o repositório, digamos data-service: 1.0-SNAPSHOT, substituindo um jar mais antigo de SNAPSHOT.

Instantâneo vs versão

No caso da versão, se o Maven baixou uma vez a versão mencionada, digamos data-service: 1.0, ele nunca tentará baixar um 1.0 mais recente disponível no repositório. Para baixar o código atualizado, a versão do serviço de dados deve ser atualizada para 1.1.

No caso do INSTANTÂNEO, o Maven buscará automaticamente o INSTANTÂNEO o mais recente (data-service: 1.0-SNAPSHOT) cada vez que a equipe app-ui constrói seu projeto.

app-ui pom.xml

app-ui projeto está usando 1.0-SNAPSHOT de serviço de dados.

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

data-service pom.xml

data-service o projeto está liberando 1.0-SNAPSHOT para cada alteração menor.

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

Embora, no caso de SNAPSHOT, o Maven busque automaticamente o SNAPSHOT mais recente diariamente, você pode forçar o maven a fazer o download da construção de instantâneo mais recente usando o switch -U para qualquer comando maven.

mvn clean package -U

Vamos abrir o console de comando, vá para o C:\ > MVN > app-ui diretório e execute o seguinte mvn comando.

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

O Maven começará a construir o projeto após fazer o download do último SNAPSHOT do serviço de dados.

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

A automação de compilação define o cenário onde o processo de compilação do (s) projeto (s) dependente (s) é iniciado depois que a compilação do projeto é concluída com êxito, a fim de garantir que os projetos dependentes sejam estáveis.

Example

Considere que uma equipe está desenvolvendo um projeto bus-core-api em que dois outros projetos app-web-ui e app-desktop-ui são dependentes.

app-web-ui projeto está usando 1.0-SNAPSHOT de bus-core-api projeto.

<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 projeto está usando 1.0-SNAPSHOT de bus-core-api projeto.

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

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

Agora, equipes de app-web-ui e app-desktop-ui projetos exigem que seu processo de construção seja iniciado sempre que bus-core-api mudanças no projeto.

Usando instantâneo, garante que o mais recente bus-core-api projeto deve ser usado, mas para atender aos requisitos acima, precisamos fazer algo extra.

Podemos proceder das duas maneiras a seguir -

• Adicione uma meta pós-construção no bus-core-api pom para dar o pontapé inicial app-web-ui e app-desktop-ui constrói.

• Use um servidor de integração contínua (CI) como o Hudson para gerenciar a automação de construção automaticamente.

Usando Maven

Atualizar bus-core-api projeto 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>

Vamos abrir o console de comando, vá para o C:\ > MVN > bus-core-api diretório e execute o seguinte mvn comando.

>mvn clean package -U

Maven vai começar a construir o projeto 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] ------------------------------------------------------------------

Uma vez bus-core-api a compilação for bem-sucedida, o Maven começará a construir o app-web-ui projeto.

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

Uma vez app-web-ui a compilação for bem-sucedida, o Maven começará a construir o app-desktop-ui projeto.

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

Usando o Serviço de Integração Contínua com Maven

Usar um CI Server é mais preferível para desenvolvedores. Não é necessário atualizar obus-core-api projeto, cada vez que um novo projeto (por exemplo, app-mobile-ui) é adicionado, como projeto dependente de bus-core-apiprojeto. Hudsion é uma ferramenta de integração contínua escrita em java, que em um contêiner de servlet, como Apache tomcat e servidor de aplicativos glassfish. Hudson gerencia automaticamente a automação de build usando o gerenciamento de dependência do Maven. O instantâneo a seguir definirá a função da ferramenta Hudson.

Hudson considera cada construção de projeto como um trabalho. Depois que um código de projeto é registrado no SVN (ou qualquer ferramenta de gerenciamento de código-fonte mapeada para Hudson), o Hudson inicia seu trabalho de construção e, uma vez que este trabalho seja concluído, ele inicia outros trabalhos dependentes (outros projetos dependentes) automaticamente.

No exemplo acima, quando bus-core-uio código-fonte é atualizado em SVN, Hudson inicia sua construção. Uma vez que a compilação é bem-sucedida, Hudson procura por projetos dependentes automaticamente e começa a construirapp-web-ui e app-desktop-ui projetos.

Um dos principais recursos do Maven é o gerenciamento de dependências. Gerenciar dependências é uma tarefa difícil, uma vez que temos de lidar com projetos de vários módulos (consistindo em centenas de módulos / subprojetos). O Maven fornece um alto grau de controle para gerenciar tais cenários.

Descoberta de dependências transitivas

Quase sempre é um caso, quando uma biblioteca, digamos A, depende de outra biblioteca, digamos B. No caso de outro projeto C querer usar A, então esse projeto requer o uso da biblioteca B também.

O Maven ajuda a evitar tais requisitos para descobrir todas as bibliotecas necessárias. O Maven faz isso lendo arquivos de projeto (pom.xml) de dependências, descobrindo suas dependências e assim por diante.

Precisamos apenas definir a dependência direta em cada pom do projeto. O Maven cuida do resto automaticamente.

Com dependências transitivas, o gráfico das bibliotecas incluídas pode crescer rapidamente em grande extensão. Podem surgir casos quando há bibliotecas duplicadas. O Maven fornece poucos recursos para controlar a extensão das dependências transitivas.

Sr. Não.	Recurso e descrição
1	Dependency mediation Determina qual versão de uma dependência deve ser usada quando várias versões de um artefato são encontradas. Se duas versões de dependências estiverem na mesma profundidade na árvore de dependências, a primeira dependência declarada será usada.
2	Dependency management Especifique diretamente as versões dos artefatos a serem usados ​​quando forem encontrados em dependências transitivas. Para um exemplo de projeto, C pode incluir B como uma dependência em sua seção de gerenciamento de dependências e controlar diretamente qual versão de B deve ser usada sempre que for referenciada.
3	Dependency scope Inclui dependências de acordo com o estágio atual da construção.
4	Excluded dependencies Qualquer dependência transitiva pode ser excluída usando o elemento "exclusão". Como exemplo, A depende de B e B depende de C, então A pode marcar C como excluído.
5	Optional dependencies Qualquer dependência transitiva pode ser marcada como opcional usando o elemento "opcional". Como exemplo, A depende de B e B depende de C. Agora, B marcou C como opcional. Então A não usará C.

Escopo de Dependência

A descoberta de dependências transitivas pode ser restringida usando vários Escopos de dependência, conforme mencionado abaixo.

Sr. Não.	Escopo e descrição
1	compile Este escopo indica que a dependência está disponível no caminho de classe do projeto. É o escopo padrão.
2	provided Este escopo indica que a dependência deve ser fornecida pelo JDK ou Web-Server / Container no tempo de execução.
3	runtime Este escopo indica que a dependência não é necessária para a compilação, mas é necessária durante a execução.
4	test Este escopo indica que a dependência está disponível apenas para as fases de compilação e execução de teste.
5	system Este escopo indica que você deve fornecer o caminho do sistema.
6	import Este escopo é usado apenas quando a dependência é do tipo pom. Este escopo indica que o POM especificado deve ser substituído pelas dependências na seção <dependencyManagement> desse POM.

Gestão de Dependências

Normalmente, temos um conjunto de projetos sob um projeto comum. Nesse caso, podemos criar um pom comum com todas as dependências comuns e, em seguida, tornar esse pom, o pai dos poms do subprojeto. O exemplo a seguir ajudará você a entender esse conceito.

A seguir estão os detalhes do gráfico de dependência acima -

• App-UI-WAR depende de App-Core-lib e App-Data-lib.
• Root é pai de App-Core-lib e App-Data-lib.
• Root define Lib1, lib2, Lib3 como dependências em sua seção de dependências.

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>

Agora, quando construirmos o projeto App-UI-WAR, o Maven descobrirá todas as dependências percorrendo o gráfico de dependências e construirá o aplicativo.

Com o exemplo acima, podemos aprender os seguintes conceitos-chave -

• Dependências comuns podem ser colocadas em um único lugar usando o conceito de pom pai. Dependências deApp-Data-lib e App-Core-libprojeto estão listados no projeto Root (consulte o tipo de pacote de Root. É POM).

• Não há necessidade de especificar Lib1, lib2, Lib3 como dependência em App-UI-WAR. Maven usa oTransitive Dependency Mechanism para gerenciar esses detalhes.

No desenvolvimento do projeto, normalmente um processo de implantação consiste nas seguintes etapas -

• Faça check-in do código de todos os projetos em andamento no SVN (sistema de controle de versão) ou repositório de código-fonte e marque-o.

• Baixe o código-fonte completo do SVN.

• Crie o aplicativo.

• Armazene a saída de construção do arquivo WAR ou EAR em um local de rede comum.

• Obtenha o arquivo da rede e implante-o no site de produção.

• Atualizada a documentação com data e número da versão atualizada do aplicativo.

Declaração do Problema

Normalmente, há várias pessoas envolvidas no processo de implantação mencionado acima. Uma equipe pode lidar com o check-in do código, outra pode lidar com a construção e assim por diante. É muito provável que qualquer etapa seja perdida devido aos esforços manuais envolvidos e devido ao ambiente de várias equipes. Por exemplo, a compilação mais antiga não pode ser substituída na máquina da rede e a equipe de implantação implantou a compilação mais antiga novamente.

Solução

Automatize o processo de implantação combinando o seguinte -

• Maven, para construir e lançar projetos.
• SubVersion, repositório de código-fonte, para gerenciar o código-fonte.
• Gerenciador de repositório remoto (Jfrog / Nexus) para gerenciar binários de projeto.

Atualizar projeto POM.xml

Usaremos o plug-in Maven Release para criar um processo de lançamento automatizado.

Por exemplo: projeto 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>

No Pom.xml, a seguir estão os elementos importantes que usamos -

Sr. Não.	Elemento e descrição
1	SCM Configura o local do SVN de onde o Maven fará o check-out do código-fonte.
2	Repositories Local onde WAR / EAR / JAR construído ou qualquer outro artefato será armazenado após a construção do código ser bem-sucedida.
3	Plugin O plugin maven-release é configurado para automatizar o processo de implantação.

Plug-in de lançamento Maven

O Maven realiza as seguintes tarefas úteis usando maven-release-plugin.

mvn release:clean

Ele limpa o espaço de trabalho caso o último processo de liberação não tenha sido bem-sucedido.

mvn release:rollback

Reverta as alterações feitas no código e na configuração do espaço de trabalho, caso o último processo de liberação não tenha sido bem-sucedido.

mvn release:prepare

Executa várias operações, como -

• Verifica se há alguma alteração local não confirmada ou não.

• Garante que não haja dependências SNAPSHOT.

• Altera a versão do aplicativo e remove SNAPSHOT da versão para fazer a liberação.

• Atualize os arquivos pom para o SVN.

• Execute casos de teste.

• Confirme os arquivos POM modificados.

• Marque o código no subversion

• Aumente o número da versão e anexe SNAPSHOT para liberação futura.

• Envie os arquivos POM modificados para o SVN.

mvn release:perform

Verifica o código usando a tag definida anteriormente e executa o objetivo de implantação do Maven, para implantar o war ou construir o artefato no repositório.

Vamos abrir o console de comando, vá para o C:\ > MVN >bus-core-api diretório e execute o seguinte mvn comando.

>mvn release:prepare

Maven começará a construir o projeto. Assim que a compilação for bem-sucedida, execute o seguintemvn comando.

>mvn release:perform

Depois que a construção for bem-sucedida, você pode verificar o arquivo JAR carregado em seu repositório.

Este capítulo ensina como gerenciar um projeto baseado na web usando Maven. Aqui você aprenderá como criar / construir / implantar e executar um aplicativo da web.

Criar aplicativo da web

Para criar uma aplicação web java simples, usaremos maven-archetype-webappplugar. Então, vamos abrir o console de comando, vá para oC:\MVN diretório e execute o seguinte mvn comando.

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

O Maven iniciará o processamento e criará a estrutura completa do projeto do aplicativo Java baseado na web da seguinte forma -

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

Agora vá para o diretório C: / MVN. Você verá um projeto de aplicativo java criado, denominado trucks (conforme especificado em artifactId) conforme especificado no instantâneo a seguir. A seguinte estrutura de diretório é geralmente usada para aplicativos da web -

O Maven usa um layout de diretório padrão. Usando o exemplo acima, podemos entender os seguintes conceitos-chave -

Sr. Não.	Estrutura e descrição da pasta
1	trucks contém a pasta src e pom.xml.
2	src/main/webapp contém index.jsp e pasta WEB-INF.
3	src/main/webapp/WEB-INF contém web.xml
4	src/main/resources ele contém arquivos de imagens / propriedades.

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>

Se você observar, verá que o Maven também criou um arquivo-fonte JSP de amostra.

Abrir C:\ > MVN > trucks > src > main > webapp > pasta para ver index.jsp com o seguinte código -

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

Construir aplicativo da web

Vamos abrir o console de comando, vá para o diretório C: \ MVN \ trucks e execute o seguinte mvn comando.

C:\MVN\trucks>mvn clean package

Maven começará a construir o projeto.

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

Implantar aplicativo da web

Agora copie o trucks.war criado em C:\ > MVN > trucks > target > pasta para o diretório do webapp do servidor da web e reinicie o servidor da web.

Aplicativo da Web de teste

Execute o aplicativo da web usando o URL: http://<server-name>:<port-number>/trucks/index.jsp.

Verifique a saída.

O Eclipse fornece um excelente plugin m2eclipse que integra perfeitamente o Maven e o Eclipse.

Alguns dos recursos do m2eclipse estão listados abaixo -

• Você pode executar metas Maven a partir do Eclipse.

• Você pode visualizar a saída dos comandos Maven dentro do Eclipse, usando seu próprio console.

• Você pode atualizar as dependências do maven com IDE.

• Você pode lançar compilações Maven de dentro do Eclipse.

• Ele faz o gerenciamento de dependência para o caminho de construção do Eclipse com base no pom.xml do Maven.

• Ele resolve dependências Maven do espaço de trabalho do Eclipse sem instalar no repositório Maven local (requer que o projeto de dependência esteja no mesmo espaço de trabalho).

• Ele faz download automaticamente das dependências e fontes necessárias dos repositórios Maven remotos.

• Ele fornece assistentes para a criação de novos projetos Maven, pom.xml e para habilitar o suporte Maven em projetos existentes

• Ele fornece uma busca rápida por dependências em repositórios Maven remotos.

Instalando o plugin m2eclipse

Use um dos seguintes links para instalar o m2eclipse -

Eclipse	URL
Eclipse 3.5 (Gallileo)	Instalando m2eclipse no Eclipse 3.5 (Gallileo)
Eclipse 3.6 (Helios)	Instalando m2eclipse no Eclipse 3.6 (Helios)

O exemplo a seguir ajudará você a aproveitar os benefícios da integração do Eclipse e do maven.

Importar um projeto maven no Eclipse

• Abra o Eclipse.

• Selecione File > Import > opção.

• Selecione a opção de projetos Maven. Clique no botão Avançar.

• Selecione o local do projeto, onde um projeto foi criado usando o Maven. Criamos um banco de consumidor do projeto Java nos capítulos anteriores. Vá para o capítulo 'Criando projeto Java' para ver como criar um projeto usando o Maven.

• Clique no botão Concluir.

Agora, você pode ver o projeto maven em eclipse.

Agora, dê uma olhada em consumer Bankingpropriedades do projeto. Você pode ver que o Eclipse adicionou dependências Maven ao caminho de construção do java.

Agora, é hora de construir este projeto usando a capacidade maven de eclipse.

• Clique com o botão direito no projeto consumerBanking para abrir o menu de contexto.
• Selecione a opção Executar como.
• Em seguida, opção de pacote maven.

Maven começará a construir o projeto. Você pode ver a saída no Console do Eclipse da seguinte maneira -

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

Agora, clique com o botão direito em App.java. SelecioneRun Asopção. Então selecioneJava Application.

Você verá o resultado da seguinte forma -

Hello World!

O NetBeans 6.7 e mais recente tem suporte embutido para Maven. No caso da versão anterior, o plugin Maven está disponível no gerenciador de plugin. Estamos usando o NetBeans 6.9 neste exemplo.

Alguns dos recursos do NetBeans estão listados abaixo -

• Você pode executar metas do Maven a partir do NetBeans.

• Você pode visualizar a saída dos comandos Maven dentro do NetBeans usando seu próprio console.

• Você pode atualizar as dependências do maven com IDE.

• Você pode iniciar compilações do Maven de dentro do NetBeans.

• O NetBeans faz o gerenciamento de dependências automaticamente com base no pom.xml do Maven.

• O NetBeans resolve dependências Maven de seu espaço de trabalho sem instalar no repositório Maven local (requer que o projeto de dependência esteja no mesmo espaço de trabalho).

• Os downloads automáticos do NetBeans requerem dependências e fontes dos repositórios Maven remotos.

• O NetBeans fornece assistentes para a criação de novos projetos Maven, pom.xml.

• O NetBeans fornece um navegador de repositório Maven que permite que você visualize seu repositório local e repositórios Maven externos registrados.

O exemplo a seguir ajudará você a aproveitar os benefícios da integração do NetBeans e do Maven.

Abra um projeto maven no NetBeans

• Abra o NetBeans.

• Selecione File Menu > Open Project opção.

• Selecione o local do projeto, onde um projeto foi criado usando o Maven. Criamos um consumerBanking do Projeto Java. Vá para o capítulo 'Criando projeto Java' para ver como criar um projeto usando o Maven.

Agora, você pode ver o projeto maven no NetBeans. Dê uma olhada nas Bibliotecas do projeto consumerBanking e nas Bibliotecas de Teste. Você pode ver que o NetBeans adicionou dependências Maven ao seu caminho de construção.

Construir um projeto maven no NetBeans

Agora, é hora de construir este projeto usando a capacidade maven do NetBeans.

• Clique com o botão direito no projeto consumerBanking para abrir o menu de contexto.
• Selecione Limpar e construir como opção.

Maven começará a construir o projeto. Você pode ver a saída no NetBeans Console da seguinte maneira -

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

Executar aplicativo no NetBeans

Agora, clique com o botão direito em App.java. SelecioneRun Filecomo opção. Você verá o resultado no NetBeans Console.

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 possui suporte integrado para Maven. Estamos usando o IntelliJ IDEA Community Edition 11.1 neste exemplo.

Alguns dos recursos do IntelliJ IDEA estão listados abaixo -

• Você pode executar metas Maven a partir do IntelliJ IDEA.

• Você pode visualizar a saída dos comandos Maven dentro do IntelliJ IDEA usando seu próprio console.

• Você pode atualizar as dependências do maven no IDE.

• Você pode iniciar compilações Maven de dentro do IntelliJ IDEA.

• O IntelliJ IDEA faz o gerenciamento de dependências automaticamente com base no pom.xml do Maven.

• O IntelliJ IDEA resolve dependências Maven de seu espaço de trabalho sem instalar no repositório Maven local (requer que o projeto de dependência esteja no mesmo espaço de trabalho).

• O IntelliJ IDEA baixa automaticamente as dependências e fontes necessárias dos repositórios Maven remotos.

• O IntelliJ IDEA fornece assistentes para a criação de novos projetos Maven, pom.xml.

O exemplo a seguir ajudará você a aproveitar os benefícios da integração do IntelliJ IDEA e do Maven.

Crie um novo projeto no IntelliJ IDEA

Vamos importar o projeto Maven usando o New Project Wizard.

• Abra o IntelliJ IDEA.

• Selecione File Menu > New Project Opção.

• Selecione importar projeto do modelo existente.

• Selecione a opção Maven

• Selecione o local do projeto, onde um projeto foi criado usando o Maven. Criamos um consumerBanking do Projeto Java. Vá para o capítulo 'Criando projeto Java' para ver como criar um projeto usando o Maven.

• Selecione o projeto Maven para importar.

• Insira o nome do projeto e clique em Concluir.

• Agora, você pode ver o projeto maven no IntelliJ IDEA. Dê uma olhada nas bibliotecas externas do projeto consumerBanking. Você pode ver que o IntelliJ IDEA adicionou dependências Maven ao seu caminho de construção na seção Maven.

Construir um projeto maven no IntelliJ IDEA

Agora, é hora de construir este projeto usando a capacidade do IntelliJ IDEA.

• Selecione o projeto consumerBanking.

• Selecione Buid menu > Rebuild Project Opção

Você pode ver a saída no Console do IntelliJ IDEA

4:01:56 PM Compilation completed successfully

Execute o aplicativo no IntelliJ IDEA

• Selecione o projeto consumerBanking.

• Clique com o botão direito em App.java para abrir o menu de contexto.

• selecionar Run App.main()

Você verá o resultado no Console do 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