Maven安装和基础知识

回到首页☞

Maven的发明创造肯定有技术，使用起来确实简单。
但是我们还是要理一理，为了使用起来高效，处理疑问更快。

下载安装

注意下window安装软件最好保持路径无空格。

• 前往https://maven.apache.org/download.cgi下载最新版的Maven程序：
• 将文件解压到E:\setup\apache-maven-3.6.0目录下:
• 配置环境变量
  MAVEN_HOME：E:\setup\apache-maven-3.6.0
  path：MAVEN_HOME\bin
• 检测
  dos下运行命令mvn -v

settings.xml配置

本地仓库是个资源缓冲区，会把远程仓库的jar资源同步到本地，以便以后可以本地高效使用。

E:\setup\apache-maven-3.6.0\conf\settings.xml

核心也就是这个settings.xml文件了：

• 创建一个目录D:\mavne\maven-repository
• settiing中配置本地库

<localRepository>D:\mavne\maven-repository

• 配置阿里云镜像（因为要访问国外服务器，会很慢）
  镜像说白了就是一个云上jar包资源仓库，配置了这个远程仓库，我们就可以使用这个资源，第一次引入jar的时候就会下载jar包到本地仓库。
  当然公司一般有自己的公共仓库，配置配置公司内网仓库即可，因为IT公司都有信息安全考虑，不可能把项目暴露在互联网上，让人随便入侵。

<mirror>
        <id>mirrorId</id>
        <mirrorOf>central</mirrorOf>
        <name>Human Readable Name </name>
        <url>http://repo1.maven.org/maven2/</url>
    </mirror>
    <!-- 又一个镜像 -->
    <mirror> 
        <id>alimaven</id> 
        <name>aliyun maven</name> 
        <url>http://central.maven.org/maven2</url> 
        <mirrorOf>central</mirrorOf> 
    </mirror>
 
    <!-- 阿里云镜像2 -->
    <mirror> 
        <id>alimaven</id> 
        <name>aliyun maven</name> 
        <url>http://maven.aliyun.com/nexus/content/repositories/central/</url> 
        <mirrorOf>central</mirrorOf> 
    </mirror>
    
  </mirrors>

有了上面这些配置maven就已经可用了，下面就要考虑怎么和IDEA等集成工具配合工作。

IDEA 嵌入maven

IDEA 工程右键会看到也有个settings设置，这里可以设置Maven。
Maven是项目构建工具，所以所在位置如上图，其中软件位置，配置文件位置，和本地仓库都可以手工设置。

项目使用maven–pom.xml详解

工程嵌入了maven，就可以创建maven工程，maven核心就是一个坐标文件pom.xml
至于IDEA怎么解析pom.xml，怎么用pom.xml来配合project工作的暂时不做深入研究，只是了解下pom.xml的使用。

Project Object Model，项目对象模型。通过xml可扩展标记语言（EXtensible Markup Language）格式保存的pom.xml文件。作用类似ant的build.xml文件，功能更强大。该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。
一个完整的pom.xml文件，放置在项目的根目录下。

<project xmlns="http://maven.apache.org/POM/4.0.0" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <!– The Basics –>
  <groupId>…</groupId>
  <artifactId>…</artifactId>
  <version>…</version>
  <packaging>…</packaging>
  <dependencies>…</dependencies>
  <parent>…</parent>
  <dependencyManagement>…</dependencyManagement>
  <modules>…</modules>
  <properties>…</properties>
  <!– Build Settings –>
  <build>…</build>
  <reporting>…</reporting>
  <!– More Project Information –>
  <name>…</name>
  <description>…</description>
  <url>…</url>
  <inceptionYear>…</inceptionYear>
  <licenses>…</licenses>
  <organization>…</organization>
  <developers>…</developers>
  <contributors>…</contributors>
  <!– Environment Settings –>
  <issueManagement>…</issueManagement>
  <ciManagement>…</ciManagement>
  <mailingLists>…</mailingLists>
  <scm>…</scm>
  <prerequisites>…</prerequisites>
  <repositories>…</repositories>
  <pluginRepositories>…</pluginRepositories>
  <distributionManagement>…</distributionManagement>
  <profiles>…</profiles>
</project>

1、头部信息配置

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

字段	说明
xmlns	命名空间，类似包名，因为xml的标签可自定义，需要命名空间来
xmlns:xsi	xml遵循的标签规范
xsi:schemaLocation	用来定义xmlschema的地址，也就是xml书写时需要遵循的语法

2、maven的基本信息

<project xmlns="http://maven.apache.org/POM/4.0.0" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.funtl</groupId>
    <artifactId>itoken-dependencies</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>
    <name>itoken dependencies</name>
    <url>www.funtl.com</url>
</project>

字段	说明
modelVersion	声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，这是为了当Maven引入了新的特性或者其他模型变更的时候，确保稳定性。
groupId	公司或者组织的唯一标志，并且配置时生成的路径也是由此生成，如com.winner.trade，maven会将该项目打成的jar包放本地路径：/com/winner/trade
artifactId	本项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的
version	本项目目前所处的版本号
packaging	打包类型，可取值：pom , jar , maven-plugin , ejb , war , ear , rar , par等等
name	项目的名称, Maven产生的文档用，可省略
url	项目主页的URL, Maven产生的文档用 ，可省略

其中groupId，artifactId，version，packaging这四项组成了项目的唯一坐标。一般情况下，前面三项就足矣。

3、POM之间的关系

主要用于POM文件的复用和依赖。

3.1、依赖关系：依赖关系列表

该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。
其实写代码比较简单，配置依赖也简单，但是java生态的混乱各种中间件版本的对应关系配置是如何的，是最糟糕的信息收集工作。
当初遇到过：
1、MQ和kafka对应关系问题，本地正常，beta正常，pro环境就不可用了，版本降低后可以。
2、S3依赖jar缺失，百度半天没解决，最后google才遇到有人提供过同样问题。

例如我要做文件上传功能，要配置那个依赖坐标哪
阿里central仓库
我们用这个链接去搜索即可：

    <dependencies>
        <dependency>
            <groupId>com.itxiaoer.commons</groupId>
            <artifactId>commons-upload</artifactId>
            <version>2.2.9</version>
        </dependency>
    </dependencies>

字段	说明
groupId	依赖项的组织名
artifactId	依赖项的子项目名
version	依赖项的版本
type	依赖类型一般省略，默认类型是jar，其他还有jar，war，ejb-client和test-jar
scope	依赖项的适用范围 ，包括compile，provided，runtime，test，system，exclusions
optional	可选依赖，如果你在项目B中把C依赖声明为可选，你就需要在依赖于B的项目（例如项目A）中显式的引用对C的依赖。
exclusions	排除项目中的依赖冲突时使用，不依赖该项目

scope 依赖项的适用范围

• compile，缺省值，适用于所有阶段，会随着项目一起发布。
• provided，类似compile，期望JDK、容器或使用者会提供这个依赖。如servlet.jar。
• runtime，只在运行时使用，如JDBC驱动，适用运行和测试阶段。
• test，只在测试时使用，用于编译和运行测试代码。不会随项目发布。
• system，类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。
• optional: 当项目自身被依赖时，标注依赖是否传递。用于连续依赖时使用
  我们知道，maven的依赖关系是有传递性的。如：A–>B，B–>C。但有时候，项目A可能不是必需依赖C，因此需要在项目A中排除对C的依赖。在maven的依赖管理中，有两种方式可以对依赖关系进行，分别是可选依赖（Optional Dependencies）以及依赖排除（Dependency Exclusions）。

可选依赖 Optional Dependencies

当一个项目A依赖另一个项目B时，项目A可能用到了项目B很少一部分功能，此时就可以在A中配置对B的可选依赖。举例来说，项目B类似hibernate，它支持对mysql、oracle等各种数据库的支持，但是在引用这个项目时，我们可能只用到其对mysql的支持，此时就可以在A项目中配置对项目B的可选依赖。
配置可选依赖的原因：

• 1、节约磁盘、内存等空间；
• 2、避免license许可问题；
• 3、避免类路径问题，等等。

  <dependencies>
    <dependency>
      <groupId>sample.ProjectB</groupId>
      <artifactId>Project-B</artifactId>
      <version>1.0</version>
      <scope>compile</scope>
      <optional>true</optional> <!-- value will be true or false only -->
    </dependency>
  </dependencies>

假设以上配置是项目A的配置，即：Project-A <-- Project-B。在编译项目A时，是可以正常通过的。

如果有一个新的项目C依赖A，即：Project-C <-- Project-A <-- Project-B。此时项目C就不会依赖项目B了。
如果项目C用到了涉及项目B的功能，那么就需要在pom.xml中重新配置对项目B的依赖。

依赖排除 Dependency Exclusions

• 第一种情况
  当一个项目A依赖项目B，而项目B同时依赖项目C，如果项目A中因为各种原因不想引用项目C，在配置项目B的依赖时，可以排除对C的依赖。

示例（假设配置的是A的pom.xml，依赖关系为：A<–B<–C）：

  <dependencies>
    <dependency>
      <groupId>sample.ProjectB</groupId>
      <artifactId>Project-B</artifactId>
      <version>1.0</version>
      <scope>compile</scope>
      <exclusions>
        <exclusion>
          <groupId>sample.ProjectC</groupId>
          <artifactId>Project-C</artifactId>
        </exclusion>
      </exclusions> 
    </dependency>
  </dependencies>

当然，对于多重依赖，配置也很简单，参考如下示例：

Project-A
-> Project-B
-> Project-D
-> Project-E <! – This dependency should be excluded -->
-> Project-F
-> Project C
A对于E相当于有多重依赖，我们在排除对E的依赖时，只需要在配置B的依赖中进行即可：

  <dependencies>
    <dependency>
      <groupId>sample.ProjectB</groupId>
      <artifactId>Project-B</artifactId>
      <version>1.0-SNAPSHOT</version>
      <exclusions>
        <exclusion>
          <groupId>sample.ProjectE</groupId>
          <artifactId>Project-E</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
  </dependencies>

• 第二种情况
  如果我们的项目有两个依赖项：A & B，而且A和B同时依赖了C，但不是同一个版本。那么我们怎么办呢？

1 添加检查插件

<reporting>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-project-info-reports-plugin</artifactId>
		</plugin>
	</plugins>
</reporting>

然后运行：mvn project-info-reports:dependencies，来查看依赖项报告。

2 去除依赖项

<dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>${struts.version}</version>
      <exclusions>
          <exclusion>
              <groupId>org.freemarker</groupId>
              <artifactId>freemarker</artifactId>
          </exclusion>
      </exclusions>
</dependency>

3.2、继承关系：继承其他pom.xml配置的机制

在我们已经聚合的项目中，有很多重复的配置，有相同的groupId和version，有相同的spring-core, spring-beans, spring-context和juit依赖，造成大量的浪费也会引发问题，所以如何使用继承机制来统一配置这些重复的信息，做到”一处声明，处处使用“呢？

思路：创建POM的父子结构，在父POM中声明一些配置供子POM继承

这种配置是项目经常用的，一个web工程往往包含api project，imp project 和webproject，当然更流行的是前后端分离，可能web是独立的vue工程了，不需要pom

父 pom.xml

<project>
  [...]
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.4</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  [...]
</project>

子 pom.xml

<parent>
  <groupId>com.devzuz.mvnbook.proficio</groupId>
  <artifactId>proficio</artifactId>
  <version>1.0-SNAPSHOT</version>
  <relativePath>../ParentProject/pom.xml</relativePath>   
</parent>

relativePath默认为…/pom.xml，如果路径不一样需要手动指定

3.3、聚合关系：用于将多个maven项目聚合为一个大的项目。

我们想要一次构建两个项目，而不是到两个模块的目录下分别执行mvn命令 – Maven的聚合就是为该需求服务的。

为了能够使用一条命令就能构建account-email和account-persist两个模块，需要创建一个额外的名为account-aggregator的模块，然后通过该模块构建整个项目的所有模块。

account-aggregator也有它自己的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>com.park.mvnDemo.account</groupId>
    <artifactId>account-aggregator</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>Account Aggregator</name>
    <modules>
        <module>account-email</module>
        <module>account-persist<module>
    </modules>
</project>

在上面的xml文件中，packaging的方式为pom。对于聚合模块来说， 其打包方式必须为pom，否则无法构建！

modules: 这里是实现聚合的最核心的配置，可以声明任意数量的module元素来实现元素的聚合；
其中，每个module的值为当前聚合POM的相对路径;
如：
当前的聚合POM位于D:\m2\code\account-aggregator
另有一个项目A位于D:\m2\code\account-aggregator\account-email
一个项目B位于D:\m2\code-aggregatoraccount\account-persist
与上面聚合pom内的的module值相对应。也可写成/account-email
为了方便用户构建项目，通常将聚合模块放在项目目录的最顶层，其他模块则作为聚合模块的子目录存在。
当然，你也可以手动指定路径

4、Maven的六类属性

4.1、maven内置属性

主要有两个常用内置属性

属性	说明
${basedir}	项目的根目录(包含pom.xml文件的目录)
${version}	项目版本

4.2、 POM属性

用户可以使用该属性引用POM文件中对应元素的值，常用的POM属性包括：

属性	说明
${project.build.sourceDirectory}	项目的主源码目录，默认为 src/main/java
${project.build.testSourceDirectory}	项目的测试源码目录，默认为 src/test/java
${project.build.directory}	项目构件输出目录，默认为 target/
${project.outputDirectory}	项目主代码编译输出目录，默认为 target/classes/
${project.testOutputDirectory}	项目测试代码编译输出目录，默认为 target/test-classes/
${project.groupId}	项目的 groupId
${project.artifactId}	项目的 artifactId
${project.version}	项目的 version，与${version}等价
${project.build.fianlName}	项目打包输出文件的名称，默认为"${project.artifactId} - ${project.version}"

4.3、 自定义属性

用户可以在POM的元素下自定义Maven属性

 <!--配置依赖版本-->
 <properties>
     <!-- Environment Settings -->
     <java.version>1.8</java.version>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

     <!-- Spring cloud Settings   -->
     <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
     <spring-boot-admin.version>2.0.1</spring-boot-admin.version>
     <zipkin.version>2.10.1</zipkin.version>
 </properties>

然后在pom文件中通过${zipkin.version}来使用他们

dependencies 和 dependencyManagement 标签
在通常情况下，由于我们的模块很多，我们需要一个itoken-denpendencies的项目来管理子项目的公共的依赖。

为了项目的正确运行，必须让所有的子项目使用依赖项的统一版本，必须确保应用的各个项目的依赖项和版本一致，才能保证测试的和发布的是相同的结果。

在我们项目顶层的POM文件中，我们会看到dependencyManagement元素。通过它元素来管理jar包的版本，让子项目中引用一个依赖而不用显示的列出版本号。

结合maven的自定义属性，我们来看看项目中的具体应用：

itoken-denpendencies 中的 pom.xml
在父项目中用dependencyManagement声明依赖的版本，需要

<dependencyManagement>
	<dependencies>
	    <!--spring cloud-->
	    <dependency>
	        <groupId>org.springframework.cloud</groupId>
	        <artifactId>spring-cloud-dependencies</artifactId>
	        <version>${spring-cloud.version}</version>
	        <type>pom</type>
	        <scope>import</scope>
	    </dependency>
	    <!--zipkin-->
	    <dependency>
	        <groupId>io.zipkin.java</groupId>
	        <artifactId>zipkin</artifactId>
	        <version>${zipkin.version}</version>
	    </dependency>
	<dependencies>
</dependencyManagement>            

itoken-zipkin 中的 pom.xml
在子项目中，Maven会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用在这个dependencyManagement元素中指定的版本号。

<dependencies>
    <!--spring cloud-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
    </dependency>
    <!--zipkin-->
    <dependency>
        <groupId>io.zipkin.java</groupId>
        <artifactId>zipkin</artifactId>
    </dependency>
    [...]
<dependencies>

需要注意的是：
dependencyManagement里只是声明依赖，并不实现引入。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom。

如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

4.4、Settings属性

用户使用${settings.}开头的属性可以引用 maven settings.xml 文件中XML元素的值

属性	说明
settings.localRepository	自定义本地库路径，默认在 ${user.home}/.m2中；
settings.interactiveMode	交互模式，Maven是否应该尝试与用户输入交互，默认是true，如果不是false。
settings.offline	是否每次编译都去查找远程中心库， 如果此构建系统应以离线模式运行，则为true，默认为false。由于网络设置或安全原因，此元素对于构建无法连接到远程存储库的服务器非常有用。
settings.pluginGroups	插件组，例如org.mortbay.jetty；

4.5、 Java系统属性

所有Java系统属性都可以使用Maven属性引用，用到的时候再补充

4.6、 环境变量属性

所有环境变量都可以使用以env.开头的Maven属性引用
${env.JAVA_HOME}表示JAVA_HOME环境变量的值;

5、构建设置

这个比较重要，尤其是正式工程，要打多环境的包，可能会用到不同的SDK，properties文件等。
例如：dev、sit、uat、beta、rnd、pro等等环境。
dev不需要密码验证，SIT,uat不要管控，生产研发需要搜SSO等校验。

  <!– "Project Build" contains more elements than just the BaseBuild set –>
  <build>…</build>
  <profiles>
    <profile>
      <!– "Profile Build" contains a subset of "Project Build"s elements –>
      <build>…</build>
    </profile>
  </profiles>

build中的主要标签：Resources和Plugins。

5.1、Resources：资源文件管理

用于引用或排除资源文件

<resources>
	<resource>
		<targetPath>META-INF/plexus</targetPath>
		<filtering>false</filtering>
		<directory>${basedir}/src/main/plexus</directory>
		<includes>
		  <include>configuration.xml</include>
		</includes>
		<excludes>
		  <exclude>**/*.properties</exclude>
		</excludes>
	</resource>
</resources>

属性	说明
targetPath	资源的打包路径，该路径相对target/classes目录
filtering	主要用来替换项目中的资源文件（* .xml、* . properties）当中的$ {…}属性值如$ {db.url} 如果filtering=true, resources目录中存在资源文件并且 配置了db.url=aaa的话，在项目编译的时候，就会自动的把pom文件中的${db.url}替换为aaa
directory	描述存放资源的目录，该路径相对POM路径
includes	包含的模式列表，例如**/*.xml
excludes	排除的模式列表，例如**/*.xml

5.2、Plugins：设置构建的插件

为什么我们需要插件？
1.需要某个特殊的 jar包，但是有不能直接通过maven依赖获取，或者说在其他环境的maven仓库内不存在，那么如何将我们所需要的jar包打入我们的生产jar包中。
2.某个jar包内部包含的文件是我们所需要的，或者是我们希望将它提取出来放入指定的位置 ，那么除了复制粘贴，如何通过maven插件实现呢。

plugins 和 pluginmanagement
maven 通过 plugins 和 pluginmanagement 来管理插件，类似 dependencies 和 dependencyment
但需要注意的是，plugins 和 pluginmanagement 隶属于 build 标签下，而不是最外层的 project

在父项目中声明插件和版本信息
同样pluginmanagement也不会直接引入插件

<pluginManagement>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>2.1</version>
            <configuration>
                <attach>true</attach>
            </configuration>
            <executions>
                <execution>
                    <phase>compile</phase>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</pluginManagement>

在子项目中引入插件
同样，子项目继承父项目的plugin设置，并可以自由定义

<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
    </plugin>
</plugins>

6、maven仓库配置

上面已经在setting中配置了仓库，这里综合整理下。

什么是Maven仓库?
Maven仓库就是放置所有JAR文件（WAR，ZIP，POM等等）的地方，所有Maven项目可以从同一个Maven仓库中获取自己所需要的依赖JAR，这节省了磁盘资源。此外，由于Maven仓库中所有的JAR都有其自己的坐标，该坐标告诉Maven它的组ID，构件ID，版本，打包方式等等，因此Maven项目可以方便的进行依赖版本管理。你也不在需要提交JAR文件到SCM仓库中，你可以建立一个组织层次的Maven仓库，供所有成员使用。
简言之，Maven仓库能帮助我们管理构件（主要是JAR）。

maven寻找仓库的顺序大致可以理解为：

• 1，在本地仓库中寻找，如果没有则进入下一步。
• 2，在全局应用的私服仓库中寻找，如果没有则进入下一步。
• 3，在项目自身的私服仓库中寻找，如果没有则进入下一步。
• 4，在中央仓库中寻找，如果没有则终止寻找。

补充：
1，如果在找寻的过程中，如果发现该仓库有镜像设置，则用镜像的地址代替。
2，如果仓库的id设置成“central”，则该配置会覆盖maven默认的中央仓库配置。

6.1、本地仓库

Maven缺省的本地仓库地址为 ${user.home}/.m2/repository 。也就是说，一个用户会对应的拥有一个本地仓库。 你也可以自定义本地仓库的位置，修改${user.home}/.m2/settings.xml ：

 <localRepository>D:\mavne\maven-repository</localRepository>

其实我们知道有这个软件默认路径就好了，我们一般使用安装目录下的settings.xml

还可以在运行时指定本地仓库位置：

mvn clean install -Dmaven.repo.local=/home/juven/myrepo/

6.2、中央仓库

3.xxx版本之后，在： maven安装目录下的：/lib/maven-model-builder-${version}.jar中
打开该文件，能找到超级POM：\org\apache\maven\model\pom-4.0.0.xml，它是所有Maven POM的父POM，所有Maven项目继承该配置，你可以在这个POM中发现如下配置：

  <repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

中央仓库的id为central，远程url地址为http://repo.maven.apache.org/maven2，它关闭了snapshot 快照版本构件下载的支持。

6.3、在POM中配置远程仓库

前面我们看到超级POM配置了ID为central的远程仓库，我们可以在POM中配置其它的远程仓库。这样做的原因有很多，比如你有一个局域网的远程仓库，使用该仓库能大大提高下载速度，继而提高构建速度，也有可能你依赖的一个jar在central中找不到，它只存在于某个特定的公共仓库，这样你也不得不添加那个远程仓库的配置。
这里我配置一个远程仓库指向中央仓库的中国镜像：

<project>
...
  <repositories>
    <repository>
      <id>maven-net-cn</id>
      <name>Maven China Mirror</name>
      <url>http://maven.net.cn/content/groups/public/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>
  <pluginRepositories>
    <pluginRepository>
      <id>maven-net-cn</id>
      <name>Maven China Mirror</name>
      <url>http://maven.net.cn/content/groups/public/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>    
    </pluginRepository>
  </pluginRepositories>
...
</project>

我们先看一下的配置，你可以在它下面添加多个 ，每个都有它唯一的ID，一个描述性的name，以及最重要的，远程仓库的url。
此外，

<releases><enabled>true</enabled></releases>   告诉Maven可以从这个仓库下载releases版本的构件

<snapshots><enabled>false</enabled></snapshots>告诉Maven不要从这个仓库下载snapshot版本的构件。

禁止从公共仓库下载snapshot构件是推荐的做法，因为这些构件不稳定，且不受你控制，你应该避免使用。当然，如果你想使用局域网内组织内部的仓库，你可以激活snapshot的支持。

回到首页☞