blocks|key|2723058|text|因此，为了进一步解释一下概述的here|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2723059|Maven构建在生命周期中分为以下几个部分：|2723060|2723061|clean|unordered-list-item|2723062|build+(default)|2723063|site|2723064|2723065|每个周期都被分成几个阶段。例如，构建分为几个阶段，如下所示：|2723066|准备resources|2723067|compile|2723068|
|2723069|package|2723070|2723071|install|2723072|
的|2723073|2723074|2723075|阶段的目标是在之前运行前或在后运行a阶段，例如：|style|BOLD|2723076|清理前阶段-将在清理阶段之前执行-将在清理阶段之后执行|2723077|如果您愿意，您可以将目标视为附加的“插入”阶段。有关详细信息，请阅读here或查看@Gerolds+answer。|2723078|entityMap|0|LINK|mutability|MUTABLE|url|http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html|1|http://www.tutorialspoint.com/maven/maven_build_life_cycle.htm|2|https://stackoverflow.com/a/30953905/6482^0|F|4|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|7|4|E|3|0|0|Y|4|1|15|F|2|0^^$0|@$1|2|3|4|5|6|7|1P|8|@]|9|@$A|1Q|B|1R|1|1S]]|C|$]]|$1|D|3|E|5|6|7|1T|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|1U|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|1V|8|@]|9|@]|C|$]]|$1|J|3|K|5|I|7|1W|8|@]|9|@]|C|$]]|$1|L|3|M|5|I|7|1X|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|20|8|@]|9|@]|C|$]]|$1|S|3|T|5|I|7|21|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|22|8|@]|9|@]|C|$]]|$1|W|3|X|5|I|7|23|8|@]|9|@]|C|$]]|$1|Y|3|V|5|6|7|24|8|@]|9|@]|C|$]]|$1|Z|3|10|5|I|7|25|8|@]|9|@]|C|$]]|$1|11|3|12|5|6|7|26|8|@]|9|@]|C|$]]|$1|13|3|-4|5|I|7|27|8|@]|9|@]|C|$]]|$1|14|3|-4|5|6|7|28|8|@]|9|@]|C|$]]|$1|15|3|16|5|6|7|29|8|@$A|2A|B|2B|17|18]|$A|2C|B|2D|17|18]]|9|@]|C|$]]|$1|19|3|1A|5|6|7|2E|8|@]|9|@]|C|$]]|$1|1B|3|1C|5|6|7|2F|8|@]|9|@$A|2G|B|2H|1|2I]|$A|2J|B|2K|1|2L]]|C|$]]|$1|1D|3|-4|5|6|7|2M|8|@]|9|@]|C|$]]]|1E|$1F|$5|1G|1H|1I|C|$1J|1K]]|1L|$5|1G|1H|1I|C|$1J|1M]]|1N|$5|1G|1H|1I|C|$1J|1O]]]]

So to explain a little further as outlined <a href="http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html" rel="nofollow noreferrer">here</a>

Maven builds are split in life-cycles these are:

<ul>
<li>clean</li>
<li>build (default)</li>
<li>site</li>
</ul>

Each of this cycles is split into phases.
For instance build is split into phases like:

<ul>
<li>prepare resources</li>
<li>compile</li>
<li>package</li>
<li>install</li>
</ul>

Phases have goals to run prior pre- or after post- a phase, for instance:

<ul>
<li>pre-clean - will be executed prior the clean phase</li>
<li>post-clean - will be executed after the clean phase</li>
</ul>

You can view goals as additional "inserted" phases if you like.
Read up <a href="http://www.tutorialspoint.com/maven/maven_build_life_cycle.htm" rel="nofollow noreferrer">here</a> or take a look at <a href="https://stackoverflow.com/a/30953905/6482">@Gerolds answer</a> for details.

blocks|key|143969|text|Maven生命周期是一个(抽象的)概念，它涵盖了项目开发生命周期中预期发生的所有阶段阶段()(或者更好:+Maven决定支持的所有步骤)阶段。这些步骤(或阶段)在Maven术语中称为。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|143970|Maven插件是目标的容器/提供者。在goals中实现的代码才是真正的主力。(Maven+in+its+core+itself+is+just+managing+plugins+and+executing+goals)。插件的每个目标都可以分配/绑定到任何+.|143971|在调用mvn+<phase>+时，Maven会传递所有阶段(每次)，并执行所有目标(由插件提供)，这些目标在给定阶段之前和之前(包括)绑定到任何阶段。如果存在一个没有绑定目标的阶段，则什么也不会做。但是这个阶段已经过去了。|CODE|143972|也就是说，你不能在Maven的一个内置生命周期中“插入‘额外的阶段’。他们已经在那里了，总是这样！您可以使用自己的阶段开发自己的生命周期，但这远远不是简单地使用Maven。|143973|Goals也可以直接执行，当你不使用任何阶段运行mvn或者(plugin:)goal时，你会被告知不带换行符，并且为了可读性而在这里缩写|143974|You+must+specify+a+valid+lifecycle+phase+or+a+goal+in+the+format

<plugin-prefix>:<goal>+or

<plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>.

Available+lifecycle+phases+are:

...|code-block|syntax|javascript|143975|..。请参阅下面References中的实际输出或Maven.构建生命周期简介。|143976|参考|143977|143978|Maven+/+Introduction+to+the+Build+Lifecycle|unordered-list-item|143979|143980|如果您想知道在POM中没有任何目标绑定的情况下，Maven如何知道如何做，在页面底部有一个指向default-bindings.xml的链接，它位于<Your+Maven+installation>/lib/maven-core-x.y.z.jar/META-INF/plexus/default-bindings.xml中。|143981|内置生命周期(clean、default、site)的阶段在<component-set><components><component><role>org.apache.maven.lifecycle.Lifecycle下的/lib/maven-core-x.y.z.jar/META-INF/plexus/components.xml中声明。另请参见Lifecycles+Reference。|143982|143983|Maven:+The+Complete+Reference,+Chapter+4.+The+Build+Lifecycle|143984|Maven+by+Example,+3.5.+Core+Concepts|143985|143986|entityMap|0|LINK|mutability|MUTABLE|url|https://maven.apache.org/plugins/|1|https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html|2|https://git-wip-us.apache.org/repos/asf?p=maven.git;a=blob;f=maven-core/src/main/resources/META-INF/plexus/default-bindings.xml|3|https://git-wip-us.apache.org/repos/asf?p=maven.git;a=blob;f=maven-core/src/main/resources/META-INF/plexus/components.xml;hb=HEAD|4|https://maven.apache.org/ref/3.8.1/maven-core/lifecycles.html|5|http://books.sonatype.com/mvnref-book/reference/lifecycle.html|6|http://books.sonatype.com/mvnex-book/reference/simple-project-sect-simple-core.html^0|19|Q|0|32|I|3L|1|13|1X|0|0|3|B|F|E|X|8|1C|Q|0|0|O|3|0|0|8|A|0|0|2|0|0|0|17|1|0|0|1B|K|22|2F|1B|K|2|0|U|28|34|1K|34|1K|3|4W|K|4|0|0|0|1P|5|0|0|10|6|0|0^^$0|@$1|2|3|4|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1Z|8|@$9|20|A|21|B|C]|$9|22|A|23|B|C]]|D|@$9|24|A|25|1|26]]|E|$]]|$1|H|3|I|5|6|7|27|8|@$9|28|A|29|B|J]|$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]|$9|2E|A|2F|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|2G|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|2H|8|@$9|2I|A|2J|B|J]]|D|@]|E|$]]|$1|O|3|P|5|Q|7|2K|8|@]|D|@]|E|$R|S]]|$1|T|3|U|5|6|7|2L|8|@$9|2M|A|2N|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|2O|8|@$9|2P|A|2Q|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|2R|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|10|7|2S|8|@]|D|@$9|2T|A|2U|1|2V]]|E|$]]|$1|11|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|2X|8|@$9|2Y|A|2Z|B|J]|$9|30|A|31|B|J]]|D|@$9|32|A|33|1|34]]|E|$]]|$1|14|3|15|5|6|7|35|8|@$9|36|A|37|B|J]|$9|38|A|39|B|J]]|D|@$9|3A|A|3B|1|3C]|$9|3D|A|3E|1|3F]]|E|$]]|$1|16|3|-4|5|6|7|3G|8|@]|D|@]|E|$]]|$1|17|3|18|5|10|7|3H|8|@]|D|@$9|3I|A|3J|1|3K]]|E|$]]|$1|19|3|1A|5|10|7|3L|8|@]|D|@$9|3M|A|3N|1|3O]]|E|$]]|$1|1B|3|-4|5|6|7|3P|8|@]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|3Q|8|@]|D|@]|E|$]]]|1D|$1E|$5|1F|1G|1H|E|$1I|1J]]|1K|$5|1F|1G|1H|E|$1I|1L]]|1M|$5|1F|1G|1H|E|$1I|1N]]|1O|$5|1F|1G|1H|E|$1I|1P]]|1Q|$5|1F|1G|1H|E|$1I|1R]]|1S|$5|1F|1G|1H|E|$1I|1T]]|1U|$5|1F|1G|1H|E|$1I|1V]]]]

A Maven lifecycle is an (abstract) concept that covers all steps (or better: all the steps the Maven designers decided to support) that are expected to occur in a project's development lifetime. These steps (or stages) are called phases in Maven terminology.
A Maven plugin is a container for/supplier of goals. Code implemented in goals is the real workhorse. (<a href="https://maven.apache.org/plugins/" rel="nofollow noreferrer">Maven in its core itself is just managing plugins and executing goals</a>). Each of a plugin's goals can be assigned/bound to any of the <a href="https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference" rel="nofollow noreferrer">lifecycle phases</a>.
When invoking <code>mvn &lt;phase&gt;</code> Maven passes all phases (every time) and executes all goals (supplied by plugins) that have been bound to any of the phases prior and up to (and including) the given phase. If there is a phase with no goal bound to it nothing is done. But the phase is passed nevertheless.
I.e. you can't &quot;'insert' additional phases&quot; into one of Maven's built-in lifecycles. They are already there, always! You could develop your own lifecycle with its own phases but that's far beyond simply using Maven as it is.
Goals can also be executed directly, which you get told when running <code>mvn</code> without any phase or (plugin:)goal [with line breaks and shortened for readability here]:
<pre><code>You must specify a valid lifecycle phase or a goal in the format

&lt;plugin-prefix&gt;:&lt;goal&gt; or

&lt;plugin-group-id&gt;:&lt;plugin-artifact-id&gt;[:&lt;plugin-version&gt;]:&lt;goal&gt;.

Available lifecycle phases are:

...
</code></pre>
... see actual output or Maven, Introduction to the Build Lifecycle at References below.
References
<ul>
<li><a href="https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html" rel="nofollow noreferrer">Maven / Introduction to the Build Lifecycle</a> 
If you ever wondered how Maven knows what to do without any goal binding in the POM there's a link to <a href="https://git-wip-us.apache.org/repos/asf?p=maven.git;a=blob;f=maven-core/src/main/resources/META-INF/plexus/default-bindings.xml" rel="nofollow noreferrer"><code>default-bindings.xml</code></a> at the bottom of that page which is located in <code>&lt;Your Maven installation&gt;/lib/maven-core-x.y.z.jar/META-INF/plexus/default-bindings.xml</code>.
The phases for the built-in lifecycles (clean, default, site) are declared in <a href="https://git-wip-us.apache.org/repos/asf?p=maven.git;a=blob;f=maven-core/src/main/resources/META-INF/plexus/components.xml;hb=HEAD" rel="nofollow noreferrer"><code>&lt;Your Maven installation&gt;/lib/maven-core-x.y.z.jar/META-INF/plexus/components.xml</code></a> under <code>&lt;component-set&gt;&lt;components&gt;&lt;component&gt;&lt;role&gt;org.apache.maven.lifecycle.Lifecycle</code>. See also <a href="https://maven.apache.org/ref/3.8.1/maven-core/lifecycles.html" rel="nofollow noreferrer">Lifecycles Reference</a>.
</li>
</ul>
<ul>
<li><a href="http://books.sonatype.com/mvnref-book/reference/lifecycle.html" rel="nofollow noreferrer">Maven: The Complete Reference, Chapter 4. The Build Lifecycle</a></li>
</ul>
<ul>
<li><a href="http://books.sonatype.com/mvnex-book/reference/simple-project-sect-simple-core.html" rel="nofollow noreferrer">Maven by Example, 3.5. Core Concepts</a></li>
</ul>

blocks|key|147850|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|147851|+Maven:生命周期与阶段、插件与目标|blockquote|147852|147853|147854|回答延迟只是为了澄清此线程中缺少的另一个粒度级别:+Maven+(目标的)，这是Maven的最小单元。|147855|因此，我们有构建周期(基本上，针对特定总体目标的一组操作)，它由阶段(较低的粒度，周期步骤)组成，它可以调用由特定插件提供的一组已配置的目标。也就是说，Maven+(也)是一个插件执行器，每个插件可以提供一个或多个目标。然后，您(还)决定将哪个目标附加到哪个阶段，在默认生命周期中的大多数时间(没有任何目标，即默认)。但是你实际上可以有另一个层次:执行(相同的目标，来自相同的插件，或者来自不同插件的不同目标)|offset|length|style|BOLD|147856|我准备了一张照片来恢复整个过程|147857|📷|atomic|147858|​|147859|事实上，这就是Maven通过其构建日志中的唯一字符串显示它(其最小的工作单元)的方式：|147860|plugin-artifactId:plugin-version:plugin-goal+(goal-execution-id)+@+project-name|code-block|syntax|javascript|147861|例如，我们将拥有：|147862|[INFO]+---+maven-compiler-plugin:2.5.1:compile+(default-compile)+@+sample-project+---|147863|这实际上意味着(通过不同的粒度级别)：|147864|147865|在compile阶段(不幸的是，仅在REACTOR+BUILD+PLAN+–+Tasks:+[...]下使用mvn+-X+...进行调试)和|unordered-list-item|CODE|147866|我正在调用Maven编译器插件(由artifactId→|147867|指定)，其<代码>C24目标<代码>H225<代码>H126由<代码>D28+default-compile.|147868|定义。|147869|它是独一无二的，因为你可以将相同的目标(同一个插件)绑定到不同的阶段，或者绑定到相同的阶段，但在不同的执行中(也就是说，使用不同的配置)。例如，maven-compiler-plugin在test-compile+phase+(一个不同的阶段)期间也被用来在不同的执行(default-testCompile)中编译测试代码(通过它的testCompile目标)。您还可以(使用相同的插件和目标)在不同的阶段编译一些自动生成的代码，这些代码是由您在POM中指定的执行定义的(并且可能是不同的配置)。|147870|默认的执行是通过Maven+packaging+bindings提供的，也就是说，在默认情况下(在配置上强制执行约定)，Maven已经在某些阶段调用了特定的目标(标准插件)。这些默认调用的执行ids是根据certain+conventions定义的。|147871|这也解释了为什么如果您真的想要覆盖Maven构建的默认行为(绑定)，您需要在POM中为相同的插件指定(覆盖)完全相同的执行id。例如，您可以跳过编译，简单地定义具有相同default-compile+id的maven-compiler-plugin的执行，但绑定到不存在的阶段(或空阶段)。|147872|：执行告诉在哪个阶段使用哪个配置来执行哪个(或哪些)目标。|147873|默认情况下提供了一些执行(默认绑定)，这解释了为什么6行的maven+minimal+pom已经可以做很多事情(编译、测试、打包等)：在某些阶段执行标准插件的目标:它是约定优先于配置。然后，通过pom.xml配置，您可以将stuff+(executions)添加到构建或影响已配置插件的行为(在本例中没有executions部分，但只需configuration就足够了)。|147874|是的，您可以跳过构建周期(及其阶段)，直接调用(插件的)目标。想象一下：|147875|mvn+compiler:compile
mvn+compiler:testCompile
mvn+surefire:test
mvn+jar:jar|147876|(注意:您也可以只在一个调用中调用内联)|147877|在这里，我们正在编译应用程序代码，测试代码，执行测试和打包:想象一下，这将是多么手动，容易出错，重复和耗时。约定重于配置对我们有帮助:+Maven引入了构建生命周期和阶段。缺省生命周期(没有名称，即缺省生命周期)根据最佳实践和约定(Maven的口头语)提供了一系列阶段。|147878|如果您想实现与上面相同的功能，只需运行：mvn+package，它将自动编译、测试和打包您的项目。多么?调用插件。也就是说，阶段是一组有意义且可配置的插件(目标)执行。为了使它更标准，对于每个阶段，Maven将首先调用任何之前的阶段，这样，例如，如果你想测试，你将确保你首先编译。|147879|附注：请注意，当为相同的execution指定多个目标时，您仍然会在构建日志中清楚地看到两个不同的目标(因此，仍然是唯一的元组)的两个不同的执行(具有相同的id)。|147880|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/3bc3acbd06981693c9ab9607004f6182.png|imageAlt|1|LINK|MUTABLE|url|https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference|2|3|https://maven.apache.org/plugins/maven-compiler-plugin/testCompile-mojo.html|4|https://maven.apache.org/ref/3.3.3/maven-core/default-bindings.html|5|https://stackoverflow.com/a/34599117/5606016|6|https://maven.apache.org/guides/introduction/introduction-to-the-pom.html#Minimal_POM^0|0|0|0|0|0|6|4|W|2|1L|2|1W|2|0|0|0|1|0|0|0|0|0|0|0|0|0|1|7|I|X|1I|A|1|7|1|0|H|A|0|13|F|0|0|20|L|2M|C|3R|J|4N|B|2M|I|2|4N|B|3|0|8|O|4|2U|J|5|0|2C|F|2V|L|0|5|O|0|0|57|2P|7|48|A|4O|D|T|H|6|0|0|10|0|0|0|K|0|0|3R|0|0|3W|K|B|0|0|2A|C|9|0^^$0|@$1|2|3|-4|4|5|6|2R|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|2S|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|2T|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|2U|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|2V|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|2W|7|@$J|2X|K|2Y|L|M]|$J|2Z|K|30|L|M]|$J|31|K|32|L|M]|$J|33|K|34|L|M]]|8|@]|9|$]]|$1|N|3|O|4|5|6|35|7|@]|8|@]|9|$]]|$1|P|3|Q|4|R|6|36|7|@]|8|@$J|37|K|38|1|39]]|9|$]]|$1|S|3|T|4|5|6|3A|7|@]|8|@]|9|$]]|$1|U|3|V|4|5|6|3B|7|@]|8|@]|9|$]]|$1|W|3|X|4|Y|6|3C|7|@]|8|@]|9|$Z|10]]|$1|11|3|12|4|5|6|3D|7|@]|8|@]|9|$]]|$1|13|3|14|4|Y|6|3E|7|@]|8|@]|9|$Z|10]]|$1|15|3|16|4|5|6|3F|7|@]|8|@]|9|$]]|$1|17|3|-4|4|5|6|3G|7|@]|8|@]|9|$]]|$1|18|3|19|4|1A|6|3H|7|@$J|3I|K|3J|L|1B]|$J|3K|K|3L|L|1B]|$J|3M|K|3N|L|1B]]|8|@$J|3O|K|3P|1|3Q]]|9|$]]|$1|1C|3|1D|4|1A|6|3R|7|@$J|3S|K|3T|L|1B]]|8|@]|9|$]]|$1|1E|3|1F|4|1A|6|3U|7|@$J|3V|K|3W|L|1B]]|8|@]|9|$]]|$1|1G|3|1H|4|5|6|3X|7|@]|8|@]|9|$]]|$1|1I|3|1J|4|5|6|3Y|7|@$J|3Z|K|40|L|1B]|$J|41|K|42|L|1B]|$J|43|K|44|L|1B]|$J|45|K|46|L|1B]]|8|@$J|47|K|48|1|49]|$J|4A|K|4B|1|4C]]|9|$]]|$1|1K|3|1L|4|5|6|4D|7|@]|8|@$J|4E|K|4F|1|4G]|$J|4H|K|4I|1|4J]]|9|$]]|$1|1M|3|1N|4|5|6|4K|7|@$J|4L|K|4M|L|1B]|$J|4N|K|4O|L|1B]]|8|@]|9|$]]|$1|1O|3|1P|4|5|6|4P|7|@$J|4Q|K|4R|L|M]]|8|@]|9|$]]|$1|1Q|3|1R|4|5|6|4S|7|@$J|4T|K|4U|L|M]|$J|4V|K|4W|L|1B]|$J|4X|K|4Y|L|1B]|$J|4Z|K|50|L|1B]]|8|@$J|51|K|52|1|53]]|9|$]]|$1|1S|3|1T|4|5|6|54|7|@$J|55|K|56|L|M]]|8|@]|9|$]]|$1|1U|3|1V|4|Y|6|57|7|@]|8|@]|9|$Z|10]]|$1|1W|3|1X|4|5|6|58|7|@$J|59|K|5A|L|M]]|8|@]|9|$]]|$1|1Y|3|1Z|4|5|6|5B|7|@$J|5C|K|5D|L|M]]|8|@]|9|$]]|$1|20|3|21|4|5|6|5E|7|@$J|5F|K|5G|L|M]|$J|5H|K|5I|L|1B]]|8|@]|9|$]]|$1|22|3|23|4|5|6|5J|7|@$J|5K|K|5L|L|M]|$J|5M|K|5N|L|1B]]|8|@]|9|$]]|$1|24|3|-4|4|5|6|5O|7|@]|8|@]|9|$]]]|25|$26|$4|27|28|29|9|$2A|2B|2C|-4]]|2D|$4|2E|28|2F|9|$2G|2H]]|2I|$4|2E|28|2F|9|$2G|2H]]|2J|$4|2E|28|2F|9|$2G|2K]]|2L|$4|2E|28|2F|9|$2G|2M]]|2N|$4|2E|28|2F|9|$2G|2O]]|2P|$4|2E|28|2F|9|$2G|2Q]]]]

<blockquote>
Maven: Lifecycle vs. Phase vs. Plugin vs. Goal
</blockquote>
Answering late just to clarify yet another level of granularity missing in this thread: executions (of a goal), which are the smallest units of a Maven build.
Hence, we have build cycles (basically, set of actions for a specific overall goal), which consist of phases (lower granularity, a cycle step), which can invoke a set of configured goals provided by certain plugins. That is, Maven is (also) a plugin executor, each plugin can offer one or more goals. You then (also) decide which goal is attached to which phase, most of the times in the defaul life cycle (without any, that is, the default). But you can actually have yet another level: executions (of the same goal, from the same plugin, or of different goals from different plugins)
A picture I prepared to resume the whole
<a href="https://i.stack.imgur.com/Ub3Bd.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Ub3Bd.png" alt="enter image description here" /></a>
And indeed this is how Maven shows it (its smallest unit of work) via the unique string in its build log:
<pre><code>plugin-artifactId:plugin-version:plugin-goal (goal-execution-id) @ project-name
</code></pre>
For example, we would have:
<pre><code>[INFO] --- maven-compiler-plugin:2.5.1:compile (default-compile) @ sample-project ---
</code></pre>
Which indeed means (through different levels of granularity):
<ul>
<li>During the <a href="https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference" rel="nofollow noreferrer"><code>compile</code></a> phase (unfortunately only mentioned with <code>mvn -X ...</code> for debugging, under <code>REACTOR BUILD PLAN – Tasks: [...]</code>) →</li>
<li>I'm invoking the Maven Compiler plugin (specified by <code>artifactId</code> and <code>version</code>) with its <a href="https://maven.apache.org/plugins/maven-compiler-plugin/compile-mojo.html" rel="nofollow noreferrer"><code>compile</code></a> goal →</li>
<li>as defined by the <code>execution</code> with the <code>id</code> <code>default-compile</code>.</li>
</ul>
It's unique because indeed you could have the same goal (of the same plugin) bound to different phases or to the same phase but in different executions (that is, with different configurations). The <code>maven-compiler-plugin</code>, for instance, is also used during the <a href="https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference" rel="nofollow noreferrer"><code>test-compile</code> phase</a> (a different phase) to compile test code (via its <a href="https://maven.apache.org/plugins/maven-compiler-plugin/testCompile-mojo.html" rel="nofollow noreferrer"><code>testCompile</code></a> goal) in a different execution (<code>default-testCompile</code>). You could also compile (using the same plugin and goal) some auto-generated code during a different phase as defined by an execution you specified int the POM (and potentially a different configuration).
Default executions are provided out-of-the-box via <a href="https://maven.apache.org/ref/3.3.3/maven-core/default-bindings.html" rel="nofollow noreferrer">Maven packaging bindings</a>, that is, by default (and enforcing convention over configuration) Maven already invokes certain goals (of standard plugins) during certain phases. The executions ids of these default invocations are defined according to <a href="https://stackoverflow.com/a/34599117/5606016">certain conventions</a>.
This also explains why if you really want to override a default behavior (binding) of a Maven build, you need to specify (override) exactly the same execution id in your POM for the same plugin. You could, for instance, skip compilation simply defining an execution of the <code>maven-compiler-plugin</code> with the same <code>default-compile</code> id but bound to a non existing phase (or an empty one).
To make it short: an execution tells Maven which goal(s) to execute with which configuration within which phase.
Some executions are provided by default (defaul bindings), which explains why the <a href="https://maven.apache.org/guides/introduction/introduction-to-the-pom.html#Minimal_POM" rel="nofollow noreferrer">maven minimal pom</a> of just 6 lines can already do a lot (compile, test, package, etc.): executing goals of standard plugins in certain phases: it's convention over configuration. Then, via the <code>pom.xml</code> configuration you can add stuff (executions) to the build or influence the behavior of already configured plugins (in this case no <code>executions</code> section, but just <code>configuration</code> would be enough).
Yes, you could skip build cycles (and their phases) and directly invoke goals (of plugins). Imagine the following:
<pre><code>mvn compiler:compile
mvn compiler:testCompile
mvn surefire:test
mvn jar:jar
</code></pre>
(NOTE: you could also invoke inline in only one call)
Here we are compiling app code, test code, execute tests and package: imagine how manual, error-prone, repetitive and time-consuming this would be. Convention over configuration helps us: Maven introduces build life cycles and phases. The default life cycle (with no name, that is, the default), provides a range of phases based on best practices and conventions (the mantra of Maven). 
If you want to achieve the same as above, simply run: <code>mvn package</code> and it will automatically compile, test and package your project. How? invoking plugins. That is, phases are meaningful and configurable set of plugins (goals) executions. To make it even more standard, for each phase Maven will firstly invoke any preceeding phase, so that e.g. if you want to test you'll be sure you firstly compile.
p.s. note that when specifying several goals for the same <code>execution</code>, you will still see clearly in the build log two different executions (with the same id) for the two different goals (hence, still unique tuple).

blocks|key|146338|text|感谢Sandeep+Jindal和Premraj+(从这里What+are+Maven+goals+and+phases+and+what+is+their+difference?)。他们的解释帮助我理解。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|146339|我在https://www.surasint.com/maven-life-cycle-phase-and-goal-easy-explained/中创建了一些完整的代码示例&一些简单的解释。我认为这可能有助于其他人理解，并可以直接尝试一些东西。|146340|简而言之，从链接中，你不应该试图一次理解所有三个，首先你应该了解这些组中的关系：|146341|146342|生命周期与阶段|unordered-list-item|146343|插件与Goal|146344|146345|1.生命周期与阶段|style|BOLD|146346|生命周期是按顺序排列的阶段的集合，请参阅此处Life+Cycle+References。当您调用阶段时，它还将调用它之前的所有阶段。|146347|例如，清理生命周期有3个阶段(预清理、清理、清理后)。|146348|mvn+clean|code-block|syntax|javascript|146349|它将调用pre-clean和clean。|146350|2.插件与目标|146351|Goal就像Plugin中的一个动作。因此，如果plugin是一个类，那么goal就是一个方法。|146352|你可以这样调用一个目标：|146353|mvn+clean:clean|146354|这意味着“在clean插件中调用clean目标”(这里与clean阶段无关。别让“干净”这个词把你搞糊涂了，它们是不一样的！请参阅我上面的链接中的完整解释)|146355|3.现在阶段和目标之间的关系：|146356|清洁阶段可以(Pre)链接到清洁目标(S).For示例，正常情况下，清洁阶段链接到清洁目标。因此，当您调用此命令时：|146357|mvn+clean|146358|它将调用pre-clean阶段和clean阶段，这两个阶段链接到clean:clean目标。|146359|它几乎等同于：|146360|mvn+pre-clean+clean:clean|146361|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/16205778/what-are-maven-goals-and-phases-and-what-is-their-difference|1|https://www.surasint.com/maven-life-cycle-phase-and-goal-easy-explained/|2|http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference^0|T|1P|0|0|2|20|1|0|0|0|0|0|0|0|9|0|0|4|B|2|1C|2|1R|2|M|L|2|0|3|6|F|A|0|0|4|9|E|5|0|0|7|0|0|4|6|6|0|0|0|0|0|F|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|21|8|@]|9|@$A|22|B|23|1|24]]|C|$]]|$1|D|3|E|5|6|7|25|8|@]|9|@$A|26|B|27|1|28]]|C|$]]|$1|F|3|G|5|6|7|29|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|2A|8|@]|9|@]|C|$]]|$1|I|3|J|5|K|7|2B|8|@]|9|@]|C|$]]|$1|L|3|M|5|K|7|2C|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|2D|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|2E|8|@$A|2F|B|2G|Q|R]]|9|@]|C|$]]|$1|S|3|T|5|6|7|2H|8|@$A|2I|B|2J|Q|R]|$A|2K|B|2L|Q|R]|$A|2M|B|2N|Q|R]|$A|2O|B|2P|Q|R]]|9|@$A|2Q|B|2R|1|2S]]|C|$]]|$1|U|3|V|5|6|7|2T|8|@$A|2U|B|2V|Q|R]|$A|2W|B|2X|Q|R]]|9|@]|C|$]]|$1|W|3|X|5|Y|7|2Y|8|@]|9|@]|C|$Z|10]]|$1|11|3|12|5|6|7|2Z|8|@$A|30|B|31|Q|R]|$A|32|B|33|Q|R]]|9|@]|C|$]]|$1|13|3|14|5|6|7|34|8|@$A|35|B|36|Q|R]]|9|@]|C|$]]|$1|15|3|16|5|6|7|37|8|@$A|38|B|39|Q|R]|$A|3A|B|3B|Q|R]]|9|@]|C|$]]|$1|17|3|18|5|6|7|3C|8|@]|9|@]|C|$]]|$1|19|3|1A|5|Y|7|3D|8|@]|9|@]|C|$Z|10]]|$1|1B|3|1C|5|6|7|3E|8|@]|9|@]|C|$]]|$1|1D|3|1E|5|6|7|3F|8|@$A|3G|B|3H|Q|R]]|9|@]|C|$]]|$1|1F|3|1G|5|6|7|3I|8|@]|9|@]|C|$]]|$1|1H|3|1I|5|Y|7|3J|8|@]|9|@]|C|$Z|10]]|$1|1J|3|1K|5|6|7|3K|8|@]|9|@]|C|$]]|$1|1L|3|1M|5|6|7|3L|8|@]|9|@]|C|$]]|$1|1N|3|1O|5|Y|7|3M|8|@]|9|@]|C|$Z|10]]|$1|1P|3|-4|5|6|7|3N|8|@]|9|@]|C|$]]]|1Q|$1R|$5|1S|1T|1U|C|$1V|1W]]|1X|$5|1S|1T|1U|C|$1V|1Y]]|1Z|$5|1S|1T|1U|C|$1V|20]]]]

Credit to Sandeep Jindal and Premraj (from here <a href="https://stackoverflow.com/questions/16205778/what-are-maven-goals-and-phases-and-what-is-their-difference">What are Maven goals and phases and what is their difference?</a>). Their explanation help me to understand.

I created some full code examples &amp; some simple explanations here <a href="https://www.surasint.com/maven-life-cycle-phase-and-goal-easy-explained/" rel="nofollow noreferrer">https://www.surasint.com/maven-life-cycle-phase-and-goal-easy-explained/</a> . I think it may help others to understand and can try something directly.

In short from the link, You should not try to understand all three at once, first you should understand the relationship in these groups:

<ul>
<li>Life Cycle vs Phase </li>
<li>Plugin vs Goal</li>
</ul>

1. Life Cycle vs Phase 

Life Cycle is a collection of phase in sequence, see here <a href="http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Lifecycle_Reference" rel="nofollow noreferrer">Life Cycle References</a>. When you call a phase, it will also call all phases before it.

For example, the clean life cycle has 3 phases (pre-clean, clean, post-clean). 

<pre><code>mvn clean
</code></pre>

It will call pre-clean and clean. 

2. Plugin vs Goal

Goal is like an action in Plugin. So if plugin is a class, goal is a method.

you can call a goal like this:

<pre><code>mvn clean:clean
</code></pre>

This means "call the clean goal, in the clean plugin" (Nothing relates to the clean phase here. Don't let the word"clean" confusing you, they are not the same! See full explanation in my link above)

3. Now the relation between Phase &amp; Goal:

Phase can (pre)links to Goal(s).For example, normally, the clean phase links to the clean goal. So, when you call this command:

<pre><code>mvn clean
</code></pre>

It will call the pre-clean phase and the clean phase which links to the clean:clean goal.

It is almost the same as:

<pre><code>mvn pre-clean clean:clean
</code></pre>

blocks|key|145403|text|来源：this+really+good+tutorial|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|145404|生命周期、生命周期阶段、插件和插件目标是Maven的核心。|145405|由于arguments.|145406|Maven具有三个生命周期，因此site.|unordered-list-item|145407|
|145408|Each命令|style|BOLD|145409|+mvn只接受生命周期阶段或插件目标:默认、清理和代码生命周期由生命周期阶段组成，总共有28个阶段-+21+in+default+(验证，...，编译，...，包，...，安装，部署)，3+in+clean+(预清理，清理，后清理)和<代码>E1154+in+site+<>E216>(预站点，站点，站点后，site-deploy).|145410|When生命周期阶段是使用another.|145411|lifecycle命令调用的，所有前面的阶段都是在task.|145412|depending阶段本身没有完成任何任务的能力之后依次执行的，它们依赖插件来执行对项目和打包类型的mvn，Maven将各种插件目标绑定到生命周期阶段，目标执行委托给它们的任务。|CODE|145413|145414|145415|当我们在Java项目中运行mvn+package时，Maven会将插件目标绑定到生命周期阶段，如下图所示：|145416|​|145417|📷|atomic|145418|145419|entityMap|0|LINK|mutability|MUTABLE|url|https://web.archive.org/web/20170325093701/https://www.codetab.org/apache-maven-tutorial/|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/4096aefa0722daecde0719e8ba94cdb4.png|imageAlt^0|3|P|0|0|0|0|0|0|0|6|0|1|11|1F|D|2L|A|0|0|0|1E|3|1I|L|0|0|0|D|B|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@$A|1O|B|1P|1|1Q]]|C|$]]|$1|D|3|E|5|6|7|1R|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1S|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1T|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1U|8|@]|9|@]|C|$]]|$1|M|3|N|5|J|7|1V|8|@$A|1W|B|1X|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|J|7|1Y|8|@$A|1Z|B|20|O|P]|$A|21|B|22|O|P]|$A|23|B|24|O|P]]|9|@]|C|$]]|$1|S|3|T|5|J|7|25|8|@]|9|@]|C|$]]|$1|U|3|V|5|J|7|26|8|@]|9|@]|C|$]]|$1|W|3|X|5|J|7|27|8|@$A|28|B|29|O|Y]|$A|2A|B|2B|O|P]]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|2C|8|@]|9|@]|C|$]]|$1|10|3|-4|5|6|7|2D|8|@]|9|@]|C|$]]|$1|11|3|12|5|6|7|2E|8|@$A|2F|B|2G|O|Y]]|9|@]|C|$]]|$1|13|3|14|5|6|7|2H|8|@]|9|@]|C|$]]|$1|15|3|16|5|17|7|2I|8|@]|9|@$A|2J|B|2K|1|2L]]|C|$]]|$1|18|3|14|5|6|7|2M|8|@]|9|@]|C|$]]|$1|19|3|-4|5|6|7|2N|8|@]|9|@]|C|$]]]|1A|$1B|$5|1C|1D|1E|C|$1F|1G]]|1H|$5|1I|1D|1J|C|$1K|1L|1M|-4]]]]

Sourced from <a href="https://web.archive.org/web/20170325093701/https://www.codetab.org/apache-maven-tutorial/" rel="nofollow noreferrer">this really good tutorial</a>:
Lifecycles, Lifecycle Phases, Plugins and Plugin Goals are the core of Maven.
<ul>
<li>The Maven command mvn only accepts Lifecycle Phases or Plugin Goals as arguments.</li>
<li>Maven comes with three lifecycles: default, clean and site.</li>
<li>Each lifecycle is made up of lifecycle phases and in all, there are 28 phases – 21 in default (validate, ..., compile, ..., package, ..., install, deploy), 3 in clean (pre-clean, clean, post-clean) and 4 in site (pre-site, site, post-site, site-deploy).</li>
<li>When a lifecycle phase is invoked using the <code>mvn</code> command, all preceding phases are executed sequentially one after another.</li>
<li>lifecycle phases by themselves don’t have the capability to accomplish any task, and they rely on plugins to carry out the task.</li>
<li>depending on the project and packaging type, Maven binds various plugin goals to lifecycle phases and goals carry out the task entrusted to them.</li>
</ul>
When we run <code>mvn package</code> in a Java Project, Maven binds plugin goals to lifecycle phases as shown in the figure below:
<img src="https://i.stack.imgur.com/MOw5a.png" alt="mvn-plugins-package-goal" />

blocks|key|144073|text|还有另一个迟来的图表|type|unstyled|depth|inlineStyleRanges|entityRanges|data|144074|144075|生命周期是生命周期的黄色rectangles|unordered-list-item|144076|Phases，是带有深蓝色"callable"阶段的蓝色矩形(即，通常不会从命令行调用带有升序的阶段，因为它们可能不会被设计为使项目处于明确定义的状态)。|offset|length|144077|的目标是蓝色长片。所示的关联/绑定“阶段->目标”是"jar“打包模式之一。每个阶段都可以有与之绑定的目标。当然，这适用于每个生命周期，尽管绑定只对“默认”lifecycle.|144078|Plugins显示为灰色剪裁的矩形。插件提供了可以绑定到各个阶段的目标。|144079|144080|​|144081|📷|atomic|144082|144083|entityMap|0|LINK|mutability|MUTABLE|url|https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Some_Phases_Are_Not_Usually_Called_From_the_Command_Line|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/1c584d2e489cd5deaf4b60e65442087a.png|imageAlt^0|0|0|0|D|A|0|0|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|1B|8|@]|9|@$H|1C|I|1D|1|1E]]|A|$]]|$1|J|3|K|5|E|7|1F|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|1G|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1J|8|@]|9|@$H|1K|I|1L|1|1M]]|A|$]]|$1|T|3|P|5|6|7|1N|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|13|Y|14|A|$15|16|17|-4]]]]

And belatedly another diagram

<ul>
<li>Lifecycles as yellow rectangles</li>
<li>Phases of lifecycles as blue rectangles with
<a href="https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Some_Phases_Are_Not_Usually_Called_From_the_Command_Line" rel="noreferrer">"callable"</a> phases in darker blue (i.e. the phases with hypenation are not usually called from the command line as they may not be designed to leave the project in a well-defined state).</li>
<li>Goals as blue lozenges. The association/binding "phase -> goal" shown is the one of the "jar" packaging mode. Every phase can have goals bound to it. This holds of course for each of the lifecycles, although bindings are only show for the "default" lifecycle.</li>
<li>Plugins as grey clipped rectangles. Plugins provide the Goals that can be bound to the Phases.</li>
</ul>

<a href="https://i.stack.imgur.com/DU5hL.png" rel="noreferrer"><img src="https://i.stack.imgur.com/DU5hL.png" alt="Maven Lifecycles, Phases, Goals, Plugins"></a>

blocks|key|2935588|text|LifeCycle+vs阶段：+Life+Cycle是phases的集合。当您调用一个阶段时，它也将调用它之前的所有阶段。Maven提供了3个内置的构建生命周期，包括：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|2935589|java站点清理生命周期-这涉及项目的清理(对于全新的构建和deployment)|2935590|Default/build生命周期-这处理项目|unordered-list-item|2935591|
|2935592|2935593|2935594|生命周期的完整部署-这处理生成项目的java文档。|2935595|2935596|📷|atomic|2935597|​|2935598|清洁生命周期分为3个阶段:前清洁、清洁和后清洁。默认和站点生命周期的阶段如图所示。|2935599|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/903a8b8e9daf493c6a6b6215ce14cd86.png|imageAlt^0|0|F|G|A|R|6|0|0|0|0|0|0|0|0|0|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|D]|$9|1D|A|1E|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1F|8|@]|E|@]|F|$]]|$1|I|3|J|5|K|7|1G|8|@]|E|@]|F|$]]|$1|L|3|M|5|6|7|1H|8|@]|E|@]|F|$]]|$1|N|3|-4|5|K|7|1I|8|@]|E|@]|F|$]]|$1|O|3|M|5|6|7|1J|8|@]|E|@]|F|$]]|$1|P|3|Q|5|K|7|1K|8|@]|E|@]|F|$]]|$1|R|3|-4|5|6|7|1L|8|@]|E|@]|F|$]]|$1|S|3|T|5|U|7|1M|8|@]|E|@$9|1N|A|1O|1|1P]]|F|$]]|$1|V|3|W|5|6|7|1Q|8|@]|E|@]|F|$]]|$1|X|3|Y|5|6|7|1R|8|@]|E|@]|F|$]]|$1|Z|3|-4|5|6|7|1S|8|@]|E|@]|F|$]]]|10|$11|$5|12|13|14|F|$15|16|17|-4]]]]

LifeCycle vs Phases:
<code>Life Cycle</code> is a collection of <code>phases</code>. When you call a phase, it will also call all phases that come before it.
Maven comes with 3 built-in build life cycles as:

<ol>
<li>Clean lifecycle- this involves cleaning of the project (for a fresh build &amp; deployment)</li>
<li>Default/build lifecycle- this handles the complete deployment of the project</li>
<li>Site lifecycle- this handles generating the java documentation of the project.
<a href="https://i.stack.imgur.com/Fgn42.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Fgn42.png" alt="enter image description here"></a></li>
</ol>

Clean lifecycle has 3 phases: pre-clean, clean and post-clean. Default and site lifecycles' phases are same as shown in the picture.

Relatively new developer here, even though I've been using it for a little while, I'm hoping to solidify my Maven fundamentals. Part of my problem is that I have no experience with Ant, which seems to be from where many explanations stem. I've been reading and watching tutorials, and I keep hearing the same terms:

<ul>
<li>Lifecycle</li>
<li>Phase</li>
<li>Plugin</li>
<li>Goal</li>
</ul>

From what I've learned, it seems that lifecycle is the broadest of the bunch, and is composed of (or completed by) phases, plugins, and/or goals.

Question: Could you provide any info on how these terms are related and the most common examples?

The more explicit and basic, the better!

Maven: Lifecycle vs. Phase vs. Plugin vs. Goal

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

这里相对较新的开发人员，尽管我已经使用了一段时间，但我希望巩固我的Maven基础。我的部分问题是我没有使用的经验，这似乎是许多解释的根源。我一直在阅读和观看教程，我总是听到相同的术语：LifecyclePhasePluginGoal据我所知，生命周期似乎是最广泛的，由阶段、插件和/或目标组成(或完成)。 terms ：...

问Maven:生命周期与阶段、插件与目标
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Maven:生命周期与阶段、插件与目标EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Maven:生命周期与阶段、插件与目标
EN