Maven官网笔记（学习翻译）

Maven官网笔记

1、What is Maven?

1.1 介绍（Introduction）

Maven，是一个表示知识积累的单词，最开始是使用在雅加达涡轮机项目中用于构建项目。开发者希望有一个统一的标准去构建项目，一种简洁的定义去规范项目，一个简单的方法去发布项目信息，还有就是展示JARS的关系通过这些项目。Maven就是一个这样的基于Java的构建和管理Java应用的工具。

1.2 Maven的目标（Maven’s Objectives）

Maven最主要的目标是允许开发者在最短的时间内了解开发的完整状态。为了实现这个目标，maven处理了几个关注的领域（maven的作用）：

使得构建过程变得简单
提供一个统一的构建系统
提供有效的项目信息
促进更好的开发体验

1.3 使得构建过程变得简单（Making the build process easy）

Maven目标是收集最好的开发实践原则，简化它并用于指导项目构建

1.4 提供了一个统一的构建系统(Providing a uniform build system)

Maven构建项目使用他独有的project object model （POM文件）和一系列插件。一旦你熟悉了一个Maven项目，那么你就知道了所有maven项目是如何构建的。这会节省很多时间，当你在浏览很多项目的时候。

1.5 提供有效的项目信息（Providing quality project information）

Maven提供了有用的项目信息，这些信息一部份来源于POM，一部分来源于你的工程源。

Maven能提供：

直接从源代码管理创建的日志(不是很清晰)
交叉引用资源（引用jar包
Mailing lists managed by the project
在项目中引用依赖
包含覆盖率的单元测试

1.6 提供最好的开发实践指南（Providing guidelines for best practices development）

Maven目标是收集当前的最好的开发实践原则，简化它并用于指导项目   举例，单元测试的规格，执行，和报告是构建maven正常生命周期的一部分。当前被用于的指导单元测试的最佳实践：

将测试代码和源代码分离保存源代码树中
使用测试命名约束来定位和执行测试
当运行测试准备工作时，有一个测试案例安装他们的环境来替代自定义构建。

Maven同样可以协助项目的工作流程比如发布和问题管理

Maven同样建议了关于 如果组织项目结构的许多的指导方针，一旦你学会了这种布局，你能快速导航其他的项目（如果这些项目使用的是Maven）由于Maven对项目结构有一种固执的偏见，所以一些项目可能因为历史原因不适合使用maven的结构。虽然maven被设计成能灵活的满足不同项目的需求，但是他不会满足如何一种场景而不损害其功能。如果你的项目有一个不同寻常的结构而不被maven识别，你可能不得不放弃某些功能特性并完全使用maven。

1.7 什么是Maven做不到的

你可能一些关于maven的事情如下所示：

maven是一个网站和文档工具
Maven拓展了ant，使你可以下载依赖
Maven是一个可重用的ant脚本的集合

虽然Maven做这些事情，正如你在上面看到的什么是maven？这些不是maven的唯一特性，并且他跟maven的目标有很大的不同。

2、特性概要 Feature Summary

以下是Maven的主要特性：

简单的项目安装的最好实践—开始一个新项目或者模块只要短短几秒
贯穿所有项目的一致使用方式–意味着开发人员不需要浪费实践学习项目
优质的依赖管理，包括自动更新，依赖闭包（也称为依赖传递项）
能轻松的在多个项目中同时生效
一个大并且是递增式的依赖仓库和元数据仓库，可以开箱即用，并与最大的开放源代码项目作出安排，以实时提供其最新版本
可拓展的，能够轻松的使用java和脚本语言的写插件
只需要很少的配置或无需变更配置就可以实时的使用最新的特性
Ant任务工作在maven以外的项目管理和发布
基于模型构建：maven可以构建任意数量的项目并转换成预定义的输出比如JAR包或者WAR包，或者其他基于元数据的项目，并且在大多数情况下不需要使用脚本。
项目信息一致性站点
发布管理和分发出版物
依赖关系管理

3、Maven使用手册

这个文档中心是为那些决定使用maven构建项目的人或者想要构建更快的项目又或者是已经使用maven，但是想要使用一些新的功能或者解决构建问题创建的。

Download Maven - maven下载
The 5 minute test - Learn how to use Maven in 5 minutes - 5分钟学习一下使用maven
Getting Started Tutorial - 如果你掌握了基础，这是一个深度的教程
Getting Help - 获取帮助

3.1 安装

自己看官方文档吧，挺简单的

3.2 运行（Running Apache Maven）

这个语法在maven中是被允许使用的
mvn [options] [<goal(s)>] [<phase(s)>]

所有可以使用的option命令的内置帮助，你可以使用这条命令获取

mvn -h

构建maven项目使用maven生命周期一种典型的调用

mvn verify

按照顺序来说，内置的生命周期和阶段如下：

clean - pre-clean、clean、post-clean
default - validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile, process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile, process-test-classes, test, prepare-package, package, pre-integration-test, integration-test, post-integration-test, verify, install, deploy
site - pre-site, site, post-site, site-deploy

项目生成打包输出并生成文档网站，将其发布到文档中心可以使用一下命令：

mvn clean deploy site-deploy

只是创建包并安装他到本地仓库以便其他工程的复用可以使用以下命令：

mvn verify

这是Maven项目中最常用的构建调用。

当不是在一整个项目上工作时，或者一些其他的情况，你可能希望调用由Maven的一部分实现的特定任务。这被称为 插件目标

mvn archetype:generate

或者

mvn checkstyle:check

3.3 配置

一些maven的配置文件，以及如何更加方便的使用maven

3.4 MAVEN和IDE的集成

现在国内一般都是idea了吧，idea拥有一些丰富的特性集成。

3.5 Maven支持和培训的提供者

    主要是一些公司

Takari
vogella GmbH
Web Age Solutions

4、稳定版本

主要提供了一些maven版本和适配的java版本https://maven.apache.org/docs/history.html

5、Maven Plugins

Maven核心是一个插件执行框架，所有的工作都是由插件。寻找一个特别的目标来执行？这个页面列出了核心插件和其他的一些插件。

他们分别是构建和报告插件

Build plugins: 构建插件将在构建期间执行，并且他们必须被定义在pom文件的标签下
Reporting plugins：报告插件将在站点生成时被执行，他们并且他们必须被定义在pom文件的标签下。因为报告插件的作用是生成站点的一部分，报告插件必须即是国际化又是本地化的，你能了解更多的本地化插件和如果获取帮助

由Maven项目支持

5.1 Core plugins：对应于默认的核心阶段的插件

Plugin	Type	Version	Description	Source Repository
clean	B	3.2.0	在构建后清除	Git / GitHub
Compile	B	3.10.1	编译java资源	Git / [GitHub]
deploy	B	3.0.0	将构建的模块发布到远程存储库	GitHub
failsafe	B	3.0.0-M8	在隔离的类加载器中运行Junit集成测试	GitHub
install	B	3.1.0	构建和安装到本地仓库	Github
resources	B	3.3.0	复制资源（包括JAR包）到输出的文件夹中
site	B	4.0.0	为当前的资源生成一个网站
surefire	B	3.0.0	在隔离的类加载器中运行Junit单元测试
verifier	B	1.1	对集成测试很有用-验证某些条件的存在

5.2 Packaging types/tools

这些插件与打包artifact相关 (应该将当前工程打包成一个指定文件类型)

Plugin	Type	Version	Description	Source Repository
ear	B	3.3.0	从当前工程生成一个EAR	GitHub
ejb	B	3.2.1	从当前工程构建一个EJB	GitHub
jar	B	3.3.0	从当前工程构建一个JAR	GitHub
rar	B	3.0.0	从当前工程构建一个RAR	GitHub
war	B	3.3.2	从当前工程构建一个war	GitHub
app-clinet/arc	B	3.1.0	从当前工程构建一个java ee的客户端应用	GitHub
shade	B	3.4.1	从当前工程构建一个包含依赖的Uber-JAR	GitHub
source	B	3.2.1	从当前工程构建一个source-JAR	GitHub
jlink	B	3.1.0	构建一个java运行时镜像	GitHub
jmod	B	3.0.0-alpha-1	构建java jmod文件	GitHub

5.3 Reporting plugins

生成报告的plugin，在pom文件进行配置以被用来生成报告，并运行在生成站点的生命周期下。

Plugin	Type	Version	Description	Source Repository
changelog	R	2.3	从你的scm生成一个最近的change列表	github
changes	B+R	2.12.1	从问题跟踪器和修改文档中生成报告	github
checkstyle	B+R	3.2.1	生成一个checkStyle的报告	github
doap	B	1.2	从POM文件从生成一个项目描述 a Description of a Project (DOAP)	github
javadoc	B+R	3.4.1	为工程生成一个javadoc文件	github
jdeps	B	3.1.2	在项目中运行jdk的jDep工具	github
jxr	R	3.3.0	生成源交叉引用	github
linkcheck	R	1.2	基于项目文档生成一个链接检查报告	github
pmd	B+R	3.20.0	生成一个PMD报告	github
project-info-reports	R	3.4.2	生成标准的项目报告	github
surefire-report	R	3.0.0-M8	基于单元测试结果生成一个报告	github

5.4 Tools

通常情况下，maven提供的多功能工具

Plugin	Type	Version	Description	Source Repository
antrun	B	3.1.0	从某个构建的阶段中运行一组ant任务	github
artifact	B	3.3.0	管理工件任务，比如构建信息	github
archetype	B	3.2.1	从原型中生成一个项目框架结构	github
assembly	B	3.4.2	生成源文件集或者二进制文件	github
enforcer	B	3.1.0	环境约束检查，由用户自定义规则执行
dependency	B+R	3.5.0	依赖操作（复制、解包）和分析
gpg	B	3.0.1	为artifact（工件）和pom文件创建签名
help	B	3.3.0	为项目获取工作环境的信息
invoker	B+R	3.4.0	运行一组maven工程并校验输出
jarsigner	B	3.0.0	签署和校验项目的artifacts
jdeprscan	B	3.0.0-alpha-1	在项目中运行 JDK’的JDeprScan工具
patch	B	1.2	使用gun补丁工具将补丁文件应用到源码中
plugin	B+R	3.7.1	为源代码树中的任何mojo创建一个Maven插件描述符，并将其包含在JAR中。
pdf	B	1.6.1	生成项目文档的PDF版本
release	B	3.0.0	发布当前项目，更新pom文件并在SCM中标记
remote-resources	B	3.0.0	复制远程资源输出到artifact对应的文件夹中
scm	B	2.0.0-M3	执行当前项目的SCM命令
scm-publish	B	3.1.0	将你的maven网站发布到scm中
scripting	B	3.0.0	Maven脚本插件根据JSR223包装脚本API。
stage	B	1.0	协助发布和推广
toolchains	B	3.1.0	允许跨插件共享配置
wrapper	B	3.1.1	下载和解包maven包装发行版本

5.5 Retired（退休的插件）

既然都退休了 ，我就暂时不写了哈

5.6 Outside The Maven Land

这里是一些可以在github 中的[MojoHaus](https://github.com/mojohaus) project 中获得的插件。

以下是几种常见的：

Plugin	Description
animal-sniffer	构建API的签名，并根据签名检查你的类
build-helper	附加要生成的额外工件和源文件夹
buildplan	检查构建的生命周期
castor	使用Castor从XSD生成资源
clirr	使用clirr比较二进制和源文件
javacc	使用javaCC语法生成源文件
jdepend	使用jdepend生成一个关于代码度量的报告
nar-maven-plugin	编译C，C++，Fortran的不同架构
native	用本机编译器编译C和C++代码
sql	从文件中执行sql脚本
taglist	根据代码中的标记生成任务列表
versions	管理你的项目、模块和插件的版本

5.7 Misc

一些别的工程提供的他们自己maven插件，包含一下：

Plugin	Maintainer	Description
cargo	Cargo Project	启动/停止/配置J2EE容器并部署到它们。
clover	Atlassian Clover	生成一个Clover的报告
jetty	Jetty Project	运行一个jetty容器以便快速开发webapps
jalopy	Triemax	使用Jalopy来格式化源代码。
rat	Apache Creadur Project	发布审计工具（RAT）来验证文件。
Genesis Plugins	Apache Geronimo Project	在工件中验证文件合法
Apache Tomcat	Apache Tomcat Project	运行Apache Tomcat容器以快速开发webapp。
CycloneDX	CycloneDX Project	生成CycloneDX格式的软件物料清单（SBOM）。
pgpgverify	Simplify4U	验证所有项目依赖的PGP签名。

6、Available Extensions （可用的拓展）

maven的核心是一款插件执行框架，他的许多工作都是基于插件展开。然而，有了拓展功能就相当于有个钩子进入maven，比如操纵生命周期函数。

7、用户中心（重点）

7.1 5分钟学会使用maven

7.1.1 Prerequisites

你必须懂得如何安装软件到你的电脑上。如果你不知道如何安装，请询问你的办公室或者学校周围的人。又或者花钱请人帮你解决这个问题。

Maven邮件列表不是解决这些意见的最好场所。

7.1.2 Installation 安装

Maven是一个Java工具，因此您必须安装Java才能继续。

首先，下载Maven并按照安装说明进行安装。之后，在终端或命令提示符中键入以下内容：

mvn --version

如果成功打印版本说明安装成功。

如果您使用的是Windows，您应该查看Windows先决条件，以确保您已准备好在Windows上使用Maven。

7.1.3 创建一个项目

你需要一个目录放置你的项目，创建一个文件夹并执行在这个文件夹中执行一个脚本或者执行以下命令：
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false
如果你刚刚才安装maven，第一次运行需要一段时间。因为maven会下载很多*artifacts* （插件和文件）到你本地的仓库。在命令成功之前，您可能还需要执行几次。这是因为远程服务器可能会在您的下载完成之前超时。别担心，有办法解决的。你会注意到generate goal创建了一个与artifactId同名的目录。进入该目录。在此目录下，您将注意到以下标准的Maven项目结构。
my-app
|-- pom.xml
`-- src|-- main|   `-- java|       `-- com|           `-- mycompany|               `-- app|                   `-- App.java`-- test`-- java`-- com`-- mycompany`-- app`-- AppTest.java
src/main/java目录包含项目的源代码，src/test/java目录包含测试源，pom.xml文件是项目的项目对象模型，或POM。

7.1.4 The POM

pom.xml文件是maven的配置的核心文件。它是一个单一的配置文件，包含了以您想要的方式构建项目所需的大部分信息。POM是巨大的，它的复杂性可能令人望而生畏，但还没有必要理解所有的复杂问题才能有效地使用它。

7.1.5 我们刚刚做了什么

你执行了Maven目标archetype:generate的命令，并将各种参数传递给目标。前缀*archetype* 是目标提供一个插件。如果你熟悉ant，你可以把它想象成类似于一个任务。这个 *archetype:generate*目标创建一个简单的基于 [maven-archetype-quickstart](https://maven.apache.org/archetypes/maven-archetype-quickstart/) archetype的工程。现在只需要说，插件是一个具有一般共同目的的目标的集合。例如jboss-maven-plugin，其目的是“处理各种jboss项”。

7.1.6 构建项目

mvn package

这个命令会打印输出各种动作，最后的输出如下

 ...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  2.953 s
[INFO] Finished at: 2019-11-24T13:05:10+01:00
[INFO] ------------------------------------------------------------------------

不同于第一个已执行的命令 (archetype:generate)，第二次只是一个简单的单词 - package。相比教goal，他只是一个phase（环节）。phase是构建生命周期中一个步骤，构建生命周期是有序的。当一个生命周期的环节被执行时，他必须要执行完这个生命周期当前环节的前置环节才可以。比如说，你执行了一个compile环节，实际上你执行的环节有：

validate
generate-sources
process-sources
generate-resources
process-resources
compile

您可以使用以下命令测试新编译和打包的JAR:

java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App

它将打印：

Hello World!

7.1.7 Java 9 or later

说了一些关于java之后的特性。

7.1.8 Running Maven Tools

Maven环节 - 尽管很难列出一个全面的列表，但是这是最常见的执行生命周期的环节

validate: 验证项目是正确的，所有必要的信息都是可用的
compile: 编译项目的源代码
test: 使用合适的单元测试框架对编译后的源代码进行测试。这些测试不应该要求打包或部署代码。
package: 获取编译后的代码，并将其打包为可分发的格式，例如JAR。
integration-test: 处理包，并在必要时将其部署到可以运行集成测试的环境中
verify:进行任何检查，以验证包装是否有效并符合质量标准
install:将包安装到本地存储库中，以便在本地其他项目中作为依赖项使用
deploy: 在集成或发布环境中完成，将最终的包复制到远程存储库，以便与其他开发人员和项目共享。

除了上面的默认列表外，还有两个值得注意的Maven生命周期。他们是：

clean: 清除先前生成创建的工件
site: 生成此项目的站点文档

阶段的执行实际上也会在底层映射到goal上去，每个阶段执行的具体目标取决于项目的包类型。

值得注意的一件有趣的事情是，阶段和目标可能是按顺序执行的。

mvn clean dependency:copy-dependencies package

此命令将清除项目、复制依赖项并打包项目（当然，执行打包之前的所有阶段）。

7.2 Maven开始使用指南

本指南的目的是为那些第一次使用Maven的人提供参考，但也可以作为一本包含独立的参考资料和常见用例的解决方案的菜谱。对于第一次使用的用户，建议您按顺序逐步浏览材料。对那些熟悉maven的用户，本指南致力于为手头的需求提供快速的解决方案。此时假定您已经下载了Maven并在本地计算机上安装了Maven。如果您还没有这样做，请参阅下载和安装说明。好了，现在你已经安装了Maven，我们可以开始了。在开始我们的示例之前，我们将非常简要地回顾一下Maven是什么，以及它如何帮助您与团队成员的日常工作和协作。当然，Maven适用于小型项目，但是Maven通过允许团队成员关注项目涉众的需求来帮助团队更有效地运作。您可以将构建基础设施留给Maven！

什么是Maven？

乍看之下，Maven展现出了很多东西，但简单地说，Maven试图将模式应用于项目的构建基础设施，以便通过提供使用最佳实践的清晰路径来提高理解力和生产力。Maven本质上是一个提供了许多办法的帮助管理的项目管理和理解工具：

Builds
Documentation
Reporting
Dependencies
SCMs
Releases
Distribution

我怎么通过Maven优化我的开发过程？

Maven可以通过采用标准约定和实践来加速您的开发周期，同时帮助您获得更高的成功率，从而为您的构建过程带来好处。现在我们已经介绍了一点Maven的历史和目的让我们进入一些真实的例子，让您与Maven一起运行！

我如何设置maven？

Maven的默认值通常已经足够了，但如果您需要更改缓存位置或在HTTP代理之后，则需要创建配置。有关详细信息，请参阅配置Maven指南。

我如何创建一个一个maven工程？

详情见章节7.1.3

解析一下POM文件的结构（重点）：

pom.xml包含此项目的项目对象模型（POM）。POM在maven中基本的工作单元。记住这一点很重要，Maven是以项目为核心的，maven中的一切都围绕着项目这个概念。简而言之，POM中包含着许多非常重要的关于你项目的信息，并且在其中能够非常简单的找到关于你项目的关联的一切。。理解pom文件是非常重要的。

这是一个非常简单的POM，但仍然显示每个POM包含的关键元素，因此让我们逐一介绍，以熟悉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.mycompany.app</groupId><artifactId>my-app</artifactId><version>1.0-SNAPSHOT</version><name>my-app</name><!-- FIXME change it to the project's website --><url>http://www.example.com</url><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><maven.compiler.source>1.7</maven.compiler.source><maven.compiler.target>1.7</maven.compiler.target></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.11</version><scope>test</scope></dependency></dependencies><build><pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->... lots of helpful plugins</pluginManagement></build>
</project>

project：这是所有Maven pom.xml文件中的顶级元素。
modelVersion This element indicates what version of the object model this POM is using. The version of the model itself changes very infrequently but it is mandatory in order to ensure stability of use if and when the Maven developers deem it necessary to change the model.
groupId This element indicates the unique identifier of the organization or group that created the project. The groupId is one of the key identifiers of a project and is typically based on the fully qualified domain name of your organization. For example org.apache.maven.plugins is the designated groupId for all Maven plugins.
artifactId This element indicates the unique base name of the primary artifact being generated by this project. The primary artifact for a project is typically a JAR file. Secondary artifacts like source bundles also use the artifactId as part of their final name. A typical artifact produced by Maven would have the form -. (for example, myapp-1.0.jar).
version This element indicates the version of the artifact generated by the project. Maven goes a long way to help you with version management and you will often see the SNAPSHOT designator in a version, which indicates that a project is in a state of development. We will discuss the use of snapshots and how they work further on in this guide.
name This element indicates the display name used for the project. This is often used in Maven’s generated documentation.
url This element indicates where the project’s site can be found. This is often used in Maven’s generated documentation.
properties This element contains value placeholders accessible anywhere within a POM.
dependencies This element’s children list dependencies. The cornerstone of the POM.
build This element handles things like declaring your project’s directory structure and managing plugins.

我如何去编译我应用的源代码？

mvn compile

我应该怎样去编译我的测试源代码并运行我的单元测试

mvn test

什么是快照版本？

pom.xml文件中的版本标记的值有一个后缀：-SNAPSHOT。这个`SNAPSHOT`表示链接了还在开发分支中的最新代码并且不保证代码是稳定且不会改变的。相反，“release”版本（不带SNAPSHOT后缀的任何版本值）中的代码是不变的。换句话说，SNAPSHOT版本是最终“发布”版本之前的“开发”版本。SNAPSHOT比其发布版本“旧”。

如何使用插件？

每当您想要自定义Maven项目的构建时，都可以通过添加或重新配置插件来完成。

对于本例，我们将配置Java编译器以允许JDK 5.0源代码。这很简单，只需将其添加到POM:

<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.3</version><configuration><source>1.5</source><target>1.5</target></configuration></plugin></plugins>
</build>
您会注意到Maven中的所有插件看起来都很像一个依赖项——在某些方面它们确实如此。这个插件将被自动下载和使用——包括一个特定的版本，如果你要求它（默认是使用最新可用的）。configuration元素将给定的参数应用于编译器插件中的每个目标。在上面的例子中，编译器插件已经被用作构建过程的一部分，这只是改变了配置。也可以在流程中添加新的目标，并配置特定的目标。有关这方面的信息，请参阅构建生命周期简介。要了解插件可用的配置，您可以查看插件列表并导航到您正在使用的插件和目标。有关如何配置插件的可用参数的一般信息，请参阅配置插件指南。

如何添加添加resource到我们的jar中呢？

您可以在下面的示例中看到，我们已经添加了目录${basedir}/src/main/resources，我们将任何希望打包到JAR中的资源放置到该目录中。Maven使用的简单规则是：将${basedir}/src/main/resources目录中的任何目录或文件打包到JAR中，其结构与从JAR底部开始的结构完全相同。

如何过滤资源文件

如何使用外部文件定义的变量或者外部文件使用pom内部定义变量，只需将pom.xml中的资源目录的过滤设置为true：
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.mycompany.app</groupId><artifactId>my-app</artifactId><version>1.0-SNAPSHOT</version><packaging>jar</packaging><name>Maven Quick Start Archetype</name><url>http://maven.apache.org</url><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.11</version><scope>test</scope></dependency></dependencies><build><resources><resource><directory>src/main/resources</directory><filtering>true</filtering></resource></resources></build>
</project>

如何使用外部依赖项

对于每一个依赖，你最起码需要定义四项：groupId, artifactId, version, and scope

前三项就和pom文件中的定义的类似，而第四项scope表示你的项目要如何使用依赖，取值有三个compile， test, and runtime

远程mavn仓库url：

https://repo.maven.apache.org/maven2/

7.2.1 命名规范

groupId, artifactId, and version命名约定指南

groupId：在所有项目中唯一的标识你的项目，groupId应该遵守java的包命名规范。举例：org.apache.maven，org.apache.commons
artifactId: 是不带版本的jar包的名字，如果你创建了他
version

7.2.2 介绍构建生命周期

一共有三个内置的构建生命周期：

default, clean and site

default：处理你项目的发布
clean：处理你项目的清理
site：创建你项目的相关的网站

一个构建生命周期是由多个阶段组成

一个构建生命周期都是由许多个不同的构建阶段清单组成

default lifecycle 包含了一下阶段：

validate -检查项目正确并且所以信息是可用的
compile - 编译项目源代码
test - 使用测试合适的测试框架测试编译后的源代码，这个测试可以在没有打包时进行
package - 将源代码打包成发布格式，比如jar包
verify - 对集成测试的结果进行任何检查，以确保满足质量标准
install -安装包到本地仓库，可以本地中其他项目作为依赖使用
deploy - 构建完成，推送包到远程仓库提供给别人使用

一个构建阶段由插件目标组成（Plugin Goals）

如果一个插件目标没有被绑定到构建阶段中，那么它可以用命令被调用。但是如果同一个目标被绑定到了多个构建阶段中，那么他在生命周期中是可以被重复调用的。

举例

mvn clean dependency:copy-dependencies package

如果你想使用插件并将插件指定在别的阶段中使用，下面是实例：

 <plugin><groupId>com.mycompany.example</groupId><artifactId>display-maven-plugin</artifactId><version>1.0</version><executions><execution><phase>process-test-resources</phase><goals><goal>time</goal></goals></execution></executions></plugin>

7.2.3 Lifecycle Reference

下面列出了默认生命周期、清理生命周期和站点生命周期的所有构建阶段，它们按照指定的顺序执行。

clean Lifecycle

Phase（阶段）	Description（描述）
pre-clean	在实际项目清理之前执行所需的流程
clean	删除以前生成的所有文件
post-clean	执行完成项目清理所需的流程

Default Lifecycle

Phase（阶段）	Description（描述）
validate	验证项目是正确的，所有必要的信息都是可用的。
initialize	初始化构建状态，例如设置属性或创建目录。
generate-sources	生成包含在编译中的任何源代码。
process-sources	处理源代码，例如过滤任何值。
generate-resources	生成包含在包中的资源。
process-resources	将资源复制并处理到目标目录，准备打包。
compile	编译项目的源代码。
process-classes	对编译生成的文件进行后处理，例如对Java类进行字节码增强。
generate-test-sources	生成包含在编译中的任何测试源代码。
process-test-sources	处理测试源代码，例如过滤任何值。
generate-test-resources	创建用于测试的资源。
process-test-resources	将资源复制并处理到测试目录中。
test-compile	将测试源代码编译到测试目录中
process-test-classes	对测试编译生成的文件进行处理，例如对Java类进行字节码增强。
test	使用合适的单元测试框架运行测试。这些测试不应该要求打包或部署代码。
prepare-package	在实际包装之前执行任何必要的操作以准备包装。这通常是软件包的解压缩、处理版本。
package	获取编译后的代码，并将其打包为可分发的格式，例如JAR。
pre-integration-test	在执行集成测试之前执行所需的操作。这可能涉及到诸如设置所需的环境等事情。
integration-test	处理包，并在必要时将其部署到可以运行集成测试的环境中。
post-integration-test	执行集成测试执行后所需的操作。这可能包括清理环境。
verify	运行任何检查，以验证包是有效的，并符合质量标准。
install	安装包到本地仓库
deploy	推送包到远程仓库

Site Lifecycle

Phase	Description
`pre-site`	在实际项目现场生成之前执行所需的流程
`site`	生成项目的站点文档
`post-site`	执行完成站点生成和准备站点部署所需的流程
`site-deploy`	将生成的站点文档部署到指定的Web服务器

7.2.4 内置生命周期绑定

每个阶段默认绑定了目标，对于默认的生命周期，他们默认绑定的取决于 the packaging value.（jar | war | pom）。

Clean Lifecycle Bindings

Phase	plugin:goal
`clean`	`clean:clean`

Default Lifecycle Bindings - Packaging ejb / ejb3 / jar / par / rar / war

Phase	plugin:goal
`process-resources`	`resources:resources`
`compile`	`compiler:compile`
`process-test-resources`	`resources:testResources`
`test-compile`	`compiler:testCompile`
`test`	`surefire:test`
`package`	`ejb:ejb` or `ejb3:ejb3` or `jar:jar` or `par:par` or `rar:rar` or `war:war`
`install`	`install:install`
`deploy`	`deploy:deploy`

Default Lifecycle Bindings - Packaging ear

Phase	plugin:goal
`generate-resources`	`ear:generate-application-xml`
`process-resources`	`resources:resources`
`package`	`ear:ear`
`install`	`install:install`
`deploy`	`deploy:deploy`

Default Lifecycle Bindings - Packaging maven-plugin

Phase	plugin:goal
`generate-resources`	`plugin:descriptor`
`process-resources`	`resources:resources`
`compile`	`compiler:compile`
`process-test-resources`	`resources:testResources`
`test-compile`	`compiler:testCompile`
`test`	`surefire:test`
`package`	`jar:jar` and `plugin:addPluginArtifactMetadata`
`install`	`install:install`
`deploy`	`deploy:deploy`

Default Lifecycle Bindings - Packaging pom

Phase	plugin:goal
`package`
`install`	`install:install`
`deploy`	`deploy:deploy`

Site Lifecycle Bindings

Phase	plugin:goal
`site`	`site:site`
`site-deploy`	`site:deploy`

7.3 介绍pom文件

什么是POM文件

A Project Object Model （POM）是Maven中基本工作单元。他是一个包含了项目信息和可以帮助maven构建项目的配置信息的xml文件。当执行一个任务或者目标时，Maven会寻找POM文件所在的当前目录，读取POM中的配置信息，并执行目标。

超级POM - Super POM

这个超类的POM是Maven默认的POM，所有的用户自己创建的pom都会继承这个POM文件

最小POM - Minimal POM

POM的最低要求如下：

project - root
modelVersion - should be set to 4.0.0
groupId - the id of the project’s group.
artifactId - the id of the artifact (project)
version - the version of the artifact under the specified group

实例：

<project><modelVersion>4.0.0</modelVersion><groupId>com.mycompany.app</groupId><artifactId>my-app</artifactId><version>1</version>
</project>

上述示例的完全限定工件名时com.mycompany.app:my-app:1

如果最小POM没有定义指定仓库，那么你使用最小POM构建项目时，他会从Super POM中继承仓库相关的配置

项目继承 - Project Inheritance

POM中的元素合并如下所示

dependencies
developers and contributors
plugin lists (including reports)
plugin executions with matching ids
plugin configuration
resources

项目合并 - Project Aggregation

项目聚合类似于项目继承，不同的是不用在模块中指明父级pom，但是必须在父POM中指定modules。当maven 命令行执行到父POM中时，命令同样也会执行到Maven到父中指定的modules中。

要使用工程聚合，必须遵守下面两个规则：

父级的pom的打包类型必须指定为 POM
在父级中指明子module的文件夹位置

工程插值和变量 - Project Interpolation and Variables

Maven中想要做到的是一套配置可以被反复复用，当你想要在不同位置使用一个相同的值时，这个值应该只需要被定义一次。

系统自带的变量 - Project Model Variables

模型中作为单个值元素的任何字段都可以作为变量引用。例如，${project.groupId}、${project.version}、${project.build.sourceDirectory}等等。请参考POM参考以查看完整的属性列表。

自定义属性 - Properties

你可以在Properties标签中定义

<project>...<properties><mavenVersion>3.0</mavenVersion></properties><dependencies><dependency><groupId>org.apache.maven</groupId><artifactId>maven-artifact</artifactId><version>${mavenVersion}</version></dependency><dependency><groupId>org.apache.maven</groupId><artifactId>maven-core</artifactId><version>${mavenVersion}</version></dependency></dependencies>...
</project>

7.4 构建配置 - Build Profiles

主要是将了复用配置的问题

7.5 文件布局

使用相同的文件布局，可以使开发者快速上手不同项目。

目录	作用
`src/main/java`	应用源码
`src/main/resources`	应用资源
`src/main/filters`	Resource filter files
`src/main/webapp`	Web应用资源
`src/test/java`	测试源码
`src/test/resources`	测试使用资源
`src/test/filters`	Test resource filter files
`src/it`	集成测试
`src/assembly`	组件描述符
`src/site`	站点
`LICENSE.txt`	项目许可
`NOTICE.txt`	项目依赖库的通知和属性
`README.txt`	项目readme

7.6 依赖机制

7.5.1 依赖传递

伴随着依赖传递，依赖图会迅速增长。基于这个原因，有一个补充特性限制了依赖

Dependency mediation（依赖中介） - maven会选择最近的定义的依赖在当前项目的依赖树中。
“nearest definition
Dependency management
Dependency scope
Excluded dependencies
Optional dependencies

Dependency Scope

指定依赖范围可以限制依赖传递，有六种范围

compile
provided
runtime
test
system
import

Dependency Management

Importing Dependencies （导入依赖）

如果同时导入依赖

x 包含 dependency a v1.1

y包含 dependency a v1.2

z导入 x和y，会使用的依赖是a v1.1 （使用优先定义的）

解析过程是递归的

Bill of Materials (BOM) POMs

使用模板模式，可以统一使用一个bom来将多个父项目的pom统一出一个模板，让所有父pom都继承自他。也可以使用导入，来使用物料单中定义的属性。

导入pom文件注意事项：

不要导入当前pom指定的子模块pom文件
不要将导入的pom作为当前pom的父级
当引用POM具有传递依赖关系的工件时，项目需要将这些工件的版本指定为托管依赖

System Dependencies

7.7 Getting Help

maven疑难杂症：https://maven.apache.org/users/getting-help.html

以及如果帮助maven项目组修复问题

7.8 running maven

使用mvn verify 命令就可以运行绝大部分项目。

8.Configuring Plug-ins

8.1 Introduction

在maven中主要分为两种插件：

Build plugins：构建插件，被定义在<build>标签中，在构建中执行
Reporting plugins：报告插件，被定义在reporting插件中，在生成网站环节执行

每一个插件最少含有3个信息：groupId, artifactId, version。并且最好在指定插件的时候指定好版本，以保证构建的可复用性。

8.2 Generic Configuration

maven中配置文件的MOJO类的映射规则，每一个mojo就标识一个插件

MOJO类

@Mojo( name = "query" )
public class MyQueryMojoextends AbstractMojo
{@Parameter(property = "query.url", required = true)private String url;@Parameter(property = "timeout", required = false, defaultValue = "50")private int timeout;@Parameter(property = "options")private String[] options;public void execute()throws MojoExecutionException{...}
}

pom文件

<project>...<build><plugins><plugin><artifactId>maven-myquery-plugin</artifactId><version>1.0</version><configuration><url>http://www.foobar.com/query</url><timeout>10</timeout><options><option>one</option><option>two</option><option>three</option></options></configuration></plugin></plugins></build>...
</project>

映射关系是不是很简单，就是从标签名映射到对应字段。

如果直接使用命令行执行MOJO，其参数一般由系统变量替代configuration中内容，

mvn myquery:query -Dquery.url=http://maven.apache.org

系统属性的名称不一定与mojo参数的名称匹配。虽然这里是url匹配query.url

help goal

大部分maven插件有一个help goal来打印插件的描述和参数，比如要察看javadoc 的目标：

mvn javadoc:help -Ddetail -Dgoal=javadoc

Configuring Parameters

描述了一些参数配置的映射规则，这里不再赘述

复杂对象映射需要注意三点：

必须有一个私有字段（对象）对应映射元素
实例化的对象必须和MOJO在一个包中
如果你的复杂对象需要使用继承或者和MOJO不在一个包中，使用implementation属性指定

实例：

<project>
...
<configuration><person implementation="com.mycompany.mojo.query.SuperPerson"><firstName>Jason</firstName><lastName>van Zyl</lastName></person>
</configuration>
...
</project>

8.3 Configuring Build Plugins

配置生成插件，在build元素中配置即可

1、使用executions标签

<project>...<build><plugins><plugin>...<executions><execution><id>execution1</id><phase>test</phase>...</execution><execution><id>execution2</id><phase>install</phase><configuration><url>http://www.bar.com/query</url><timeout>15</timeout><options><option>four</option><option>five</option><option>six</option></options></configuration><goals><goal>query</goal></goals></execution></executions></plugin></plugins></build>...
</project>

如果你想使用execution1配置，执行以下命令即可

mvn myquery:query@execution1

2、Using the dependencies Tag

如果你想要你的插件使用jar包指定版本，使用dependencies 标签即可

<project>...<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-antrun-plugin</artifactId><version>1.2</version>...<dependencies><dependency><groupId>org.apache.ant</groupId><artifactId>ant</artifactId><version>1.7.1</version></dependency><dependency><groupId>org.apache.ant</groupId><artifactId>ant-launcher</artifactId><version>1.7.1</version></dependency></dependencies></plugin></plugins></build>...
</project>

3、使用inherited在构建项目中

默认情况下，插件配置会自动传递到子级pom文件中，如果你不想要子pom文件继承配置，可以使用inherited标签

<project>...<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-antrun-plugin</artifactId><version>1.2</version><inherited>false</inherited>...</plugin></plugins></build>...
</project>

8.4 Configuring Reporting Plugins

配置报告插件，这个没啥好讲的感觉也没啥应用的地方。

9、Creating a site

关于site相关配置的后续有空再做补充，主要是感觉暂时没有用到。

Creating site 导航：https://maven.apache.org/guides/mini/guide-site.html

markup Format：https://maven.apache.org/doxia/references/index.html

10、Introduction to Archetypes

介绍Archetypes

10.1 什么是Archetypes

Archetypes：原型，一个项目模板工具，使用原型创建项目，可以帮助开发者快速搭建项目并启动。

主要好处有三点：

原型可以快速搭建，并启动项目
可以让开发者快速了解maven的优点
原型可复用，可以在开发完成后被组织内其他开发者使用。原型也可以收集有用的功能补充自身

10.2 创建Archetypes

使用以下命令就可以调用原型创建项目

mvn archetype:generate

10.3 Maven提供的Archetypes

Archetype ArtifactIds（原型工件）	Description（描述）
maven-archetype-archetype	用于生成简单原型工程示例的原型
maven-archetype-j2ee-simple	用于生成简单j2ee工程示例的原型
maven-archetype-mojo	一个原型来生成一个样本Maven插件。
maven-archetype-plugin	生成示例Maven插件的原型。
maven-archetype-plugin-site	生成一个示例Maven插件站点的原型。
maven-archetype-portlet	生成示例JSR-268 Portlet的原型。
maven-archetype-quickstart	生成样本的原型Maven项目。
maven-archetype-simple	生成简单Maven项目的原型。
maven-archetype-site	生成一个示例Maven站点的原型，该站点演示了一些受支持的文档类型，如APT、XDoc和FML，并演示了如何i18n您的站点。
maven-archetype-site-simple	生成样本的原型Maven的站点。
maven-archetype-webapp	生成示例Maven Webapp项目的原型。

指定原型创建项目

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-archetype

10.4 什么构成了原型

由JAR包和一系列描述原型的元数据组成，还有就是一组 Velocity模板构成了原型项目

10.5 手动创建Archetypes

创建一个原型是一个非常简单的过程，一个原型由以下的东西组成

an archetype descriptor ：原型描述文本，archetype-metadata.xml 位于文件夹: src/main/resources/META-INF/maven/
从原型插件中复制的原型文件（文件位置：src/main/resources/archetype-resources/）
原型pom文件(pom文件位于src/main/resources/archetype-resources)
a pom for the archetype （POM位于root目录中）

两种办法创建原型工程：

1、手动创建一个文件结构后：

2、不需要手动为原型创建文件夹，只需要使用命令

mvn archetype:generate -DgroupId=[your project's group id] -DartifactId=[your project's artifact id] -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-archetype

然后创建archetype-metadata.xml

<archetype-descriptorxmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.1.0 https://maven.apache.org/xsd/archetype-descriptor-1.1.0.xsd"name="quickstart"><fileSets><fileSet filtered="true" packaged="true"><directory>src/main/java</directory></fileSet><fileSet><directory>src/test/java</directory></fileSet></fileSets>
</archetype-descriptor>

修改src/main/resources/archetype-resources/pom文件，这个生成工程中的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/maven-v4_0_0.xsd"><modelVersion>4.0.0</modelVersion><groupId>${groupId}</groupId><artifactId>${artifactId}</artifactId><version>${version}</version><packaging>jar</packaging><name>${artifactId}</name><url>http://www.myorganization.org</url><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency></dependencies>
</project>

使用自定义原型工程创建工程：

mvn archetype:generate -DarchetypeGroupId=com.cdeo -DarchetypeArtifactId=createmvn -DarchetypeVersion=1.0-SNAPSHOT -DgroupId=com.cdeo -DartifactId=mvninstance

自己玩了一下，感觉还挺好玩的，记得修改一下定义的代码的包路径（如果你修改了src/main/resources/archetype-resources/pom这个文件的话），这个需要改成你想要的指定代码路径

package $maven-archetype;

11、 Repositories

mirro settings

使用镜像设置的三个原因：

有一个同步的且更快的镜像在互联网上
你想使用一个特殊的仓库代替你的本地仓库
使用一个仓库管理工具提供一个本地缓存到镜像上

Security and Deployment Settings

从仓库到发布会被定义为distributionManagement 章节中，然而，你不能也不会将用户密码等其他安全设置信息上传。你需要用id来定义的你的设置来作为唯一匹配你的仓库

<settings>..<servers><server><id>repo1</id><username>repouser</username><!-- other optional elements:<password>my_login_password</password><privateKey>/path/to/identity</privateKey> (default is ~/.ssh/id_dsa)<passphrase>my_key_passphrase</passphrase>--></server></servers>..
</settings>

Password Encryption

1、how to create a master password

mvn --encrypt-master-password <password>

存储在${user.home}/.m2/settings-security.xml 这个文件下

<settingsSecurity><master>{jSMOWnoPFgsHVpMvz5VrIt5kRbzGpI8u+9EF1iFQyJQ=}</master>
</settingsSecurity>

2、如何加密服务器密码

mvn --encrypt-password <password>

这个命令会生成一个加密的版本，如下

{COQLCE6DU6GtcS5P=}

复制粘贴到你的xml文件中

<settings>
...<servers>
...<server><id>my.server</id><username>foo</username><password>{COQLCE6DU6GtcS5P=}</password></server>
...</servers>
...
</settings>

请注意，密码可以包含花括号之外的所有的信息，如下也可以生效

<settings>
...<servers>
...<server><id>my.server</id><username>foo</username><password>Oleg reset this password on 2009-03-11, expires on 2009-04-11 {COQLCE6DU6GtcS5P=}</password></server>
...</servers>
...
</settings>

提示：

maven中密码使用 /作为转义符
拥有主密码的人可以解密你的密码
如果是windows用户，使用密码必须要带上""双引号

Configuring a proxy(配置代理)

<settings>..<proxies><proxy><id>example-proxy</id><active>true</active><protocol>http</protocol><host>proxy.example.com</host><port>8080</port><username>proxyuser</username><password>somepassword</password><nonProxyHosts>www.google.com|*.example.com</nonProxyHosts></proxy></proxies>..
</settings>

通过http认证接入远程仓库指南

12、指南

12.1 Configuring for Reproducible Builds

What are Reproducible Builds？

结束

感觉后面的内容与实际使用过程中碰到问题交集不大，我没有读下去了，暂时不做继续翻译，大家对翻译翻译内容有异议的可以提出来一起探讨。

欢迎留言评论一起学习进步。。。。

Maven官网笔记（学习翻译）相关推荐

GitHub使用教程详解——官网操作指南（翻译）
GitHub使用教程详解--官网操作指南(翻译) GitHub使用指南原文地址:GitHub官网示例项目:Hello World 十分钟轻松教学在学习计算机语言编程的过程中创建Hello Wor ...
caffe官网的部分翻译及NG的教程
Caffe原来叫:Convolutional Architecture for Fast Feature Embedding 官网的个人翻译:http://blog.csdn.net/fengbing ...
python利用mysql数据库实现一个中英文翻译程序兼单词试卷生成并改阅功能，并可以爬取有道官网进行在线翻译。
直接上运行截图(代码在后面) 开始界面使用navicat查看mysql数据库中的数据单词查询功能测试本地翻译一个本地数据库中有的单词本地翻译一个本地数据库中没有的单词爬取有道官网进行在线翻译 ...
Maven 官网查找依赖包
1.登录 Maven 官网地址官网地址: https://mvnrepository.com/ 2.输入你要查找的 jar 包的相关信息(这里以 spring 为例) 3.双击 spring-con ...
怎么从Apache maven 官网下载旧版本
必应搜索maven官网:https://maven.apache.org/download.cgi 可以看到官网左边有个Download(下载).点击下载,右边Files中显示目前最新版的maven版 ...
在maven官网下载maven历史版本
前几天改了maven的settings.xml文件忘记备份了,想把原来的settings.xml文件拿过来用,于是就再去下载一次,我本地版本是3.5.4. 在官网下载历史版本的话,步骤如下: (1 ...
知道maven地址,如何在maven官网下载jar包
比如,我现在想下载这个jar <dependency> <groupId>io.confluent</groupId> <artifactId>kaf ...
如何通过maven官网查询相关依赖的具体代码和版本？
如何通过maven官网查询相关依赖的具体代码和版本? 通过官网:http://mvnrepository.com/,或者:https://search.maven.org/ 在搜索栏中输入想要引入的依 ...
如何借助官网例程学习STM32
如何借助官网例程学习STM32 现在STM32的资料已经非常多了,那么假如市场上这款芯片刚刚出现,没有可参考的TB店家,应该怎么办呢?答案是可以参考官网例程! 1.首先打开官方网址:https://w ...