Maven 是一款基于 Java 平台的项目管理和整合工具，它将项目的开发和管理过程抽象成一个项目对象模型（POM）。开发人员只需要做一些简单的配置，Maven 就可以自动完成项目的编译、测试、打包、发布以及部署等工作。
Maven 是使用 Java 语言编写的，因此它和 Java 一样具有跨平台性，这意味着无论是在 Windows ，还是在 Linux 或者 Mac OS 上，都可以使用相同的命令进行操作。
Maven 使用标准的目录结构和默认构建生命周期，因此开发者几乎不用花费多少时间就能够自动完成项目的基础构建工作。
Apache Maven是一个（特别是Java编程）项目管理及自动构建工具，由Apache软件基金会所提供。基于项目对象模型（缩写：POM）概念，Maven利用一个中央信息片断能管理一个项目的构建、报告和文档等步骤。
它包含了一个项目对象模型 (Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。当你使用Maven的时候，你用一个明确定义的项目对象模型来描述你的项目，然后Maven可以应用横切的逻辑，这些逻辑来自一组共享的（或者自定义的）插件。
Maven 有一个生命周期，当你运行 mvn install 的时候被调用。这条命令告诉 Maven 执行一系列的有序的步骤，直到到达你指定的生命周期。遍历生命周期旅途中的一个影响就是，Maven 运行了许多默认的插件目标，这些目标完成了像编译和创建一个 JAR 文件这样的工作。
此外，Maven能够很方便的帮你管理项目报告，生成站点，管理JAR文件，等等。
Maven 官方网址：https://maven.apache.org/
Maven 依赖搜索：https://mvnrepository.com/
Maven下载地址：https://maven.apache.org/download.cgi
1 、下载Maven 安装包
2、点击Download ===》选择 apache-maven-3.8.6-bin.zip
下载地址：https://maven.apache.org/download.cgi
3、下载后解压产生此文件夹
4、文件夹如图所示
1、点击我的电脑->属性->高级系统设置->环境变量
2、新建：M2_HOME 内容： maven的bin目录（这里看大家安装的路径，不一定一样）
3、新建：MAVEN_HOME 内容：maven的目录
4、关键配置path环境，前面的不要动。加上 %MAVEN_HOME%\bin
5、输入命令行 cmd mvn -version
至此maven环境变量配置完成！
接下来，我们就按照标准目录创建一个 Maven工程 ，创建位置，你可以任意，但是我建议你创建在桌面上，因为我也是这样做的。
创建完标准结构以后，我们需要一些代码和配置，来帮助我们完成接下来的学习，在这里，你可以不理解这些代码和配置的含义。
这些代码和配置在这一章节不是重点，后边会讲，重点是标准结构长什么样子，这些代码和配置主要是为了学习接下来的 Maven命令。
找到 pom.xml 在里边写入以下配置：
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- groupId一般为公司或者组织域名的反写 -->
<groupId>com.caochenlei</groupId>
<!-- artifactId一般为当前项目或者模块的名称 -->
<artifactId>maven-demo</artifactId>
<!-- version代表当前项目或者模块的版本号 -->
<version>0.0.1-SNAPSHOT</version>
</project>
以上仅仅演示了一个标准的 maven 工程应该长什么样子，具体的配置等内容会在后边讲解。
POM 是 Maven 工程的基本工作单元，是一个 XML 文件，包含了项目的基本信息，用于描述项目如何构建，声明项目依赖等等。
执行任务或目标时，Maven 会在当前目录中查找 POM，读取 POM，获取所需的配置信息，然后执行目标。
POM 中可以指定以下配置等等：
所有 POM 文件一般都需要 project 根元素和三个必需字段：groupId，artifactId，version。
比如说，我们现在需要导入一个专门处理 JSON 字符串的依赖。
我们只需要知道，你所要导入的工具包的 groupId 、artifactId 、version 这三个标签的信息就可以了。
因为一个真正的项目中，依赖绝不止一个，所以在 pom.xml 就用了依赖的英文单词的复数形式来管理依赖信息，具体格式如下：
<project>
...
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.75</version>
</dependency>
...
...
可添加多个依赖
...
...
</dependencies>
...
</project>
为什么上边知道 groupId 、artifactId 、version 这三个信息 maven 就能自动管理这个依赖了，其实原理很简单。
如果你引入了依赖，maven 就会使用这个依赖的信息拼接字符串，到 maven 的中央仓库去寻找这个依赖，并把它下载下来。
默认下载是下载到了用户的根目录下，也就是 ~/.m2/repository 这个目录中，我们也称这个目录为本地仓库。
maven 中央仓库的地址是： https://repo.maven.apache.org/maven2/
maven 拼接字符串的格式：仓库地址/{groupId}/{artifactId}/{version}/{artifactId}-{version}.jar
注意：groupId 需要把所包含的所有点替换成斜杠
如果是导入上边的 fastjson ，那么这个依赖在 maven 中央仓库的地址也就是：
https://repo.maven.apache.org/maven2/com/alibaba/fastjson/1.2.75/fastjson-1.2.75.jar
这个地址是一个网络地址，你可以把它复制到浏览器地址栏中，然后回车访问一下，这个依赖就能下载下来了。
也有可能你并不能访问，因为 maven 的中央仓库是在外网，在国内访问会很慢，甚至打不开等情况。
为了解决这些不稳定的情况，国内很多知名的大公司，比如：
阿里，它们就自己创建了一个仓库，相当是把 maven
中央仓库里边所有的依赖全部拷到了他们自己的仓库中，并实时更新，同时，向国人也开放了这个仓库的地址，也就是 阿里的maven库 。
现在，maven 默认是从中央仓库去下载，我们想要改变它，就必须告诉他，说你不要去找中央仓库了，太慢了，你去阿里的 maven 库下载吧，既然要告诉他，我们就需要配置一下远程仓库地址。
找到解压后的 maven 目录，进入 conf 目录，找到 settings 文件，在里边找到 mirrors 节点，替换成以下信息：
例如我的是在： C:\DevTools\apache-maven-3.3.9\conf\settings.xml ，强烈建议使用 Notepad++ 编辑器打开，它会高亮文字。
<mirrors>
<mirror>
<id>alimaven</id>
<mirrorOf>central</mirrorOf>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
</mirror>
</mirrors>
同时，因为 maven 默认使用的 JDK 编译版本为 JDK1.5，显然也并不符合我们的要求。
我们需要重新指定版本，只需要找到 profiles 节点，替换成以下信息即可：
<profiles>
<profile>
<id>jdk1.8</id>
<activation>
<activeByDefault>true</activeByDefault>
<jdk>1.8</jdk>
</activation>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
</properties>
</profile>
</profiles>
好了，现在仓库地址也更改了，那当他下载 fastjson 依赖的时候，下载地址就应该是：
http://maven.aliyun.com/nexus/content/groups/public/com/alibaba/fastjson/1.2.75/fastjson-1.2.75.jar
为了验证，你也可以把这个地址粘贴到浏览器中，回车，看看它会不会下载。
在上边我们还提到了一个本地仓库，在本地仓库中，你要是想要找到这个依赖也是遵循 maven 的拼接字符串原则，那就成了以下：
C:/Users/CaoChenLei/.m2/repository/com/alibaba/fastjson/1.2.75/fastjson-1.2.75.jar
C:/Users/{自己的用户名}/.m2/repository/ 代表的就是本地仓库的地址。
当然，现在的你可找不到这个文件甚至目录，因为，在上边我们只是讲解了依赖是怎么下载的。
但是现在，我们并没有导入依赖，也没有对 maven 项目（‘maven-demo’）进行任何操作。
他可不知道，你有这么一个依赖需要下载。
到这里，简单梳理一下，本章节你学会了：
在 pom.xml 中添加以下标签
<project>
...
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.75</version>
</dependency>
...
</dependencies>
...
</project>
利用 groupId 、artifactId 、version 拼接字符串，然后访问下载
http://maven.aliyun.com/nexus/content/groups/public/com/alibaba/fastjson/1.2.75/fastjson-1.2.75.jar
中央仓库： maven 官方的、最大的依赖（第三方开源项目、工具、框架、插件等等）存放仓库，但是，国内用户访问速度慢
阿里仓库： 阿里仓库也称为远程仓库，它是中央仓库的一份实时拷贝，访问速度快，建议使用此仓库
本地仓库： maven 下载依赖后，用于存放依赖的地方，在项目的依赖管理中，首先去本地仓库中查找，本地仓库中有，则使用，没有，则下载，然后存放到本地仓库中，避免每一次都下载，浪费网络带宽
你怎么知道
groupId 、artifactId 、version这三个标签的信息？
我们给大家一个 Maven 依赖搜索网站：https://mvnrepository.com/
现在访问，好像需要验证码，挺烦人的，我们就以 fastjson 为例，为大家进行演示。
一个依赖是有自己的作用范围的，一般主要有以下几种情况：
如何设置一个依赖的作用范围，请参考：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.75</version>
<!-- 设置依赖范围，主要可取值：compile、test、provided，默认不配就是compile -->
<scope>compile</scope>
</dependency>
假设，现在有一个 Hello 项目，它导入了 spring-core 依赖，而开发 spring-core 需要依赖 commons-logging 依赖；
还存在另外一个项目 HelloFriend 他依赖了 Hello 项目，关系如图所示：
依赖的传递有什么好处？
可以传递的依赖不必在每个模块工程中都重复声明，在 “最下面” 的工程中依赖一次即可。
假设，现在 commons-logging 这个依赖包是有问题的包，我不想继续使用了，该如何排除呢？
我们这里有一份参考代码，请您参考：
在 HelloFriend 工程的 pom.xml 文件的 dependencies 标签内写入以下代码
<dependency>
<groupId>com.hello</groupId>
<artifactId>hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- 用来排除不想要的依赖包 -->
<exclusions>
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
依赖的原则：它是为了解决工程模块之间的 jar 包冲突的问题的，我们无法设置，maven 有默认的原则，我们需要了解。
由于非 compile 范围的依赖信息是不能在 “依赖链” 中传递的，所以有需要的工程只能单独配置。例如：
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
此时如果项目需要将各个模块的 junit 版本统一为 4.9，那么到各个工程中手动修改无疑是非常不可取的。
使用继承机制就可以将这样的依赖信息统一提取到父工程模块中进行统一管理。
创建父工程和创建一般的 Java 工程操作一致，唯一需要注意的是：打包方式处要设置为 pom。
而在子工程中只需要引入父工程的工程坐标就可以了。
<parent>
<!-- 父工程坐标 -->
<groupId>...</groupId>
<artifactId>Parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- 指定从当前子工程的pom.xml文件出发，查找父工程的pom.xml的路径 -->
<relativePath>../Parent/pom.xml</relativePath>
</parent>
此时如果子工程的 groupId 和 version 和父工程重复则可以删除。
将 Parent 项目中的 dependencies 标签，用 dependencyManagement 标签括起来。
<dependencyManagement>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>
在子项目中重新指定需要的依赖，删除范围和版本号。
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
</dependencies>
mvn clean
mvn compile
mvn test-compile
首先需要编译 Java工程：mvn compile
不存在参数的情况下运行：mvn exec:java -Dexec.mainClass="主程序入口类，不需要拓展名"
在存在参数的情况下运行：mvn exec:java -Dexec.mainClass="主程序入口类，不需要拓展名" -Dexec.args="arg0 arg1 arg2"
mvn test
正常打包：
mvn package
跳过测试：
mvn package -Dmaven.test.skip=true
正常安装：
mvn install
跳过测试：
mvn install -Dmaven.test.skip=true
正常部署：
mvn deploy
跳过测试：
mvn deploy -Dmaven.test.skip=true
mvn site
mvn -v
打印出已解决依赖的列表：
mvn dependency:resolve
打印出所有的依赖的列表：
mvn dependency:tree
创建 Maven 版本的 Java 项目：
#创建Maven版本的Java项目
mvn archetype:generate -DgroupId=packageName -DartifactId=appName -Dversion=1.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
#编译此项目
mvn compile
#执行此项目
mvn exec:java -Dexec.mainClass="packageName.App"
创建 Maven 版本的 JavaWeb 项目：
mvn archetype:generate -DgroupId=packageName -DartifactId=webappName -Dversion=1.0-SNAPSHOT -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
将项目转化为 Eclipse 项目 :
mvn eclipse:eclipse
将项目转化为 Idea 项目 :
mvn idea:idea
清除所有 Eclipse 的工程配置文件：
mvn eclipse:clean
清除所有 Idea 的工程配置文件：
mvn idea:clean
mvn tomcat:run
注意：以下是一个简略版的生命周期，足够我们学习了。
当执行 compile 的时候，会执行从左向右依次执行 compile
当执行 test 的时候，会执行从左向右依次执行 compile、test
当执行 package 的时候，会执行从左向右依次执行 compile、test、package
当执行 install 的时候，会执行从左向右依次执行 compile、test、package、install
当执行 deploy 的时候，会执行从左向右依次执行 compile、test、package、install、deploy
运行任何一个阶段的时候，它前面的所有阶段都会被运行，例如我们运行 mvn install 的时候，代码会被 编译，测试，打包。
这就是 Maven 为什么能够自动执行构建过程的各个环节的原因。
此外，Maven 的插件机制是完全依赖 Maven 的生命周期的，因此理解生命周期至关重要。
Maven 的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。
每个插件都能实现多个功能，每个功能就是一个插件目标。
Maven 的生命周期与插件目标相互绑定，以完成某个具体的构建任务。
例如：compile 就是插件 maven-compiler-plugin 的一个目标
Maven 有以下三个标准的生命周期：
每个生命周期中都包含着一系列的阶段。
这些阶段就相当于 Maven 提供的统一的接口，然后这些阶段的实现由 Maven 的插件来完成。
我们在输入 mvn 命令的时候 比如 mvn clean，clean 对应的就是 Clean 生命周期中的 clean 阶段。
但是 clean 的具体操作是由 maven-clean-plugin （内置了，不用我们手动添加）来实现的。
所以说 Maven 生命周期的每一个阶段的具体实现都是由 Maven 插件实现的。
Maven 实际上是一个依赖插件执行的框架，每个任务实际上是由插件完成。
Maven 插件通常被用来：
Maven 提供了下面两种类型的插件：
一定注意，maven 默认会采用自身所定义的插件来执行各个阶段，也就是说，即使你不配置这些插件，它也能够正常运行。
但是，你要是配置了某一阶段的一个插件，他就会采用你所配置的插件来进行运行。
除了一些不在生命周期内的插件，而我们需要使用，则需要单独配置，接下里就会告诉大家有哪些常见插件。
我们接下来主要讲解在工程 POM.XML 文件中如何配置一个插件？
找到 POM.XML 在根标签内添加以下代码，插件名和版本仅供参考，具体添加什么插件，取决于你。
<build>
<plugins>
<!-- 编译插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
...
...
</plugins>
</build>
maven-resources-plugin
插件描述：该插件处理项目的资源文件拷贝到输出目录，可以分别处理 main resources 和 test resources。
<build>
<plugins>
<!-- 依赖插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.1</version>
<configuration>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
除了使用 maven-resources-plugin 也可以使用以下配置来进行资源拷贝：
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
<include>**/*.conf</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
<include>**/*.conf</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
maven-compiler-plugin
插件描述：设置 maven 编译的 jdk 版本，maven3 默认用 jdk1.5，maven2 默认用 jdk1.3，除了配置maven安装目录/config/settings.xml文件，也可以使用 maven-compiler-plugin 进行指定
<build>
<plugins>
<!-- 依赖插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
maven-assembly-plugin
插件描述：该插件允许用户整合项目的输出，包括依赖、模块、网站文档和其他文档到一个单独的文件，即可用定制化打包。
四种预定义的描述器可用：bin, jar-with-dependencies, src, project。
<build>
<plugins>
<!-- 依赖插件 -->
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<mainClass>主程序类全路径</mainClass>
</manifest>
</archive>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
maven-source-plugin
插件描述：该插件处理打包项目的源代码。
<build>
<plugins>
<!-- 依赖插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<executions>
<execution>
<id>attach-sources</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
maven-dependency-plugin
插件描述：自动拷贝 jar 包到 target 目录
<build>
<plugins>
<!-- 依赖插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.6</version>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>compile</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<!-- ${project.build.directory}为Maven内置变量，缺省为target -->
<outputDirectory>${project.build.directory}/lib</outputDirectory>
<!-- 表示是否不包含间接依赖的包 -->
<excludeTransitive>false</excludeTransitive>
<!-- 表示复制的jar文件去掉版本信息 -->
<stripVersion>true</stripVersion>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>8.1.16.v20140903</version>
<!-- 插件配置选项，可选项 -->
<configuration>
<connectors>
<connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">
<port>8080</port>
</connector>
</connectors>
<scanIntervalSeconds>10</scanIntervalSeconds>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<!-- 插件配置选项，可选项 -->
<configuration>
<path>/</path>
<port>8080</port>
<uriEncoding>UTF-8</uriEncoding>
</configuration>
</plugin>
主要有两个常用内置属性：${basedir} 项目的根目录 (包含 pom.xml 文件的目录)，${version} 项目版本
#用户可以使用该属性引用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}
#获取环境变量属性，所有环境变量都可以使用以env.开头的Maven属性引用
${env.xxx}：获取系统环境变量；
#获取Settings属性，用户使用settings.开头的属性引用 settings.xml 文件中XML元素的值
${settings.xxx}：获取settings.xml中对应元素的值；
如何定义
<project>
...
<properties>
<变量名>变量值</变量名>
</properties>
...
</project>
如何引用
${变量名}
案例演示
<project>
...
<properties>
<junit.version>3.8.1</junit.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
...
</project>
eclipse version：Oxygen.3a Release (4.7.3a)，全新安装，无任何配置
java version：“1.8.0_261”
idea version：IntelliJ IDEA 2020.1.2，全新安装，无任何配置
java version：“1.8.0_261”
为什么要模块化开发？
一个工程往往会有很多代码文件，也会分为很多层，比如传统的 mvc：controller、service、dao 等等。
时间一场，随着项目开发的越来越大，这些文件和层次越来越多，放到一个工程中也越来越难管理。
而且，比如 dao 层，可能不止这一个项目用到了，其他项目也有可能用到，以前的所有代码放到一个工程中，你在抽取的时候会很麻烦。
现在经过模块化划分之后，各个层次结构之间可以相互依赖，大大提高了项目的开发进度。
在未来的微服务架构中，这一点也有很好的体现。
值得一提的是，模块与模块之间可以相互依赖，由父工程进行所有依赖版本的管理，减少了开发中很多不必要的工作。
模块化开发是在依赖继承的基础上进行的，所以你有必要去了解一下依赖继承。
父工程的 pom.xml：
子工程的 pom.xml：
父工程的 pom.xml：
子工程的 pom.xml：
Nexus3 是一个仓库管理器，它极大地简化了本地内部仓库的维护和外部仓库的访问。
平常我们在获取 maven 仓库资源的时候，都是从 maven 的官方（或者国内的镜像）获取，但是这都不是最好的方案，假如在同一个环境内，一个团队的多个开发人员同样的依赖都要从远程获取一遍，从网络方面来说，这是非常耗时的。这时候就需要在局域网内部署一个 Nexus3 用来管理 Maven（apt、yum、gradle、pypi、docker 等等）仓库。
有些公司都不提供外网给项目组人员，因此就不能使用 maven 访问远程的仓库地址，所以很有必要在局域网里找一台有外网权限的机器，搭建 Nexus3 私服，然后开发人员连到这台私服上，这样的话就可以通过这台搭建了 Nexus3 私服的电脑访问 maven 的远程仓库。
下载地址：https://www.sonatype.com/products/repository-oss-download
由于这个软件也是在外网，下载速度很慢，至少我是这样的。
首先先下载下来 Nexus，然后解压到一个没有空格，没有中文的目录中去，这里我解压到和 maven 同一级的目录中去了。
C:\DevTools\nexus-3.25.0-03-win64
首先进入 nexus-3.25.0-03 ，在进入 bin
运行命令： nexus.exe /run
然后他就会一直加载一直加载…
打开浏览器：访问http://localhost:8081/
点击登录就我会询问你账户密码，默认账户为 admin，密码就需要到 sonatype-work/nexus3 里寻找了，那一长串就是密码
Nexus 有 3 个类型的数据仓库，分别是 hosted，proxy，group。
hosted 宿主仓库：主要用于部署无法从公共仓库获取的构件以及自己或第三方的项目构件；
proxy 代理仓库：代理公共的远程仓库；
group 仓库组：Nexus 通过仓库组统一管理多个仓库，这样我们在项目中直接请求仓库组即可请求到仓库组管理的多个仓库。
Nexus 预定义了 2 个本地仓库，分别是 maven-releases, maven-snapshots。
手动上传本地 jar 包，这里以常用的ojdbc6-11.2.0.4.jar为例，当然你可以任选 jar 包上传。
这样一个 jar 包就上传成功了。
如果你的工程中，使用的 jar 包，在私服中没有，他就会自动连接远程仓库进行下载，这不是我们希望的结果，我们希望它去阿里 maven 库去下载，这样下载速度会更快。
阿里仓库地址：https://developer.aliyun.com/mvn/guide
老规矩，要配置 maven，就需要到 maven 安装目录中的 conf/settings.xml
上传需要的设置：
<servers>
<!-- 发布版 -->
<server>
<id>releases</id>
<username>admin</username>
<password>admin123</password>
</server>
<!-- 快照版 -->
<server>
<id>snapshots</id>
<username>admin</username>
<password>admin123</password>
</server>
</servers>
下载需要的设置
<mirrors>
<mirror>
<id>nexus</id>
<mirrorOf>*</mirrorOf>
<name>nexus maven</name>
<url>http://127.0.0.1:8081/repository/maven-public/</url>
</mirror>
</mirrors>
我们准备一个 maven 项目，在 pom.xml 中添加一段配置：
<distributionManagement>
<repository>
<id>releases</id>
<name>maven-releases</name>
<url>http://127.0.0.1:8081/repository/maven-releases/</url>
<uniqueVersion>true</uniqueVersion>
</repository>
<snapshotRepository>
<id>snapshots</id>
<name>maven-snapshots</name>
<url>http://127.0.0.1:8081/repository/maven-snapshots/</url>
<uniqueVersion>true</uniqueVersion>
</snapshotRepository>
</distributionManagement>
只要执行命令 mvn deploy即可。
这里配置了两个仓库，一个正式版、一个快照版，maven 是如何区分你要发布到哪一个仓库呢？
如果你的版本带着 releases，也就是 <version>0.0.1-releases</version>，就会发布到 maven-releases。
如果你的版本带着 snapshots，也就是 <version>0.0.1-snapshots</version>，就会发布到 maven-snapshots。
如果你想安装别人提供给你的 jar 包到私服，除了使用 nexus 提供的图形化界面方式上传，还可以使用命令行的方式进行上传。
我们以上传 ojdbc6-11.2.0.4.jar 到私服快照仓库为例演示。（以下命令是一行，为了方便阅读，我特意换了行，请注意）
mvn deploy:deploy-file
-DgroupId=com.oracle.database.jdbc
-DartifactId=ojdbc6
-Dversion=11.2.0.4
-Dpackaging=jar
-Dfile=C:\developlib\ojdbc6-11.2.0.4.jar
-Durl=http://localhost:8081/repository/maven-snapshots/
-DrepositoryId=snapshots
如果你想安装别人提供给你的 jar 包到本地仓库，可以参考以下命令：
我们以安装 ojdbc6-11.2.0.4.jar 到本地仓库为例演示。（以下命令是一行，为了方便阅读，我特意换了行，请注意）
mvn install:install-file
-DgroupId=com.oracle.database.jdbc
-DartifactId=ojdbc6
-Dversion=11.2.0.4
-Dpackaging=jar
-Dfile=C:\developlib\ojdbc6-11.2.0.4.jar