blocks|key|2180699|text|“发布”是不会更改的版本的最终构建。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2180700|“快照”是一个构建，它可以被具有相同名称的另一个构建替换。这意味着构建可以在任何时候更改，并且仍在积极开发中。|2180701|基于相同代码的不同构建有不同的工件。例如，你可能有一个有调试功能，而另一个没有。一个用于Java+5.0，另一个用于Java+6。通常情况下，使用一个构建来完成所需的所有任务会更简单。;)|2180702|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

A "release" is the final build for a version which does not change.

A "snapshot" is a build which can be replaced by another build which has the same name. It implies that the build could change at any time and is still under active development.

You have different artifacts for different builds based on the same code. E.g. you might have one with debugging and one without. One for Java 5.0 and one for Java 6. Generally its simpler to have one build which does everything you need. ;)

blocks|key|4255757|text|“快照”这个术语意味着构建是在给定时间内代码的快照。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4255758|这通常意味着这个版本仍在大力开发中。|4255759|当代码准备就绪，是时候发布它时，您将希望更改POM中列出的版本。然后，你可以使用"1.0“这样的标签，而不是”快照“。|4255760|有关版本控制的一些帮助，请查看Semantic+Versioning+specification。|offset|length|4255761|entityMap|0|LINK|mutability|MUTABLE|url|http://semver.org/^0|0|0|0|F|X|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

The "SNAPSHOT" term means that the build is a snapshot of your code at a given time.

It usually means that this version is still under heavy development.

When the code is ready and it is time to release it, you will want to change the version listed in the POM. Then instead of having a "SNAPSHOT" you would use a label like "1.0".

For some help with versioning, check out the <a href="http://semver.org/" rel="noreferrer">Semantic Versioning specification</a>.

blocks|key|2462624|text|Maven中的快照版本是尚未发布的版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2462625|这个想法是，在一个1.0版本(或任何其他版本)完成之前，存在一个1.0-SNAPSHOT。这个版本可能会变成1.0。它基本上是“开发中的1.0”。这可能接近于真正的1.0发行版，也可能相当遥远(例如，在0.9发行版之后)。|offset|length|style|BOLD|CODE|2462626|“真实”版本和快照版本之间的区别在于，快照可能会得到更新。这意味着今天下载1.0-SNAPSHOT可能会得到一个不同于昨天或明天下载的文件。|2462627|通常，快照依赖关系应该在开发过程中只存在，并且没有发布版本(即没有非快照)应该依赖于快照版本。|2462628|entityMap^0|0|7|2W|9|3|W|C|1I|3|1W|3|2A|3|2T|3|0|0|1Y|11|C|0|0|K|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|H]|$D|U|E|V|F|H]|$D|W|E|X|F|H]|$D|Y|E|Z|F|H]|$D|10|E|11|F|H]|$D|12|E|13|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|14|8|@$D|15|E|16|F|G]|$D|17|E|18|F|H]]|9|@]|A|$]]|$1|K|3|L|5|6|7|19|8|@$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|N|$]]

A snapshot version in Maven is one that has not been released.

The idea is that before a <code>1.0</code> release (or any other release) is done, there exists a <code>1.0-SNAPSHOT</code>. That version is what might become <code>1.0</code>. It's basically "<code>1.0</code> under development". This might be close to a real <code>1.0</code> release, or pretty far (right after the <code>0.9</code> release, for example).

The difference between a "real" version and a snapshot version is that snapshots might get updates. That means that downloading <code>1.0-SNAPSHOT</code> today might give a different file than downloading it yesterday or tomorrow.

Usually, snapshot dependencies should only exist during development and no released version (i.e. no non-snapshot) should have a dependency on a snapshot version.

blocks|key|4255891|text|其他三个答案让您很好地了解了什么是-SNAPSHOT版本。我只是想添加一些有关Maven在发现SNAPSHOT依赖项时的行为的信息。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4255892|当您构建应用程序时，Maven将在本地存储库中搜索依赖项。如果在那里找不到稳定的版本，它将搜索远程存储库(在settings.xml或pom.xml中定义)以检索此依赖项。然后，它会将其复制到本地存储库中，以使其可用于下一次构建。|BOLD|4255893|例如，一个foo-1.0.jar库被认为是一个稳定的版本，如果它在本地存储库中找到它，它将在当前构建中使用这个版本。|4255894|现在，如果您需要一个foo-1.0-SNAPSHOT.jar库，Maven会知道这个版本并不稳定，可能会发生变化。这就是为什么Maven会尝试在远程存储库中查找较新的版本，即使在本地存储库中找到了该库的版本。但是，这种检查每天只进行一次。这意味着如果您的本地存储库中有一个foo-1.0-20110506.110000-1.jar+(即这个库是在2011/05/06+11:00:00生成的)，并且如果您在同一天再次运行Maven构建，那么Maven将不会检查存储库是否有更新的版本。|4255895|Maven为您提供了一种在存储库定义中更改此更新策略的方法：|4255896|<repository>
++++<id>foo-repository</id>
++++<url>...</url>
++++<snapshots>
++++++++<enabled>true</enabled>
++++++++<updatePolicy>XXX</updatePolicy>
++++</snapshots>
</repository>|code-block|syntax|javascript|4255897|其中XXX可以是：|4255898|4255899|always：Maven将在每个build;|unordered-list-item|4255900|daily，上检查更新的版本，默认的value;|4255901|interval:XXX：间隔为分钟，(XXX)|4255902|never：Maven永远不会尝试检索另一个版本。只有当它不存在于本地时，它才会这样做。通过配置，SNAPSHOT版本将作为稳定的库进行处理。|4255903|4255904|(可以在here)上找到settings.xml的型号|4255905|entityMap|0|LINK|mutability|MUTABLE|url|http://maven.apache.org/ref/2.2.1/maven-settings/settings.html^0|H|9|1B|8|0|H|2|1I|C|1V|7|0|5|B|N|3|0|A|K|3S|T|0|0|0|2|3|0|0|0|6|0|0|5|0|0|C|0|0|5|1D|8|0|0|4|5|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1L|8|@$9|1M|A|1N|B|H]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|H]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|22|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|23|8|@]|D|@]|E|$R|S]]|$1|T|3|U|5|6|7|24|8|@$9|25|A|26|B|C]]|D|@]|E|$]]|$1|V|3|-4|5|6|7|27|8|@]|D|@]|E|$]]|$1|W|3|X|5|Y|7|28|8|@$9|29|A|2A|B|H]]|D|@]|E|$]]|$1|Z|3|10|5|Y|7|2B|8|@$9|2C|A|2D|B|H]]|D|@]|E|$]]|$1|11|3|12|5|Y|7|2E|8|@$9|2F|A|2G|B|H]]|D|@]|E|$]]|$1|13|3|14|5|Y|7|2H|8|@$9|2I|A|2J|B|H]|$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|15|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|2N|8|@]|D|@$9|2O|A|2P|1|2Q]]|E|$]]|$1|18|3|-4|5|6|7|2R|8|@]|D|@]|E|$]]]|19|$1A|$5|1B|1C|1D|E|$1E|1F]]]]

The three others answers provide you a good vision of what a <code>-SNAPSHOT</code> version is. I just wanted to add some information regarding the behavior of Maven when it finds a <code>SNAPSHOT</code> dependency.

When you build an application, Maven will search for dependencies in the local repository. If a stable version is not found there, it will search the remote repositories (defined in <code>settings.xml</code> or <code>pom.xml</code>) to retrieve this dependency. Then, it will copy it into the local repository, to make it available for the next builds.

For example, a <code>foo-1.0.jar</code> library is considered as a stable version, and if Maven finds it in the local repository, it will use this one for the current build.

Now, if you need a <code>foo-1.0-SNAPSHOT.jar</code> library, Maven will know that this version is not stable and is subject to changes. That's why Maven will try to find a newer version in the remote repositories, even if a version of this library is found on the local repository. However, this check is made only once per day. That means that if you have a <code>foo-1.0-20110506.110000-1.jar</code> (i.e. this library has been generated on 2011/05/06 at 11:00:00) in your local repository, and if you run the Maven build again the same day, Maven will not check the repositories for a newer version.

Maven provides you a way to change this update policy in your repository definition:

<pre><code>&lt;repository&gt;
 &lt;id&gt;foo-repository&lt;/id&gt;
 &lt;url&gt;...&lt;/url&gt;
 &lt;snapshots&gt;
 &lt;enabled&gt;true&lt;/enabled&gt;
 &lt;updatePolicy&gt;XXX&lt;/updatePolicy&gt;
 &lt;/snapshots&gt;
&lt;/repository&gt;
</code></pre>

where <code>XXX</code> can be:

<ul>
<li>always: Maven will check for a newer version on every build;</li>
<li>daily, the default value;</li>
<li>interval:XXX: an interval in minutes (XXX)</li>
<li>never: Maven will never try to retrieve another version. It will do that only if it doesn't exist locally. With the configuration, <code>SNAPSHOT</code> version will be handled as the stable libraries.</li>
</ul>

(model of the settings.xml can be found <a href="http://maven.apache.org/ref/2.2.1/maven-settings/settings.html" rel="noreferrer">here)</a>

blocks|key|2462697|text|这就是存储库的快照外观，在本例中没有启用，这意味着这里提到的存储库是稳定的，不需要更新。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2462698|<project>
++++...
++++<repositories>
++++++++<repository>
++++++++++++<id>lds-main</id>
++++++++++++<name>LDS+Main+Repo</name>
++++++++++++<url>http://code.lds.org/nexus/content/groups/main-repo</url>
++++++++++++<snapshots>
++++++++++++++++<enabled>false</enabled>
++++++++++++</snapshots>
++++++++</repository>
++++</repositories>
</project>|code-block|syntax|javascript|2462699|另一种情况是：|2462700|<snapshots>
++++++++<enabled>true</enabled>
</snapshots>|2462701|这意味着Maven将查找此存储库的更新。您还可以指定使用标签更新的时间间隔。|2462702|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is how a snapshot looks like for a repository and in this case is not enabled, which means that the repository referred in here is stable and there's no need for updates.

<pre><code>&lt;project&gt;
 ...
 &lt;repositories&gt;
 &lt;repository&gt;
 &lt;id&gt;lds-main&lt;/id&gt;
 &lt;name&gt;LDS Main Repo&lt;/name&gt;
 &lt;url&gt;http://code.lds.org/nexus/content/groups/main-repo&lt;/url&gt;
 &lt;snapshots&gt;
 &lt;enabled&gt;false&lt;/enabled&gt;
 &lt;/snapshots&gt;
 &lt;/repository&gt;
 &lt;/repositories&gt;
&lt;/project&gt;
</code></pre>

Another case would be for:

<pre><code>&lt;snapshots&gt;
 &lt;enabled&gt;true&lt;/enabled&gt;
&lt;/snapshots&gt;
</code></pre>

which means that Maven will look for updates for this repository. You can also specify an interval for the updates with tag.

blocks|key|2462741|text|在maven中，我们通常有两种类型的构建:1)快照构建2)发布构建|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2462742|2462743|snapshot+builds：|ordered-list-item|2462744|是一种特殊版本，它指示当前部署副本与常规版本不同，maven会检查远程存储库中每个版本的版本，因此快照版本只是开发版本：表示在版本上删除快照，这些是常规版本。|2462745|2462746|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|M|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|N|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

usually in maven we have two types of builds 
1)Snapshot builds
2)Release builds

<ol>
<li>snapshot builds:SNAPSHOT is the special version that indicate current deployment copy not like a regular version, maven checks the version for every build in the remote repository
so the snapshot builds are nothing but development builds.</li>
<li>Release builds:Release means removing the SNAPSHOT at the version for the build, these are the regular build versions.</li>
</ol>

blocks|key|4256058|text|Maven版本可以包含字符串文字"SNAPSHOT“，表示项目当前正在积极开发中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4256059|例如，如果您的项目有一个“1.0-SNAPSHOT”版本，并且您将此项目的工件部署到一个Maven存储库，如果您打算在UTC时间2008年2月7日晚上11:08部署一个版本，那么Maven会将此版本扩展到“1.0-20080207-230803-1”。换句话说，当您部署快照时，您不是在发布软件组件；而是在特定时间发布组件的快照。|4256060|因此，快照版本主要用于正在开发中的项目。如果您的项目依赖于处于活动开发中的软件组件，则可以依赖快照版本，并且在您运行构建时，Maven将定期尝试从存储库下载最新的快照。类似地，如果您的系统的下一个版本将是“1.8”，那么在正式发布之前，您的项目将有一个“1.8-SNAPSHOT”版本。|4256061|例如，以下依赖项将始终下载spring的最新1.8开发JAR：|4256062|++++<dependency>
++++++++<groupId>org.springframework</groupId>
++++++++<artifactId>spring</artifactId>
++++++++<version>1.8-SNAPSHOT”</version>
++++</dependency>|code-block|syntax|javascript|4256063|Maven|offset|length|4256064|maven发布过程的一个示例|4256065|​|4256066|📷|atomic|4256067|4256068|entityMap|0|LINK|mutability|MUTABLE|url|https://books.google.de/books?id=cBvZ4s72Z0gC&printsec=frontcover&dq=Maven:%2520The%2520Definitive%2520Guide:%2520The%2520Definitive%2520Guide%2520pdf&hl=en&sa=X&ved=0ahUKEwjd89yxsYbVAhUSb5oKHWQ1ANkQ6AEIIjAA#v=onepage&q=Maven%253A%2520The%2520Definitive%2520Guide%253A%2520The%2520Definitive%2520Guide%2520pdf&f=false|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/09c87c250efcfda3ba013ad6c5737cdb.png|imageAlt^0|0|0|0|0|0|0|5|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1F|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1H|8|@]|9|@$O|1I|P|1J|1|1K]]|A|$]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|1N|8|@]|9|@$O|1O|P|1P|1|1Q]]|A|$]]|$1|X|3|T|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|17|12|18|A|$19|1A|1B|-4]]]]

Maven versions can contain a string literal "SNAPSHOT" to signify that a project is currently under active development.

For example, if your project has a version of “1.0-SNAPSHOT” and you deploy this project’s artifacts to a Maven repository,
Maven would expand this version to “1.0-20080207-230803-1” if you were to
deploy a release at 11:08 PM on February 7th, 2008 UTC. In other words, when you
deploy a snapshot, you are not making a release of a software component; you are
releasing a snapshot of a component at a specific time.

So mainly snapshot versions are used for projects under active development.
If your project depends on a software component that is under active development,
you can depend on a snapshot release, and Maven will periodically attempt
to download the latest snapshot from a repository when you run a build. Similarly, if
the next release of your system is going to have a version “1.8,” your project would
have a “1.8-SNAPSHOT” version until it was formally released.

For example , the following dependency would always download the latest 1.8 development JAR of spring:

<pre><code> &lt;dependency&gt;
 &lt;groupId&gt;org.springframework&lt;/groupId&gt;
 &lt;artifactId&gt;spring&lt;/artifactId&gt;
 &lt;version&gt;1.8-SNAPSHOT”&lt;/version&gt;
 &lt;/dependency&gt;
</code></pre>

<a href="https://books.google.de/books?id=cBvZ4s72Z0gC&amp;printsec=frontcover&amp;dq=Maven:%20The%20Definitive%20Guide:%20The%20Definitive%20Guide%20pdf&amp;hl=en&amp;sa=X&amp;ved=0ahUKEwjd89yxsYbVAhUSb5oKHWQ1ANkQ6AEIIjAA#v=onepage&amp;q=Maven%3A%20The%20Definitive%20Guide%3A%20The%20Definitive%20Guide%20pdf&amp;f=false" rel="noreferrer">Maven</a>

An example of maven release process

<a href="https://i.stack.imgur.com/BAYDk.png" rel="noreferrer"><img src="https://i.stack.imgur.com/BAYDk.png" alt="enter image description here"></a>

blocks|key|2181086|text|我想提出一个关于术语的观点。其他答案很好地解释了在Maven的上下文中什么是“快照”版本。但是，是否是说非快照版本应该被称为“发布”版本？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2181087|在“发布”版本的语义版本控制思想和Maven的“发布”版本概念之间存在一些紧张关系，“发布”版本似乎是没有-SNAPSHOT等限定符但也没有-beta.4等限定符的任何版本；Maven的"release“版本思想似乎只包括-SNAPSHOT的缺失。|offset|length|style|CODE|2181088|换句话说，对于“发布”是否意味着“我们可以将其发布到Maven+Central”或“软件正处于向公众发布的最终版本”，存在语义上的模糊性。如果我们向公众发布-beta.4，我们可以认为它是一个“发布”版本，但它不是一个“最终发布”。Semantic+versioning明确地说，像-beta.4这样的东西是一个“预发布”版本，所以即使没有-SNAPSHOT，它也没有意义被称为“发布”版本。事实上，根据定义，即使是-rc.5也是一个候选版本，而不是一个实际的版本，即使我们可能允许公众访问测试。|2181089|因此，尽管有Maven，但在我看来，更合适的做法是只调用一个根本没有任何限定符的“发布”版本，甚至没有-beta.4。也许Maven+snapshot版本更好的名称应该是“稳定”版本(灵感来自another+answer)。因此，我们将拥有：|2181090|2181091|1.2.3-beta.4-SNAPSHOT：预发布version.|unordered-list-item|2181092|1.2.3-SNAPSHOT：的快照版本发布version.|2181093|1.2.3-beta.4：的快照版本预发布version.|2181094|1.2.3：A发布版本的稳定版本(显然是稳定的非快照版本)。|2181095|2181096|entityMap|0|LINK|mutability|MUTABLE|url|https://semver.org/#spec-item-9|1|https://stackoverflow.com/a/5907727/421049^0|0|1H|9|1Y|7|33|9|0|26|7|3X|7|4Q|9|5S|5|38|J|0|0|1F|7|2O|E|1|0|0|0|L|0|0|E|0|0|C|0|0|5|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1E|8|@$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]|$D|1L|E|1M|F|G]]|9|@$D|1N|E|1O|1|1P]]|A|$]]|$1|J|3|K|5|6|7|1Q|8|@$D|1R|E|1S|F|G]]|9|@$D|1T|E|1U|1|1V]]|A|$]]|$1|L|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1X|8|@$D|1Y|E|1Z|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|O|7|20|8|@$D|21|E|22|F|G]]|9|@]|A|$]]|$1|R|3|S|5|O|7|23|8|@$D|24|E|25|F|G]]|9|@]|A|$]]|$1|T|3|U|5|O|7|26|8|@$D|27|E|28|F|G]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|29|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]]]

I'd like to make a point about terminology. The other answers gave good explanations about what a "snapshot" version is in the context of Maven. But does it follow that a non-snapshot version should be termed a "release" version?

There is some tension between the semantic versioning idea of a "release" version, which would seem to be any version that does not have a qualifier such as <code>-SNAPSHOT</code> but also does not have a qualifier such as <code>-beta.4</code>; and Maven's idea idea of a "release" version, which only seems to include the absence of <code>-SNAPSHOT</code>.

In other words, there is a semantic ambiguity of whether "release" means "we can release it to Maven Central" or "the software is in its final release to the public". We could consider <code>-beta.4</code> to be a "release" version if we release it to the public, but it's not a "final release". <a href="https://semver.org/#spec-item-9" rel="noreferrer">Semantic versioning</a> clearly says that something like <code>-beta.4</code> is a "pre-release" version, so it wouldn't make sense for it to be called a "release" version, even without <code>-SNAPSHOT</code>. In fact by definition even <code>-rc.5</code> is a release candidate, not an actual release, even though we may allow public access for testing.

So Maven notwithstanding, in my opinion it seems more appropriate only to call a "release" version one that doesn't have any qualifier at all, not even <code>-beta.4</code>. Perhaps a better name for a Maven non-snapshot version would be a "stable" version (inspired by <a href="https://stackoverflow.com/a/5907727/421049">another answer</a>). Thus we would have:

<ul>
<li><code>1.2.3-beta.4-SNAPSHOT</code>: A snapshot version of a pre-release version.</li>
<li><code>1.2.3-SNAPSHOT</code>: A snapshot version of a release version.</li>
<li><code>1.2.3-beta.4</code>: A stable version of a pre-release version.</li>
<li><code>1.2.3</code>: A release version (which is a stable, non-snapshot version, obviously).</li>
</ul>

blocks|key|561338|text|理解SDLC的上下文将有助于理解快照和发行版之间的区别。在开发过程中，所有的开发人员都将他们的特性贡献给一个基线分支。在某个时刻，领导者认为已经积累了足够多的功能，然后他将从基线分支中删除一个发布分支。在此时间点之前的任何构建都是快照。发布到这一点的版本都是发行版。需要注意的是，如果在发布测试期间发现任何缺陷，那么在投入生产之前，发布版本也可能会发生变化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|561339|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

understanding the context of SDLC will help understand the difference between snapshot and the release. During the dev process developers all contribute their features to a baseline branch. At some point the lead thinks enough features have accumulated then he will cut a release branch from the baseline branch. Any builds prior to this time point are snapshots. Builds post to this point are releases. Be noted, release builds could change too before going to production if any defect spot during the release testing.

blocks|key|2463003|text|简单地说，快照意味着它是不稳定的版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2463004|当版本包含像1.0.0这样的快照时，-SNAPSHOT意味着它不是稳定的版本，并寻找远程存储库来解决依赖关系|2463005|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

simply snapshot means it is the version which is not stable one.

when version includes snapshot like 1.0.0 -SNAPSHOT means it is not stable version and look for remote repository to resolve dependencies

blocks|key|4256278|text|快照仅仅意味着根据您的配置，Maven将检查一个特殊依赖项的最新更改。快照是不稳定的，因为它正在开发中，但如果在特殊项目上需要有最新的更改，您必须将依赖项版本配置为快照版本。这种情况发生在拥有多个产品的大型组织中，这些产品彼此之间的关系非常密切。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4256279|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Snapshot simply means depending on your configuration Maven will check latest changes on a special dependency. Snapshot is unstable because it is under development but if on a special project needs to has a latest changes you must configure your dependency version to snapshot version. This scenario occurs in big organizations with multiple products that these products related to each other very closely.

blocks|key|4256330|text|顾名思义，快照指的是项目及其依赖项在该时刻的状态。只要maven找到项目的较新快照，它就会下载并替换本地存储库中较旧的项目.jar文件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4256331|快照版本用于正在开发中的项目。如果您的项目依赖于处于活动开发中的软件组件，则可以依赖快照版本，并且在您运行构建时，Maven将定期尝试从存储库下载最新的快照。|4256332|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

As the name suggests, snapshot refers to a state of project and its dependencies at that moment of time. Whenever maven finds a newer SNAPSHOT of the project, it downloads and replaces the older .jar file of the project in the local repository.

Snapshot versions are used for projects under active development. If your project depends on a software component that is under active development, you can depend on a snapshot release, and Maven will periodically attempt to download the latest snapshot from a repository when you run a build.

blocks|key|2463127|text|Maven快照是由Maven构建创建的工件，旨在帮助软件开发周期中的开发人员。快照是一个工件(或项目构建结果)，不会假装在任何地方使用，它只是一个临时的.jar、ear、...创建它是为了测试构建过程或测试尚未准备好进入生产环境的新需求。在您对快照工件的质量感到满意之后，您可以创建一个可供其他项目使用或自身部署的发布工件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2463128|在您的项目中，您可以使用Maven的pom.xml文件中的version元素来定义快照：|2463129|<groupId>example.project.maven</groupId>
<artifactId>MavenEclipseExample</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<description>Maven+pom+example</description>|code-block|syntax|javascript|2463130|如果你想更好的理解Maven，你也可以看看这些文章：|2463131|https://connected2know.com/programming/menu-maven-articles/|offset|length|2463132|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|1N|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Z|8|@]|9|@$M|10|N|11|1|12]]|A|$]]|$1|O|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|L]]]]

A Maven SNAPSHOT is an artifact created by a Maven build and pretends to help developers in the software development cycle.
A SNAPSHOT is an artifact (or project build result ) that is not pretended to be used anywhere, it's only a temporarily .jar, ear, ... created to test the build process or to test new requirements that are not yet ready to go to a production environment.
After you are happy with the SNAPSHOT artifact quality, you can create a RELEASE artifact that can be used by other projects or can be deployed itself.
In your project, you can define a SNAPSHOT using the version element in the pom.xml file of Maven:
<pre><code>&lt;groupId&gt;example.project.maven&lt;/groupId&gt;
&lt;artifactId&gt;MavenEclipseExample&lt;/artifactId&gt;
&lt;version&gt;0.0.1-SNAPSHOT&lt;/version&gt;
&lt;packaging&gt;jar&lt;/packaging&gt;
&lt;description&gt;Maven pom example&lt;/description&gt;
</code></pre>
If you want to understand better Maven you can look into these articles too:
<a href="https://connected2know.com/programming/menu-maven-articles/" rel="nofollow noreferrer">https://connected2know.com/programming/menu-maven-articles/</a>

blocks|key|2181454|text|快照依赖项快照依赖项是正在开发中的依赖项(JAR文件)。您可以依赖项目的快照版本，而不是不断更新版本号以获取最新版本。每次构建都会将快照版本下载到本地存储库中，即使本地存储库中已经存在匹配的快照版本也是如此。始终下载快照依赖关系可确保您的本地存储库中始终存在每个构建的最新版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2181455|您的pom包含许多-SNAPSHOT依赖项，而这些-SNAPSHOT依赖项是一个移动的目标。|2181456|📷|atomic|offset|length|2181457|​|2181458|2181459|2181460|2181461|https://dzone.com/articles/maven-release-plugin-in-the-enterprise+https://javarevisited.blogspot.com/2019/03/top-5-course-to-learn-apache-maven-for.html+https://www.mojohaus.org/versions-maven-plugin/examples/lock-snapshots.html+http://tutorials.jenkov.com/maven/maven-tutorial.html|2181462|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/09943d49a89bbc65d11f38acada7c4fe.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/2a3adcfcb24ddd16fbfc5474d0bc5d03.png|2|LINK|MUTABLE|url|https://dzone.com/articles/maven-release-plugin-in-the-enterprise|3|https://javarevisited.blogspot.com/2019/03/top-5-course-to-learn-apache-maven-for.html|4|https://www.mojohaus.org/versions-maven-plugin/examples/lock-snapshots.html|5|http://tutorials.jenkov.com/maven/maven-tutorial.html^0|0|0|0|1|0|0|0|0|0|1|1|0|0|0|1T|2|1U|2E|3|49|23|4|6D|1H|5|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1D|8|@]|9|@$G|1E|H|1F|1|1G]]|A|$]]|$1|I|3|J|5|6|7|1H|8|@]|9|@]|A|$]]|$1|K|3|J|5|6|7|1I|8|@]|9|@]|A|$]]|$1|L|3|E|5|F|7|1J|8|@]|9|@$G|1K|H|1L|1|1M]]|A|$]]|$1|M|3|J|5|6|7|1N|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1O|8|@]|9|@$G|1P|H|1Q|1|1R]|$G|1S|H|1T|1|1U]|$G|1V|H|1W|1|1X]|$G|1Y|H|1Z|1|20]]|A|$]]|$1|P|3|-4|5|6|7|21|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W|X|-4]]|Y|$5|S|T|U|A|$V|Z|X|-4]]|10|$5|11|T|12|A|$13|14]]|15|$5|11|T|12|A|$13|16]]|17|$5|11|T|12|A|$13|18]]|19|$5|11|T|12|A|$13|1A]]]]

Snapshot Dependencies
Snapshot dependencies are dependencies (JAR files) which are under development. Instead of constantly updating the version numbers to get the latest version, you can depend on a snapshot version of the project. Snapshot versions are always downloaded into your local repository for every build, even if a matching snapshot version is already located in your local repository. Always downloading the snapshot dependencies assures that you always have the latest version in your local repository, for every build.
your pom contains a lot of -SNAPSHOT dependencies and those -SNAPSHOT dependencies are a moving target
<a href="https://i.stack.imgur.com/F9fSu.png" rel="noreferrer"><img src="https://i.stack.imgur.com/F9fSu.png" alt="enter image description here" /></a>
<a href="https://i.stack.imgur.com/zaRRt.png" rel="noreferrer"><img src="https://i.stack.imgur.com/zaRRt.png" alt="enter image description here" /></a>
<a href="https://dzone.com/articles/maven-release-plugin-in-the-enterprise" rel="noreferrer">https://dzone.com/articles/maven-release-plugin-in-the-enterprise</a>
<a href="https://javarevisited.blogspot.com/2019/03/top-5-course-to-learn-apache-maven-for.html" rel="noreferrer">https://javarevisited.blogspot.com/2019/03/top-5-course-to-learn-apache-maven-for.html</a>
<a href="https://www.mojohaus.org/versions-maven-plugin/examples/lock-snapshots.html" rel="noreferrer">https://www.mojohaus.org/versions-maven-plugin/examples/lock-snapshots.html</a>
<a href="http://tutorials.jenkov.com/maven/maven-tutorial.html" rel="noreferrer">http://tutorials.jenkov.com/maven/maven-tutorial.html</a>

I am a bit confused about the meaning of a Maven Snapshot and why we build one?

What exactly is a Maven Snapshot and why do we need it?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我对Maven Snapshot的含义以及我们为什么要构建它感到有点困惑。

问Maven Snapshot到底是什么，我们为什么需要它？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Maven Snapshot到底是什么，我们为什么需要它？EN