Maven - 快速指南
Maven - Overview
什么是Maven？
Maven是一个项目管理和理解工具，为开发人员提供完整的构建生命周期框架。 由于Maven使用标准目录布局和默认构建生命周期，开发团队几乎可以立即自动化项目的构建基础架构。
在多个开发团队环境的情况下，Maven可以在很短的时间内按照标准设置工作方式。 由于大多数项目设置都很简单且可重复使用，因此Maven可以在创建报告，检查，构建和测试自动化设置的同时简化开发人员的工作。
Maven为开发人员提供了管理以下方法的方法 -
- Builds
- Documentation
- Reporting
- Dependencies
- SCMs
- Releases
- Distribution
- 邮件列表
总而言之，Maven简化并标准化了项目构建过程。 它无缝地处理编译，分发，文档，团队协作和其他任务。 Maven提高了可重用性并处理了大多数与构建相关的任务。
Maven Evolution
Maven最初旨在简化Jakarta Turbine项目的建设流程。 有几个项目，每个项目包含略有不同的ANT构建文件。 JAR被检入CVS。
Apache团队随后开发了Maven ，它可以一起构建多个项目，发布项目信息，部署项目，在多个项目中共享JAR并帮助团队协作。
目标(Objective)
Maven的主要目标是为开发人员提供以下内容 -
项目的综合模型，可重用，可维护，易于理解。
与此声明性模型交互的插件或工具。
Maven项目结构和内容在xml文件pom.xml中声明，称为项目对象模型（POM），它是整个Maven系统的基本单元。 在后面的章节中，我们将详细解释POM。
约定优于配置
Maven使用Convention优于Configuration ，这意味着开发人员不需要自己创建构建过程。
开发人员不必提及每个配置细节。 Maven为项目提供合理的默认行为。 创建Maven项目时，Maven会创建默认项目结构。 开发人员只需要相应地放置文件，他/她不需要在pom.xml中定义任何配置。
例如，下表显示了项目源代码文件，资源文件和其他配置的默认值。 假设， ${basedir}表示项目位置 -
| 项目 | 默认 |
|---|---|
| 源代码 | ${basedir}/src/main/java |
| Resources | ${basedir}/src/main/resources |
| Tests | ${basedir}/src/test |
| 符合字节代码 | ${basedir}/target |
| 可分发的JAR | ${basedir}/target/classes |
为了构建项目，Maven为开发人员提供了提及生命周期目标和项目依赖性的选项（依赖于Maven插件功能及其默认约定）。 许多项目管理和构建相关任务都由Maven插件维护。
开发人员可以构建任何给定的Maven项目，而无需了解各个插件的工作方式。 我们将在后面的章节中详细讨论Maven插件。
Maven的特点
简单的项目设置遵循最佳实践。
所有项目的一致使用。
依赖管理包括自动更新。
一个庞大且不断增长的库库。
可扩展，能够轻松编写Java或脚本语言的插件。
只需很少或不需要额外配置即可即时访问新功能。
Model-based builds - Maven能够将任意数量的项目构建到预定义的输出类型中，例如jar，war，metadata。
Coherent site of project information - 使用与构建过程相同的元数据，maven能够生成包含完整文档的网站和PDF。
Release management and distribution publication - 如果没有其他配置，maven将与您的源控制系统（如CVS）集成并管理项目的发布。
Backward Compatibility - 您可以从旧版本的Maven轻松地将项目的多个模块移植到Maven 3中。 它也可以支持旧版本。
Automatic parent versioning - 无需在子模块中指定父级进行维护。
Parallel builds - 它分析项目依赖关系图，使您能够并行构建计划模块。 使用此功能，您可以实现20-50％的性能提升。
Better Error and Integrity Reporting - Maven改进了错误报告，它为您提供了Maven wiki页面的链接，您可以在其中获得错误的完整描述。
Maven - Environment Setup
Maven是一个基于Java的工具，因此第一个要求是在您的机器上安装JDK。
系统需求 (System Requirement)
| JDK | 1.7或以上。 |
|---|---|
| 记忆 | 没有最低要求。 |
| 磁盘空间 | 没有最低要求。 |
| 操作系统 | 没有最低要求。 |
步骤1 - 验证计算机上的Java安装
打开控制台并执行以下java命令。
| OS | 任务 | 命令 |
|---|---|---|
| Windows | 打开命令控制台 | c:\> java -version |
| Linux | 打开命令终端 | $ java -version |
| Mac | 开放式终端 | 机器:~joseph $ java -version |
让我们验证所有操作系统的输出 -
| OS | output |
|---|---|
| Windows | java版“1.7.0_60” Java（TM）SE运行时环境（版本1.7.0_60-b19） Java HotSpot（TM）64位服务器VM（内置24.60-b09，混合模式） |
| Linux | java版“1.7.0_60” Java（TM）SE运行时环境（版本1.7.0_60-b19） Java HotSpot（TM）64位服务器VM（内置24.60-b09，混合模式） |
| Mac | java版“1.7.0_60” Java（TM）SE运行时环境（版本1.7.0_60-b19） Java HotSpot（TM）64位服务器VM（内置24.60-b09，混合模式） |
如果未安装Java，请从https://www.oracle.com/technetwork/java/javase/downloads/index.html安装Java软件开发工具包（SDK）。 我们假设Java 1.7.0.60作为本教程的安装版本。
第2步 - 设置JAVA环境
将JAVA_HOME环境变量设置为指向计算机上安装Java的基本目录位置。 例如 -
| OS | output |
|---|---|
| Windows | 将环境变量JAVA_HOME设置为C:\Program Files\Java\jdk1.7.0_60 |
| Linux | export JAVA_HOME =/usr/local/java-current |
| Mac | export JAVA_HOME =/Library/Java/Home |
将Java编译器位置附加到系统路径。
| OS | output |
|---|---|
| Windows | 将字符串“; C:\Program Files\Java\jdk1.7.0.60\bin”附加到系统变量Path的末尾。 |
| Linux | export PATH = $ PATH:$ JAVA_HOME/bin/ |
| Mac | 不需要 |
使用java -version命令验证Java安装，如上所述。
第3步 - 下载Maven存档
从https://maven.apache.org/download.cgi下载Maven 2.2.1。
| OS | 存档名称 |
|---|---|
| Windows | 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 |
第4步 - 提取Maven存档
将存档解压缩到要安装Maven 3.3.1的目录。 将从存档创建子目录apache-maven-3.3.1。
| OS | 位置（根据您的安装可能会有所不同） |
|---|---|
| Windows | C:\Program Files\Apache Software Foundation\apache-maven-3.3.1 |
| Linux | /usr/local/apache-maven |
| Mac | /usr/local/apache-maven |
第5步 - 设置Maven环境变量
将M2_HOME，M2，MAVEN_OPTS添加到环境变量中。
| OS | output |
|---|---|
| Windows | 使用系统属性设置环境变量。 M2_HOME = C:\Program Files\Apache Software Foundation\apache-maven-3.3.1 M2 =％M2_HOME％\ bin MAVEN_OPTS = -Xms256m -Xmx512m |
| Linux | 打开命令终端并设置环境变量。 export M2_HOME =/usr/local/apache-maven/apache-maven-3.3.1 export M2 = $ M2_HOME/bin 导出MAVEN_OPTS = -Xms256m -Xmx512m |
| Mac | 打开命令终端并设置环境变量。 export M2_HOME =/usr/local/apache-maven/apache-maven-3.3.1 出口M2 = $ M2_HOME/bin 导出MAVEN_OPTS = -Xms256m -Xmx512m |
步骤6 - 将Maven bin目录位置添加到系统路径
现在将M2变量附加到系统路径。
| OS | output |
|---|---|
| Windows | 将字符串;％M2％附加到系统变量Path的末尾。 |
| Linux | export PATH = $ M2:$ PATH |
| Mac | export PATH = $ M2:$ PATH |
第7步 - 验证Maven安装
现在打开控制台并执行以下mvn命令。
| OS | 任务 | 命令 |
|---|---|---|
| Windows | 打开命令控制台 | c:\> mvn --version |
| Linux | 打开命令终端 | $ mvn --version |
| Mac | 开放式终端 | machine:~ wiki$ mvn --version |
最后，验证上述命令的输出，如下所示 -
| OS | output |
|---|---|
| Windows | Apache Maven 3.3.1（r801777; 2009-08-07 00:46:01 + 0530） Java版本:1.7.0_60 Java home:C:\Program Files\Java\jdk1.7.0_60\jre |
| Linux | Apache Maven 3.3.1（r801777; 2009-08-07 00:46:01 + 0530） Java版本:1.7.0_60 Java home:C:\Program Files\Java\jdk1.7.0_60\jre |
| Mac | Apache Maven 3.3.1（r801777; 2009-08-07 00:46:01 + 0530） Java版本:1.7.0_60 Java home:C:\Program Files\Java\jdk1.7.0_60\jre |
Maven - POM
POM代表项目对象模型。 它是Maven的基本工作单元。 它是一个XML文件，它以pom.xml的形式驻留在项目的基本目录中。
POM包含有关项目的信息以及Maven用于构建项目的各种配置详细信息。
POM还包含目标和插件。 在执行任务或目标时，Maven在当前目录中查找POM。 它读取POM，获取所需的配置信息，然后执行目标。 可以在POM中指定的一些配置如下 -
- 项目依赖
- plugins
- goals
- 建立档案
- 项目版本
- developers
- 邮件列表
在创建POM之前，我们应首先确定项目group （groupId），其name （artifactId）及其版本，因为这些属性有助于唯一标识存储库中的项目。
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>
应该注意，每个项目应该有一个POM文件。
所有POM文件都需要project元素和三个必填字段: groupId, artifactId, version 。
存储库中的项目符号是groupId:artifactId:version 。
POM的最低要求 -
| Sr.No. | 节点和描述 |
|---|---|
| 1 | Project root 这是项目根标记。 您需要指定基本架构设置，例如apache架构和w3.org规范。 |
| 2 | Model version 型号版本应为4.0.0。 |
| 3 | groupId 这是项目组的ID。 这在组织或项目中通常是独一无二的。 例如，银行集团com.company.bank拥有所有与银行相关的项目。 |
| 4 | artifactId 这是项目的ID。 这通常是项目的名称。 例如，消费者银行业务。 与groupId一起，artifactId定义工件在存储库中的位置。 |
| 5 | version 这是项目的版本。 与groupId一起，它在工件的存储库中用于将版本彼此分开。 例如 - com.company.bank:consumer-banking:1.0 com.company.bank:consumer-banking:1.1. |
超级POM
Super POM是Maven的默认POM。 所有POM都继承自父级或默认（尽管明确定义与否）。 此基本POM称为Super POM ，包含默认继承的值。
Maven使用有效的POM（来自超级pom和项目配置的配置）来执行相关目标。 它可以帮助开发人员在他/她的pom.xml中指定最小配置细节。 虽然配置可以轻松覆盖。
查看超级POM的默认配置的简单方法是运行以下命令: mvn help:effective-pom
在您的计算机上的任何目录中创建一个pom.xml。使用上述示例pom的内容。
在下面的示例中，我们在C:\MVN\project文件夹中创建了一个pom.xml。
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。
C:\MVN\project>mvn help:effective-pom
Maven将开始处理并显示有效pom。
[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] ------------------------------------------------------------------------
在继承，插值和配置文件应用后，有效POM在控制台中显示为结果。
<?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>
在上面的pom.xml中，您可以看到默认的项目源文件夹结构，输出目录，所需的插件，存储库，报告目录，Maven将在执行所需目标时使用。
Maven pom.xml也不需要手动编写。 Maven提供了许多原型插件来创建项目，按顺序创建项目结构和pom.xml
Maven - Build Life Cycle
什么是构建生命周期？
构建生命周期是一个明确定义的阶段序列，它定义了目标的执行顺序。 这里阶段代表生命周期的一个阶段。 例如，典型的Maven Build Lifecycle由以下几个阶段组成。
| 阶段 | Handles | 描述 |
|---|---|---|
| prepare-resources | 资源复制 | 可以在此阶段自定义资源复制。 |
| validate | 验证信息 | 验证项目是否正确以及是否所有必要信息都可用。 |
| compile | compilation | 源代码编译在此阶段完成。 |
| Test | Testing | 测试适合测试框架的已编译源代码。 |
| package | packaging | 此阶段创建JOM/WAR包，如POM.xml中的包装中所述。 |
| install | installation | 此阶段将程序包安装在本地/远程maven存储库中。 |
| Deploy | Deploying | 将最终包复制到远程存储库。 |
注册goals始终存在pre和post阶段，这些阶段必须在特定阶段之前或之后运行。
当Maven开始构建项目时，它会逐步完成定义的阶段序列并执行目标，这些目标在每个阶段都会注册。
Maven有以下三个标准生命周期 -
- clean
- 默认（或构建）
- site
goal代表一项有助于项目建设和管理的特定任务。 它可能绑定到零个或多个构建阶段。 未绑定到任何构建阶段的目标可以通过直接调用在构建生命周期之外执行。
执行顺序取决于调用目标和构建阶段的顺序。 例如，请考虑以下命令。 clean和package参数是构建阶段，而dependency:copy-dependencies是一个目标。
mvn clean dependency:copy-dependencies package
这里首先执行clean阶段，然后执行dependency:copy-dependencies goal ，最后执行package阶段。
清洁生命周期
当我们执行mvn post-clean命令时，Maven会调用由以下阶段组成的清洁生命周期。
- pre-clean
- clean
- post-clean
Maven清洁目标（清洁:清洁）必然会在清洁生命周期中处于clean阶段。 它clean:cleangoal通过删除构建目录来删除构建的输出。 因此，当执行mvn clean命令时，Maven删除构建目录。
我们可以通过提及清洁生命周期的任何上述阶段中的目标来定制此行为。
在下面的示例中，我们将maven-antrun-plugin:运行目标附加到预清洁，清洁和后清洁阶段。 这将允许我们回显显示清洁生命周期阶段的文本消息。
我们在C:\MVN\project文件夹中创建了一个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>
<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>
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。
C:\MVN\project>mvn post-clean
Maven将开始处理并显示清洁生命周期的所有阶段。
[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] ------------------------------------------------------------------
您可以尝试调整mvn clean命令，它将显示pre-clean和清洁。 post-clean阶段不会执行任何操作。
Default (or Build) Lifecycle
这是Maven的主要生命周期，用于构建应用程序。 它有以下23个阶段。
| Sr.No. | 生命周期阶段和描述 |
|---|---|
| 1 | validate 验证项目是否正确，并且所有必要信息都可用于完成构建过程。 |
| 2 | initialize 初始化构建状态，例如set属性。 |
| 3 | generate-sources 生成要包含在编译阶段的任何源代码。 |
| 4 | process-sources 处理源代码，例如，过滤任何值。 |
| 5 | generate-resources 生成要包含在包中的资源。 |
| 6 | process-resources 将资源复制并处理到目标目录，为打包阶段做好准备。 |
| 7 | compile 编译项目的源代码。 |
| 8 | process-classes 从编译中对生成的文件进行后处理，例如对Java类进行字节码增强/优化。 |
| 9 | generate-test-sources 生成要包含在编译阶段的任何测试源代码。 |
| 10 | process-test-sources 处理测试源代码，例如，过滤任何值。 |
| 11 | test-compile 将测试源代码编译到测试目标目录中。 |
| 12 | process-test-classes 从测试代码文件编译中处理生成的文件。 |
| 13 | test 使用合适的单元测试框架运行测试（Junit是一个）。 |
| 14 | prepare-package 在实际包装之前执行准备包装所需的任何操作。 |
| 15 | package 获取已编译的代码并将其打包为可分发的格式，例如JAR，WAR或EAR文件。 |
| 16 | pre-integration-test 执行集成测试之前执行所需的操作。 例如，设置所需的环境。 |
| 17 | integration-test 如有必要，可以将程序包处理并部署到可以运行集成测试的环境中。 |
| 18 | post-integration-test 执行集成测试后执行所需的操作。 例如，清理环境。 |
| 19 | verify 运行任何检查以验证包是否有效并符合质量标准。 |
| 20 | install 将软件包安装到本地存储库中，该存储库可以在本地用作其他项目的依赖项。 |
| 21 | deploy 将最终包复制到远程存储库以与其他开发人员和项目共享。 |
与Maven Lifecycles相关的几个重要概念值得一提 -
当通过Maven命令调用某个阶段时，例如mvn compile ，只会执行直到并包括该阶段的阶段。
根据包装类型（JAR/WAR/EAR），不同的maven目标将绑定到Maven生命周期的不同阶段。
在下面的示例中，我们将maven-antrun-plugin:run goal附加到Build生命周期的几个阶段。 这将允许我们回显显示生命周期阶段的文本消息。
我们在C:\MVN\project文件夹中更新了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>
<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>
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。
C:\MVN\project>mvn compile
Maven将开始处理并显示构建生命周期的阶段，直到编译阶段。
[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] -----------------------------------------------------------------
-
网站生命周期
Maven Site插件通常用于创建新文档以创建报告，部署站点等。它具有以下阶段 -
- pre-site
- site
- post-site
- site-deploy
在以下示例中，我们将maven-antrun-plugin:run goal附加到Site生命周期的所有阶段。 这将允许我们回显显示生命周期阶段的文本消息。
我们在C:\MVN\project文件夹中更新了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>
<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>
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。
C:\MVN\project>mvn site
Maven将开始处理并显示站点生命周期的阶段，直至站点阶段。
[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] ------------------------------------------------------------------
Maven - Build Profiles
什么是Build Profile？
构建配置文件是一组配置值，可用于设置或覆盖Maven构建的默认值。 使用构建配置文件，您可以为不同的环境（例如Production v/s开发环境）自定义构建。
配置文件使用其activeProfiles/profiles元素在pom.xml文件中指定，并以各种方式触发。 配置文件在构建时修改POM，并用于为不同的目标环境提供参数（例如，开发，测试和生产环境中的数据库服务器的路径）。
构建配置文件的类型
构建配置文件主要有三种类型。
| 类型 | 它定义的地方 |
|---|---|
| 每个项目 | 在项目POM文件pom.xml中定义 |
| 每用户 | 在Maven设置xml文件中定义（％USER_HOME％/。m2/settings.xml） |
| Global | 在Maven全局设置xml文件中定义（％M2_HOME％/ conf/settings.xml） |
资料激活
可以通过各种方式激活Maven构建配置文件。
- 显式使用命令控制台输入。
- 通过maven设置。
- 基于环境变量（用户/系统变量）。
- 操作系统设置（例如，Windows系列）。
- 存在/丢失文件。
配置文件激活示例
让我们假设您的项目的以下目录结构 -
现在，在src/main/resources ，有三个特定于环境的文件 -
| Sr.No. | 文件名称和描述 |
|---|---|
| 1 | env.properties 如果未提及配置文件，则使用默认配置。 |
| 2 | env.test.properties 使用测试配置文件时测试配置。 |
| 3 | env.prod.properties 使用prod配置文件时的生产配置。 |
显式配置文件激活
在下面的示例中，我们将附加maven-antrun-plugin:run goal来测试阶段。 这将允许我们回显不同配置文件的文本消息。 我们将使用pom.xml定义不同的配置文件，并使用maven命令在命令控制台上激活配置文件。
假设，我们在C:\MVN\project文件夹中创建了以下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>
<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>
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。 使用-P选项将配置文件名称作为参数传递。
C:\MVN\project>mvn test -Ptest
Maven将开始处理并显示测试构建配置文件的结果。
[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] ------------------------------------------------------------------
现在，作为练习，您可以执行以下步骤 -
将另一个profile元素添加到pom.xml的profiles元素中（复制现有的profile元素并将其粘贴到profile元素结束的位置）。
将此配置文件元素的id从test更新为normal。
更新任务部分以回显env.properties并将env.properties复制到目标目录。
再次重复上述三个步骤，将id更新为prod，将任务部分更新为env.prod.properties。
就这样。 现在你已准备好三个构建配置文件（normal/test/prod）。
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。 使用-P选项将概要文件名称作为参数传递。
C:\MVN\project>mvn test -Pnormal
C:\MVN\project>mvn test -Pprod
检查构建的输出以查看差异。
通过Maven设置激活配置文件
打开％USER_HOME％/。m2目录中可用的Maven settings.xml文件，其中%USER_HOME%表示用户主目录。 如果不存在settings.xml文件，则创建一个新文件。
使用活动“个人档案”节点将测试配置文件添加为活动配置文件，如下例所示。
<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>
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。 不要使用-P选项传递配置文件名称。 Maven将显示测试配置文件的结果为活动配置文件。
C:\MVN\project>mvn test
通过环境变量激活配置文件
现在从maven settings.xml中删除活动配置文件，并更新pom.xml中提到的测试配置文件。 将激活元素添加到profile元素，如下所示。
当使用值“test”指定系统属性“env”时，将触发测试配置文件。 创建一个环境变量“env”并将其值设置为“test”。
<profile>
<id>test</id>
<activation>
<property>
<name>env</name>
<value>test</value>
</property>
</activation>
</profile>
让我们打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。
C:\MVN\project>mvn test
通过操作系统激活配置文件
激活元素包括os详细信息，如下所示。 当系统是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>
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。 不要使用-P选项传递配置文件名称。 Maven将显示测试配置文件的结果为活动配置文件。
C:\MVN\project>mvn test
通过存在/丢失文件激活配置文件
现在激活元素包含OS详细信息，如下所示。 当缺少target/generated-sources/axistools/wsdl2java/com/companyname/group时，将触发测试配置文件。
<profile>
<id>test</id>
<activation>
<file>
<missing>target/generated-sources/axistools/wsdl2java/
com/companyname/group</missing>
</file>
</activation>
</profile>
现在打开命令控制台，转到包含pom.xml的文件夹并执行以下mvn命令。 不要使用-P选项传递配置文件名称。 Maven将显示测试配置文件的结果为活动配置文件。
C:\MVN\project>mvn test
Maven - Repositories
什么是Maven存储库？
在Maven术语中，存储库是存储所有项目jar，库jar，插件或任何其他项目特定工件的目录，并且可以由Maven轻松使用。
Maven存储库有三种类型。 下图将给出关于这三种类型的想法。
- local
- central
- remote
本地存储库
Maven本地存储库是计算机上的文件夹位置。 它是在第一次运行任何maven命令时创建的。
Maven本地存储库保存您项目的所有依赖项（库jar，插件罐等）。 当您运行Maven构建时，Maven会自动将所有依赖项jar下载到本地存储库中。 每次构建项目时，它都有助于避免引用存储在远程机器上的依赖项。
默认情况下，Maven本地存储库由Maven在％USER_HOME％目录中创建。 要覆盖默认位置，请在％M2_HOME％\ conf目录中提供Maven settings.xml文件中的另一个路径。
<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>
当您运行Maven命令时，Maven会将依赖项下载到您的自定义路径。
中央存储库
Maven中央存储库是Maven社区提供的存储库。 它包含大量常用库。
当Maven在本地存储库中找不到任何依赖项时，它会使用以下URL开始在中央存储库中搜索 - https://repo1.maven.org/maven2/
中央存储库的关键概念如下 -
- 该存储库由Maven社区管理。
- 它不需要配置。
- 它需要搜索互联网访问。
要浏览中央maven存储库的内容，maven社区提供了一个URL - https://search.maven.org/#browse 。 使用此库，开发人员可以搜索中央存储库中的所有可用库。
远程存储库
有时，Maven也没有在中央存储库中找到提到的依赖项。 然后它停止构建过程并将错误消息输出到控制台。 为了防止这种情况，Maven提供了Remote Repository概念，它是开发人员自己的包含所需库或其他项目jar的自定义存储库。
例如，使用下面提到的POM.xml，Maven将从同一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>
Maven依赖搜索序列
当我们执行Maven构建命令时，Maven开始按以下顺序查找依赖库 -
Step 1 - 在本地存储库中搜索依赖关系，如果未找到，则转到步骤2，否则执行进一步处理。
Step 2 - 在中央存储库中搜索依赖关系，如果未找到，则提及远程存储库/存储库，然后转到步骤4.否则，将其下载到本地存储库以供将来参考。
Step 3 - 如果没有提到远程存储库，Maven只是停止处理并抛出错误（无法找到依赖关系）。
Step 4 - 在远程存储库或存储库中搜索依赖关系，如果找到，则将其下载到本地存储库以供将来参考。 否则，Maven停止处理并抛出错误（无法找到依赖项）。
Maven - Plugins
什么是Maven插件？
Maven实际上是一个插件执行框架，其中每个任务实际上都是由插件完成的。 Maven插件通常用于 -
- 创建jar文件
- 创建战争文件
- 编译代码文件
- 单元测试代码
- 创建项目文档
- 创建项目报告
插件通常提供一组目标，可以使用以下语法执行 -
mvn [plugin-name]:[goal-name]
例如，可以使用maven-compiler-plugin的compile-goal通过运行以下命令来编译Java项目。
mvn compiler:compile
插件类型
Maven提供了以下两种类型的插件 -
| Sr.No. | 类型和描述 |
|---|---|
| 1 | Build plugins 它们在构建过程中执行，应该在pom.xml的 |
| 2 | Reporting plugins 它们在站点生成过程中执行，应在pom.xml的 |
以下是几个常见插件的列表 -
| Sr.No. | 插件和说明 |
|---|---|
| 1 | clean 构建后清理目标。 删除目标目录。 |
| 2 | compiler 编译Java源文件。 |
| 3 | surefire 运行JUnit单元测试。 创建测试报告。 |
| 4 | jar 从当前项目构建JAR文件。 |
| 5 | war 从当前项目构建WAR文件。 |
| 6 | javadoc 为项目生成Javadoc。 |
| 7 | antrun 从构建中提到的任何阶段运行一组ant任务。 |
Example
我们在示例中广泛使用了maven-antrun-plugin来在控制台上打印数据。 请参阅构建配置文件章节。 让我们以更好的方式理解它，并在C:\MVN\project文件夹中创建一个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>
<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>
接下来，打开命令控制台并转到包含pom.xml的文件夹，然后执行以下mvn命令。
C:\MVN\project>mvn clean
Maven将开始处理并显示清洁生命周期的清洁阶段。
[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] ------------------------------------------------------------------
以上示例说明了以下关键概念 -
使用plugins元素在pom.xml中指定插件。
每个插件都可以有多个目标。
您可以使用其阶段元素定义插件应从何处开始处理的阶段。 我们使用了clean阶段。
您可以通过将任务绑定到插件目标来配置要执行的任务。 我们将echo任务与maven-antrun-plugin run目标绑定在一起。
然后，如果本地存储库中没有该插件，Maven将下载该插件并开始处理。
Maven - Creating Project
Maven使用archetype插件来创建项目。 要创建一个简单的Java应用程序，我们将使用maven-archetype-quickstart插件。 在下面的示例中，我们将在C:\MVN文件夹中创建基于maven的java应用程序项目。
让我们打开命令控制台，转到C:\MVN目录并执行以下mvn命令。
C:\MVN>mvn archetype:generate
-DgroupId = com.companyname.bank
-DartifactId = consumerBanking
-DarchetypeArtifactId = maven-archetype-quickstart
-DinteractiveMode = false
Maven将开始处理并将创建完整的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] ------------------------------------------------------------------
现在转到C:/ MVN目录。 您将看到一个名为consumer Banking的java应用程序项目（在artifactId中指定）。 Maven使用标准目录布局，如下所示 -
使用上面的例子，我们可以理解以下关键概念 -
| Sr.No. | 文件夹结构和描述 |
|---|---|
| 1 | consumerBanking 包含src文件夹和pom.xml |
| 2 | src/main/java 包含包结构下的java代码文件（com/companyName/bank）。 |
| 3 | src/main/test 包含包结构下的测试java代码文件（com/companyName/bank）。 |
| 4 | src/main/resources 它包含图像/属性文件（在上面的例子中，我们需要手动创建这个结构）。 |
如果你观察到，你会发现Maven还创建了一个示例Java源文件和Java Test文件。 打开C:\MVN\consumerBanking\src\main\java\com\companyname\bank文件夹，您将看到App.java。
package com.companyname.bank;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ){
System.out.println( "Hello World!" );
}
}
打开C:\MVN\consumerBanking\src\test\java\com\companyname\bank文件夹以查看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 );
}
}
开发人员需要按照上表中的说明放置文件，Maven处理所有与构建相关的复杂性。
在下一章中，我们将讨论如何使用maven Build and Test Project构建和测试项目。
Maven - Build & Test Project
我们在Project Creation章节中学到的是如何使用Maven创建Java应用程序。 现在我们将看到如何构建和测试应用程序。
转到您创建Java应用程序的C:/ MVN目录。 打开consumerBanking文件夹。 您将看到包含以下内容的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>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
</dependency>
</dependencies>
</project>
在这里你可以看到，Maven已经添加了Junit作为测试框架。 默认情况下，Maven在其默认目录结构中添加源文件App.java和测试文件AppTest.java ，如上一章所述。
让我们打开命令控制台，转到C:\MVN\consumerBanking目录并执行以下mvn命令。
C:\MVN\consumerBanking>mvn clean package
Maven将开始构建该项目。
[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]-----------------------------------------------
您已经构建了项目并创建了最终的jar文件，以下是关键的学习概念 -
我们给maven两个目标，首先清理目标目录（干净），然后将项目构建输出打包为jar（包）。
打包的jar在consumerBanking\target文件夹中可用作consumerBanking-1.0-SNAPSHOT.jar。
在consumerBanking\target\surefire-reports文件夹中提供了测试报告。
Maven编译源代码文件，然后测试源代码文件。
然后Maven运行测试用例。
最后，Maven创建了包。
现在打开命令控制台，转到C:\MVN\consumerBanking\target\classes目录并执行以下java命令。
>java com.companyname.bank.App
您将看到如下结果 -
Hello World!
添加Java源文件
让我们看看我们如何在项目中添加额外的Java文件。 打开C:\MVN\consumerBanking\src\main\java\com\companyname\bank文件夹，在其中创建Util类作为Util.java。
package com.companyname.bank;
public class Util {
public static void printMessage(String message){
System.out.println(message);
}
}
更新App类以使用Util类。
package com.companyname.bank;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ){
Util.printMessage("Hello World!");
}
}
现在打开命令控制台，转到C:\MVN\consumerBanking目录并执行以下mvn命令。
>mvn clean compile
Maven构建成功后，转到C:\MVN\consumerBanking\target\classes目录并执行以下java命令。
>java -cp com.companyname.bank.App
您将看到如下结果 -
Hello World!
Maven - External Dependencies
如您所知，Maven使用存储库的概念进行依赖关系管理。 但是，如果在任何远程存储库和中央存储库中都没有依赖项，会发生什么？ Maven使用External Dependency概念为这种情况提供答案。
例如，让我们对“创建Java项目”一章中创建的项目进行以下更改。
将lib文件夹添加到src文件夹。
将任何jar复制到lib文件夹中。 我们使用了ldapjdk.jar ，它是LDAP操作的帮助库。
现在我们的项目结构应如下所示 -
在这里，你有自己的库，特定于项目，这是一个常见的情况，它包含jar，可能无法在任何存储库中提供maven下载。 如果您的代码在Maven中使用此库，则Maven构建将失败，因为它无法在编译阶段下载或引用此库。
为了处理这种情况，让我们使用以下方法将此外部依赖项添加到maven 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.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>
在上面的示例中查看依赖项下的第二个依赖项元素，它清除以下关于External Dependency项的关键概念。
外部依赖项（库jar位置）可以在pom.xml中以与其他依赖项相同的方式配置。
指定groupId与库的名称相同。
指定artifactId与库的名称相同。
将范围指定为系统。
指定相对于项目位置的系统路径。
希望您现在清楚了解外部依赖关系，并且您将能够在Maven项目中指定外部依赖项。
Maven - Project Documents
本教程将教您如何一次创建应用程序的文档。 让我们开始吧，转到C:/ MVN目录，在那里使用前面章节中给出的示例创建了java consumerBanking应用程序。 打开consumerBanking文件夹并执行以下mvn命令。
C:\MVN>mvn site
Maven将开始构建该项目。
[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]-----------------------------------------------
您的项目文档现已准备就绪。 Maven在目标目录中创建了一个站点。
打开C:\MVN\consumerBanking\target\site文件夹。 单击index.html以查看文档。
Maven使用名为Doxia的文档处理引擎创建文档，该引擎将多种源格式读入公共文档模型。 要为项目编写文档，您可以使用以下几种常用格式编写内容，这些格式由Doxia解析。
| 格式名称 | 描述 | 参考 |
|---|---|---|
| XDoc | Maven 1.x文档格式 | |
| FML | 用于常见问题文档 |
Maven - Project Templates
Maven使用Archetype的概念为用户提供了一个非常大的不同类型的项目模板列表（614个数字）。 Maven使用以下命令帮助用户快速启动新的java项目。
mvn archetype:generate
什么是原型？
Archetype是一个Maven插件，其任务是根据模板创建项目结构。 我们将使用quickstart archetype插件在这里创建一个简单的Java应用程序。
使用项目模板
让我们打开命令控制台，转到C:\ 》 MVN目录并执行以下mvn命令。
C:\MVN>mvn archetype:generate
Maven将开始处理并将要求选择所需的原型。
[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:
按Enter键选择默认选项（203:maven-archetype-quickstart）
Maven将要求特定版本的原型。
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:
按Enter键选择默认选项（6:maven-archetype-quickstart:1.1）
Maven会询问项目细节。 按要求输入项目详细信息。 如果提供了默认值，请按Enter键。 您可以通过输入自己的值来覆盖它们。
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:
Maven将要求项目详细确认。 按enter或按Y.
Confirm properties configuration:
groupId: com.companyname.insurance
artifactId: health
version: 1.0-SNAPSHOT
package: com.companyname.insurance
Y:
现在Maven将开始创建项目结构并将显示以下内容 -
[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]-----------------------------------------------
创建项目
现在转到C:\ 》 MVN目录。 您将看到一个名为health的java应用程序项目，该项目在项目创建时作为artifactId给出。 Maven将为项目创建标准目录布局，如下所示 -
Created POM.xml
Maven为项目生成一个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.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>
Created App.java
Maven为项目生成示例java源文件App.java，如下所示 -
地点: 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!" );
}
}
Created AppTest.java
Maven为项目生成示例java源测试文件AppTest.java，如下所示 -
位置: 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 );
}
}
现在你可以看到Maven的力量了。 您可以在maven中使用单个命令创建任何类型的项目，并可以启动您的开发。
不同的原型
| Sr.No. | Archetype ArtifactIds＆Description |
|---|---|
| 1 | maven-archetype-archetype 原型，包含样本原型。 |
| 2 | maven-archetype-j2ee-simple 原型，包含简化的J2EE应用程序示例。 |
| 3 | maven-archetype-mojo 原型，包含示例Maven插件的示例。 |
| 4 | maven-archetype-plugin 一个原型，包含一个示例Maven插件。 |
| 5 | maven-archetype-plugin-site 一个原型，包含一个示例Maven插件站点。 |
| 6 | maven-archetype-portlet 原型，包含示例JSR-268 Portlet。 |
| 7 | maven-archetype-quickstart 原型，包含示例Maven项目。 |
| 8 | maven-archetype-simple 原型，包含一个简单的Maven项目。 |
| 9 | maven-archetype-site 一个原型，它包含一个示例Maven站点，用于演示一些受支持的文档类型，如APT，XDoc和FML，并演示如何i18n您的站点。 |
| 10 | maven-archetype-site-simple 原型，包含示例Maven站点。 |
| 11 | maven-archetype-webapp 一个原型，包含一个示例Maven Webapp项目。 |
Maven - Snapshots
大型软件应用程序通常由多个模块组成，并且通常情况下，多个团队正在处理同一应用程序的不同模块。 例如，考虑一个团队正在作为app-ui项目（app-ui.jar:1.0）在应用程序的前端工作，他们正在使用数据服务项目（data-service.jar:1.0）。
现在可能发生的是，从事数据服务的团队正在快速进行错误修复或增强，他们几乎每隔一天就将库发布到远程存储库。
现在，如果数据服务团队每隔一天上传一个新版本，那么将出现以下问题 -
数据服务团队每次发布更新的代码时都应告诉app-ui团队。
app-ui团队需要定期更新他们的pom.xml以获得更新版本。
为了应对这种情况， SNAPSHOT概念发挥了作用。
什么是SNAPSHOT？
SNAPSHOT是一个特殊版本，表示当前的开发副本。 与常规版本不同，Maven在每个构建的远程存储库中检查新的SNAPSHOT版本。
现在，数据服务团队每次都会向存储库发布其更新代码的SNAPSHOT，比如数据服务:1.0-SNAPSHOT，替换旧的SNAPSHOT jar。
快照与版本
对于Version，如果Maven下载了上述版本，比如数据服务:1.0，它将永远不会尝试下载存储库中可用的较新1.0。 要下载更新的代码，数据服务版本将升级到1.1。
在SNAPSHOT的情况下，Maven将在每次app-ui团队构建项目时自动获取最新的SNAPSHOT（数据服务:1.0-SNAPSHOT）。
app-ui pom.xml
app-ui项目正在使用1.0-SNAPSHOT的数据服务。
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>app-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项目正在为每次微小变化发布1.0-SNAPSHOT。
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>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>
虽然，在SNAPSHOT的情况下，Maven每天自动获取最新的SNAPSHOT，但您可以强制maven使用-U开关将最新的快照构建下载到任何maven命令。
mvn clean package -U
让我们打开命令控制台，转到C:\ 》 MVN 》 app-ui目录并执行以下mvn命令。
C:\MVN\app-ui>mvn clean package -U
Maven将在下载最新的SNAPSHOT数据服务后开始构建项目。
[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]------------------------------------------------------------------------
Maven - Build Automation
构建自动化定义了在项目构建成功完成后依赖项目构建过程开始的场景，以确保依赖项目是稳定的。
Example
考虑一个团队正在开发一个项目bus-core-api ，其中另外两个项目是app-web-ui和app-desktop-ui 。
app-web-ui项目正在使用1.0-SNAPSHOT的bus-core-api项目。
<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项目正在使用1.0-SNAPSHOT的bus-core-api项目。
<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项目 -
<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>
现在， app-web-ui和app-desktop-ui项目的团队要求他们的构建过程应该在bus-core-api项目发生变化时启动。
使用快照，确保应该使用最新的bus-core-api项目，但为了满足上述要求，我们需要做一些额外的工作。
我们可以采取以下两种方式 -
在bus-core-api pom中添加一个post-build目标，以启动app-web-ui和app-desktop-ui构建。
使用像Hudson这样的持续集成（CI）服务器来自动管理构建自动化。
使用Maven
更新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>
<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>
让我们打开命令控制台，转到C:\ 》 MVN 》 bus-core-api目录并执行以下mvn命令。
>mvn clean package -U
Maven将开始构建项目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] ------------------------------------------------------------------
一旦bus-core-api构建成功，Maven将开始构建app-web-ui项目。
[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] ------------------------------------------------------------------
一旦app-web-ui构建成功，Maven将开始构建app-desktop-ui项目。
[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] -------------------------------------------------------------------
使用Maven持续集成服务
使用CI服务器比开发人员更受欢迎。 每次添加新项目（例如，app-mobile-ui）时，都不需要更新bus-core-api项目，作为bus-core-api项目的依赖项目。 Hudsion是一个用java编写的持续集成工具，它在servlet容器中，如Apache tomcat和glassfish应用服务器。 Hudson使用Maven依赖关系管理自动管理构建自动化。 以下快照将定义Hudson工具的作用。
哈德森认为每个项目都是作为工作。 一旦项目代码签入SVN（或映射到Hudson的任何源管理工具），Hudson就会启动它的构建作业，一旦这个作业完成，它就会自动启动其他依赖作业（其他依赖项目）。
在上面的例子中，当在SVN中更新bus-core-ui源代码时，Hudson开始构建。 一旦构建成功，Hudson会自动查找依赖项目，并开始构建app-web-ui和app-desktop-ui项目。
Maven - Manage Dependencies
Maven的核心功能之一是依赖管理。 一旦我们处理多模块项目（由数百个模块/子项目组成），管理依赖项是一项艰巨的任务。 Maven提供高度的控制来管理这些场景。
传递依赖发现
通常情况下，当一个库（比如A）依赖于其他库时，比如说B.如果另一个项目C想要使用A，那么该项目也需要使用库B.
Maven有助于避免此类要求发现所需的所有库。 Maven通过读取依赖项的项目文件（pom.xml），找出它们的依赖关系等来实现这一点。
我们只需要在每个项目pom中定义直接依赖。 Maven自动处理其余部分。
通过传递依赖性，包含的库的图形可以在很大程度上快速增长。 当存在重复的库时，可能会出现案例。 Maven提供了很少的功能来控制传递依赖的程度。
| Sr.No. | 功能和说明 |
|---|---|
| 1 | Dependency mediation 确定在遇到多个版本的工件时要使用的依赖项版本。 如果两个依赖版本在依赖关系树中处于相同的深度，则将使用第一个声明的依赖关系。 |
| 2 | Dependency management 直接指定在传递依赖项中遇到它们时要使用的工件的版本。 对于示例项目，C可以在其依赖关系管理部分中包括B作为依赖关系，并且直接控制在引用它时使用哪个版本的B. |
| 3 | Dependency scope 根据构建的当前阶段包含依赖项。 |
| 4 | Excluded dependencies 可以使用“排除”元素排除任何传递依赖性。 例如，A取决于B，B取决于C，那么A可以将C标记为排除。 |
| 5 | Optional dependencies 可以使用“可选”元素将任何传递依赖项标记为可选。 例如，A取决于B，B取决于C.现在B将C标记为可选。 然后A不会用C. |
依赖范围
可以使用如下所述的各种依赖性范围来限制传递依赖性发现。
| Sr.No. | 范围和描述 |
|---|---|
| 1 | compile 此范围表示在项目的类路径中可以使用依赖项。 它是默认范围。 |
| 2 | provided 此范围表示JDK或web-Server/Container在运行时提供依赖性。 |
| 3 | runtime 此范围表示编译不需要依赖项，但在执行期间需要依赖项。 |
| 4 | test 此范围表示依赖项仅适用于测试编译和执行阶段。 |
| 5 | system 此范围表示您必须提供系统路径。 |
| 6 | import 此范围仅在依赖项为pom类型时使用。 此范围指示应使用该POM的 |
依赖管理
通常，我们在一个共同项目下有一套项目。 在这种情况下，我们可以创建一个具有所有公共依赖关系的公共pom，然后创建这个pom，即子项目的poms的父级。 以下示例将帮助您理解此概念。
以下是上述依赖图的详细信息 -
- App-UI-WAR依赖于App-Core-lib和App-Data-lib。
- Root是App-Core-lib和App-Data-lib的父级。
- Root将Lib1，lib2，Lib3定义为其依赖项部分中的依赖项。
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>
现在，当我们构建App-UI-WAR项目时，Maven将通过遍历依赖图并构建应用程序来发现所有依赖项。
从上面的例子中，我们可以学习以下关键概念 -
可以使用父pom的概念将公共依赖项放置在单个位置。 Root项目中列出了App-Data-lib和App-Core-lib项目的依赖关系（参见Root的包装类型。它是POM）。
无需在App-UI-WAR中将Lib1，lib2，Lib3指定为依赖项。 Maven使用Transitive Dependency Mechanism来管理这些细节。
Maven - Deployment Automation
在项目开发中，通常部署过程包括以下步骤 -
将正在进行的所有项目的代码签入SVN（版本控制系统）或源代码存储库并对其进行标记。
从SVN下载完整的源代码。
构建应用程序。
将构建输出WAR或EAR文件存储到公共网络位置。
从网络获取文件并将文件部署到生产站点。
更新了包含应用程序的日期和更新版本号的文档。
问题声明 (Problem Statement)
上述部署过程通常涉及多个人。 一个团队可以处理代码的签入，其他团队可以处理构建等。 由于涉及手动工作并且由于多团队环境，很可能错过任何步骤。 例如，可能无法在网络计算机上替换旧版本，部署团队再次部署旧版本。
解决方案 (Solution)
通过组合以下内容自动化部署过程 -
- Maven，用于构建和发布项目。
- SubVersion，源代码存储库，用于管理源代码。
- Remote Repository Manager（Jfrog/Nexus）来管理项目二进制文件。
更新项目POM.xml
我们将使用Maven Release插件来创建自动发布过程。
例如: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>
在Pom.xml中，以下是我们使用的重要元素 -
| Sr.No. | 元素和描述 |
|---|---|
| 1 | SCM 配置SVN位置，Maven将检查源代码。 |
| 2 | Repositories 代码构建成功后，将存储构建的WAR/EAR/JAR或任何其他工件的位置。 |
| 3 | Plugin maven-release-plugin配置为自动化部署过程。 |
Maven Release插件
Maven使用maven-release-plugin执行以下有用的任务。
mvn release:clean
它会清除工作区，以防上次发布过程失败。
mvn release:rollback
在上次发布过程不成功的情况下，回滚对工作区代码和配置所做的更改。
mvn release:prepare
执行多个操作，例如 -
检查是否存在任何未提交的本地更改。
确保没有SNAPSHOT依赖项。
更改应用程序的版本并从版本中删除SNAPSHOT以进行发布。
将pom文件更新为SVN。
运行测试用例。
提交修改后的POM文件。
在subversion中标记代码
增加版本号并附加SNAPSHOT以备将来发布。
将修改后的POM文件提交给SVN。
mvn release:perform
使用先前定义的标记检出代码并运行Maven部署目标，将war或built artifact部署到存储库。
让我们打开命令控制台，转到C:\ 》 MVN 》bus-core-api目录并执行以下mvn命令。
>mvn release:prepare
Maven将开始构建该项目。 构建成功后，运行以下mvn命令。
>mvn release:perform
构建成功后，您可以验证存储库中上载的JAR文件。
Maven - Web Application
本章将教您如何使用Maven管理基于Web的项目。 在这里，您将学习如何创建/构建/部署和运行Web应用程序。
创建Web应用程序
要创建一个简单的Java Web应用程序，我们将使用maven-archetype-webapp插件。 所以，让我们打开命令控制台，转到C:\MVN目录并执行以下mvn命令。
C:\MVN>mvn archetype:generate
-DgroupId = com.companyname.automobile
-DartifactId = trucks
-DarchetypeArtifactId = maven-archetype-webapp
-DinteractiveMode = false
Maven将开始处理并将创建完整的基于Web的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-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] -------------------------------------------------------------------
现在转到C:/ MVN目录。 您将看到创建的Java应用程序项目，名为truck（在artifactId中指定），如以下快照中所指定。 以下目录结构通常用于Web应用程序 -
Maven使用标准目录布局。 使用上面的例子，我们可以理解以下关键概念 -
| Sr.No. | 文件夹结构和描述 |
|---|---|
| 1 | trucks 包含src文件夹和pom.xml。 |
| 2 | src/main/webapp 包含index.jsp和WEB-INF文件夹。 |
| 3 | src/main/webapp/WEB-INF 包含web.xml |
| 4 | src/main/resources 它包含图像/属性文件。 |
的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>
如果你观察到，你会发现Maven还创建了一个示例JSP Source文件。
打开C:\ 》 MVN 》 trucks 》 src 》 main 》 webapp 》文件夹，使用以下代码查看index.jsp -
<html>
<body>
<h2>Hello World!</h2>
</body>
</html>
构建Web应用程序
让我们打开命令控制台，转到C:\MVN\trucks目录并执行以下mvn命令。
C:\MVN\trucks>mvn clean package
Maven将开始构建该项目。
[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] -------------------------------------------------------------------
部署Web应用程序
现在将在C:\ 》 MVN 》 trucks 》 target 》文件夹中创建的trucks.war复制到您的webserver webapp目录并重新启动Web服务器。
测试Web应用程序
使用URL运行Web应用程序: http://《server-name》:《port-number》/trucks/index.jsp 。
验证输出。
Maven - Eclipse IDE
Eclipse提供了一个出色的插件m2eclipse ，它将Maven和Eclipse无缝集成在一起。
m2eclipse的一些功能如下 -
您可以从Eclipse运行Maven目标。
您可以使用自己的控制台查看Eclipse中Maven命令的输出。
您可以使用IDE更新maven依赖项。
您可以从Eclipse中启动Maven构建。
它基于Maven的pom.xml对Eclipse构建路径进行依赖管理。
它从Eclipse工作区解析Maven依赖项，而无需安装到本地Maven存储库（要求依赖项目位于同一工作区）。
它自动从远程Maven存储库下载所需的依赖项和源。
它提供了用于创建新Maven项目，pom.xml以及在现有项目上启用Maven支持的向导
它提供了对远程Maven存储库中依赖项的快速搜索。
安装m2eclipse插件
使用以下链接之一安装m2eclipse -
| 日食 | 网址 |
|---|---|
| Eclipse 3.5（Gallileo） | |
| Eclipse 3.6（Helios） |
以下示例将帮助您利用集成Eclipse和maven的好处。
在Eclipse中导入maven项目
打开Eclipse。
选择File 》 Import 》选项。
选择Maven项目选项。 单击“下一步”按钮。
选择项目位置，使用Maven创建项目。 我们在前面的章节中创建了Java项目消费者银行业务。 转到“创建Java项目”一章，了解如何使用Maven创建项目。
单击完成按钮。
现在，您可以在eclipse中看到maven项目。
现在，看看consumer Banking项目属性。 您可以看到Eclipse已将Maven依赖项添加到java构建路径。
现在，是时候使用eclipse的maven功能构建这个项目了。
- 右键单击consumerBanking项目以打开上下文菜单。
- 选择Run as option。
- 然后是maven包选项。
Maven将开始构建该项目。 您可以在Eclipse Console中看到输出如下 -
[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] -------------------------------------------------------------------
现在，右键单击App.java。 选择Run As选项。 然后选择Java Application 。
您将看到如下结果 -
Hello World!
Maven - NetBeans
NetBeans 6.7和更新版本内置了对Maven的支持。 如果是以前的版本，Maven插件可以在插件管理器中使用。 我们在此示例中使用NetBeans 6.9。
NetBeans的一些功能如下所示 -
您可以从NetBeans运行Maven目标。
您可以使用自己的控制台查看NetBeans中Maven命令的输出。
您可以使用IDE更新maven依赖项。
您可以从NetBeans中启动Maven构建。
NetBeans基于Maven的pom.xml自动执行依赖关系管理。
NetBeans从其工作区解析Maven依赖项，而无需安装到本地Maven存储库（要求依赖项目位于同一工作区）。
NetBeans自动从远程Maven存储库下载所需的依赖项和源。
NetBeans提供了用于创建新Maven项目的向导pom.xml。
NetBeans提供了一个Maven资源库浏览器，使您可以查看本地存储库和已注册的外部Maven存储库。
以下示例将帮助您利用集成NetBeans和Maven的好处。
在NetBeans中打开maven项目
打开NetBeans。
选择File Menu 》 Open Project选项”。
选择项目位置，使用Maven创建项目。 我们创建了一个Java Project consumerBanking。 转到“创建Java项目”一章，了解如何使用Maven创建项目。
现在，您可以在NetBeans中看到maven项目。 看看consumerBanking项目库和测试库。 您可以看到NetBeans已将Maven依赖项添加到其构建路径中。
在NetBeans中构建maven项目
现在，是时候使用NetBeans的maven功能构建这个项目了。
- 右键单击consumerBanking项目以打开上下文菜单。
- 选择“清理并构建”选项。
Maven将开始构建该项目。 您可以在NetBeans Console中查看输出，如下所示 -
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
------------------------------------------------------------------------
在NetBeans中运行应用程序
现在，右键单击App.java。 选择Run File as option。 您将在NetBeans控制台中看到结果。
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]
<b class="notranslate">Hello World!</b>
------------------------------------------------------------------------
BUILD SUCCESSFUL
------------------------------------------------------------------------
Total time: 1 second
Finished at: Thu Jul 19 14:18:13 IST 2012
Final Memory: 7M/64M
------------------------------------------------------------------------
Maven - IntelliJ IDEA IDE Integration
IntelliJ IDEA内置了对Maven的支持。 我们在此示例中使用IntelliJ IDEA Community Edition 11.1。
IntelliJ IDEA的一些功能如下 -
您可以从IntelliJ IDEA运行Maven目标。
您可以使用自己的控制台查看IntelliJ IDEA内Maven命令的输出。
您可以在IDE中更新maven依赖项。
您可以从IntelliJ IDEA中启动Maven构建。
IntelliJ IDEA基于Maven的pom.xml自动执行依赖关系管理。
IntelliJ IDEA从其工作区解析Maven依赖项，而无需安装到本地Maven存储库（要求依赖项目位于同一工作区）。
IntelliJ IDEA自动从远程Maven存储库下载所需的依赖项和源。
IntelliJ IDEA提供了用于创建新Maven项目的向导pom.xml。
以下示例将帮助您利用集成IntelliJ IDEA和Maven的优势。
在IntelliJ IDEA中创建一个新项目
我们将使用New Project Wizard导入Maven项目。
打开IntelliJ IDEA。
选择File Menu 》 New Project选项”。
从现有模型中选择导入项目。
- 选择Maven选项
选择项目位置，使用Maven创建项目。 我们创建了一个Java Project consumerBanking。 转到“创建Java项目”一章，了解如何使用Maven创建项目。
- 选择要导入的Maven项目。
- 输入项目名称，然后单击“完成”。
现在，您可以在IntelliJ IDEA中看到maven项目。 看看consumerBanking项目的外部库。 您可以看到IntelliJ IDEA已将Maven依赖项添加到Maven部分下的构建路径中。
在IntelliJ IDEA中构建maven项目
现在，是时候使用IntelliJ IDEA的功能构建这个项目了。
选择consumerBanking项目。
选择Buid menu 》 Rebuild Project选项”
您可以在IntelliJ IDEA控制台中查看输出
4:01:56 PM Compilation completed successfully
在IntelliJ IDEA中运行应用程序
选择consumerBanking项目。
右键单击App.java打开上下文菜单。
选择Run App.main()
您将在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
<b class="notranslate">Hello World!</b>
Process finished with exit code 0
