maven概述

Maven翻译为“专家“， ”内行”的意思，是著名Apache公司下基于Java开发的开源项目。

Maven项目对象模型（POM）是一个项目管理工具软件，可以通过简短的中央信息描述来管理项目的搭建，报告和文档等步骤，类似于前段的package.json

Maven是一个项目管理的工具，可以对项目进行构建、依赖的管理。

maven下载安装及配置 

下载地址：下载压缩包即可

http://maven.apache.org/download.cgi

安装:解压到自己想要安装的目录之下

配置：环境变量的配置，

• 系统变量中加入MAVEN_HOME 指向maven安装根目录即可
• 在path中加入%MAVEN_HOME\bin

检测安装：win+r 输入cmd 输入mvn -v 成功打印出版本号，证明安装成功

配置阿里云镜像源和本地仓库

打开conf/settings.xml文件

配置阿里云镜像源

<mirror>
		 <id>nexus-aliyun</id>
		 <mirrorOf>*</mirrorOf>
		 <name>Nexus aliyun</name>
		 <url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

配置本地仓库

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

maven配置文件

maven配置文件的加载优先级

1. 用户目录下 .m2/settings.xml
2. maven安装目录conf/settings.xml (里面有很多推荐配置)

当前项目用编译工具打开，默认优先级的话会指向系统c盘配置，而不会指向我们自己写的配置文件中

建议做法：配置好conf/settings.xml之后，直接复制到用户目录下.m2/下一份setting.xml

 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
 
  <localRepository>/path/to/local/repo</localRepository>
  

  <pluginGroups>
    <pluginGroup>com.your.plugins</pluginGroup>
  </pluginGroups>

 
  <servers>
    <server>
      <id>xxx</id>
      <username>xxx</username>
      <password>xxx</password>
    </server>
  </servers>
 
  <mirrors>
	<mirror>
      <id>alimaven</id>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>central</mirrorOf>        
    </mirror> 
  </mirrors>

    
  <profiles>
    <profile>
      <id>jdk-1.4</id>

      <activation>
        <jdk>1.4</jdk>
      </activation>

      <repositories>
        <repository>
          <id>jdk14</id>
          <name>Repository for JDK 1.4 builds</name>
          <url>http://www.myhost.com/maven/jdk14</url>
          <layout>default</layout>
          <snapshotPolicy>always</snapshotPolicy>
        </repository>
      </repositories>
    </profile>
  </profiles>

  <activeProfiles>
    <activeProfile>alwaysActiveProfile</activeProfile>
    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
  </activeProfiles>
  
</settings>

localRepository
定义repository下载的目录

pluginGroups
用于注册自定义插件

servers
配置私服的用户名和密码

mirrors
配置下载maven jar包的镜像

profiles
用于切换开发、测试、部署的环境

mvn -p dev 启用dev环境

依赖管理

pom.xml是我们maven项目中引入依赖及管理依赖的配置文件，类似前端package.json文件的作用

<?xml version="1.0" encoding="UTF-8"?>
<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>

<dependency>
    <groupId>net.lazyegg.maven</groupId>
    <artifactId>Hello</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <scope>compile</scope>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            </exclusion>
    </exclusions>
</dependency>

</project>

modelVersion
指定了当前Maven模型的版本号，对于Maven2和Maven3来说，它只能是4.0.0

groupId
类似package，公司名倒过来

artifactId
groupId下一个功能的命名，或者说是项目名

version
版本号，SNAPSHOT意为快照，说明该项目还在开发中，是不稳定的版本。

结构为:
主版本号.次版本号.增量版本号-<里程碑版本>

groupId、artifactId、version三个元素生成了一个Maven项目的坐标

 依赖范围scope

• compile：默认范围，编译测试运行都有效
• provided：在编译和测试时有效
• runtime：在测试和运行时有效
• test：只在测试时有效
• system：在编译和测试时有效，与本机系统关联，可移植性差

常用的依赖范围：

compile	test	providedprovided
主程序	√	×	√
测试程序	√	√	√
参与部署	√	×	×

依赖的传递性 

如果A->B->C,A是否能够使用C，要看B依赖C的范围是否是compile，如果是则可以使用，不是则不可以使用

依赖的原则

• 路径最短者优先
• 路径相同时先声明者优先

依赖的排除

如果当前工程依赖A，引入依赖A的同时，A依赖B，B也会被引入进来，如果B是不稳定版本，或者B是多余的，我们用不到，可以排除依赖

<dependency>
    <groupId>net.lazyegg.maven</groupId>
    <artifactId>Hello</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <scope>compile</scope>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            </exclusion>
    </exclusions>
</dependency>

统一版本号 

对同一个框架的一组 jar 包最好使用相同的版本。为了方便升级框架，可以将 jar 包的版本信息统一提取出来

<properties>
    <starfish.spring.version>4.1.1.RELEASE</starfish.spring.version>
</properties>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${starfish.spring.version}</version>
</dependency>

 管理继承

• 创建父工程 创建父工程和创建一般的 Java 工程操作一致，唯一需要注意的是：打包方式处要设置为 pom
• 在子工程中引用父工程 ，从当前目录到父项目的 pom.xml 文件的相对路径

 <parent>
     <groupId>com.starfish.maven</groupId>
    <artifactId>Parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- 以当前文件为基准的父工程pom.xml文件的相对路径 -->
    <relativePath>../Parent/pom.xml</relativePath>
</parent>

在父工程中管理依赖 将 Parent 项目中的 dependencies ，用 dependencyManagement 标签括起来

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</dependencyManagement> 


子项目中使用不需要指定版本号和依赖范围
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
</dependency>

聚合 

将多个工程拆分为模块后，需要手动逐个安装到仓库后依赖才能够生效。修改源码后也需要逐个手动进 行 clean 操作。而使用了聚合之后就可以批量进行 Maven 工程的安装、清理工作。一般父项目就是一个聚合项目

<!-- 配置聚合 -->
<modules>
    <!-- 指定各个子工程的相对路径 -->
    <module>test-1</module>
    <module>test-2</module>
    <module>test-3</module>
</modules>

打包方式 

• jar：默认的打包方式，打包成jar用作jar包使用。打包成jar用作jar包使用。
• war：将会打包成war，发布在服务器上，如网站或服务。一般是java web项目打包。
• pom：用在父级工程或聚合工程中，用来做jar包的版本控制，必须指明这个聚合工程的打包方式为pom

maven仓库

分类

本地仓库：为当前本机电脑上的所有 Maven 工程服务
远程仓库：

        私服：架设在当前局域网环境下，为当前局域网范围内的所有 Maven 工程服务

        中央仓库：架设在 Internet 上，为全世界所有 Maven 工程服务

        中央仓库的镜像：架设在各个大洲，为中央仓库分担流量。减轻中央仓库的压力，同时更快的响应用户请求，比如阿里的镜像

加载顺序

本地仓库 > 私服 ->中央仓库 | 中央仓库

maven会默认去本地仓库中找所需的依赖，本地中没有找到，如果配置了私服，会去私服中找，在私服中没找到，私服会再从远程中央仓库中寻找jar

当然没有配置私服的话 会直接去中央服务器下载

仓库的文件

• Maven 的插件
• 我们自己开发的项目的模块
• 第三方框架或工具的 jar 包

查询依赖

不管是什么样的 jar 包，在仓库中都是按照坐标生成目录结构，所以可以通过统一的方式查询或依赖，查询地址：

http://mvnrepository.com/

maven常用命令

构建项目的主要环节

清理（clean）：删除以前的编译结果，为重新编译做好准备
编译（compile）：将Java 源程序编译为字节码文件
测试（test）：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性
报告（）：在每一次测试后以标准的格式记录和展示测试结果
打包（package）：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java 工程对应 jar 包，Web工程对应 war 包。
安装（install）：在 Maven 环境下特指将打包的结果——jar 包或 war 包安装到本地仓库中。
部署（deploy）：将打包的结果部署到远程仓库或将 war 包部署到服务器上运行一般都是deploy到私服中

 常用命令

常用命令对应上述构建项目的主要环节具体如下：

mvn -version/-v 显示版本信息

mvn clean 清空之前的编译结果

mvn compile 编译

mvn test 编译并测试

mvn package 生成target目录，编译、测试代码，生成测试报告，生成jar/war文件

mvn site 生成项目相关信息的网站

组合命令

mvn clean compile 表示先运行清理之后运行编译，会将代码编译到target文件夹中

mvn clean package 运行清理和打包

mvn clean install 运行清理和安装，会将打好的包安装到本地仓库中，以便其他的项目可以调用

mvn clean deploy 运行清理和发布

maven生命周期

Maven 生命周期定义了各个构建环节的执行顺序，有了这个清单，Maven 就可以自动化的执行构建命令了

Maven 有三套相互独立的生命周期，分别是：

• Clean Lifecycle 在进行真正的构建之前进行一些清理工作
• Default Lifecycle 构建的核心部分，编译，测试，打包，安装，部署等等
• Site Lifecycle 生成项目报告，站点，发布站点

它们是相互独立的，你可以仅仅调用 clean 来清理工作目录，仅仅调用 site 来生成站点。当然你也可以直接运行 mvn clean install site 运行所有这三套生命周期。 每套生命周期都由一组阶段(Phase)组成，下面将具体介绍

 Clean 生命周期

Clean 生命周期一共包含了三个阶段：

• pre-clean 执行一些需要在 clean 之前完成的工作
• clean 移除所有上一次构建生成的文件
• post-clean 执行一些需要在 clean 之后立刻完成的工作

Default 生命周期

Default 生命周期是 Maven 生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中（列出一些重要阶段） 

• validate：验证工程是否正确，所有需要的资源是否可用。
• compile：编译项目的源代码。
• test：使用合适的单元测试框架来测试已编译的源代码。这些测试不需要已打包和布署。
• package：把已编译的代码打包成可发布的格式，比如 jar、war 等。
• integration-test：如有需要，将包处理和发布到一个能够进行集成测试的环境。
• verify：运行所有检查，验证包是否有效且达到质量标准。
• install：把包安装到maven本地仓库，可以被其他工程作为依赖来使用。
• deploy：在集成或者发布环境下执行，将最终版本的包拷贝到远程的repository，使得其他的开发者或者工程可以共享

Site 生命周期 

• pre-site 执行一些需要在生成站点文档之前完成的工作
• site 生成项目的站点文档
• post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
• site-deploy 将生成的站点文档部署到特定的服务器上 这里经常用到的是 site 阶段和 site-deploy 阶段，用以生成和发布 Maven 站点，这可是 Maven 相当强大 的功能，Manager 比较喜欢，文档及统计数据自动生成，很好看。

运行规则

运行任何一个阶段的时候，它前面的所有阶段都会被运行，例如我们运行 mvn install 的时候，代码会被编译，测试，打包。这就是 Maven 为什么能够自动执行构建过程的各个环节的原因。此外，Maven 的插件机制是完全依赖 Maven 的生命周期的

maven插件 

maven中的所有生命周期都是抽象的定义，具体完成任务的就是maven插件，插件和生命周期绑定，并完成功能，这里的功能就是目标

• Maven 的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的
• 每个插件都能实现多个功能，每个功能就是一个插件目标
• Maven 的生命周期与插件目标相互绑定，以完成某个具体的构建任务

 这里着重介绍一下打包插件，其他不再赘述

 打包插件

• 使用maven-jar-plugin和maven-dependency-plugin插件打包，生成jar包和依赖分离复制，这样jar包小，效率高
• 使用maven-assembly-plugin插件打包 只生成一个jar文件，包含项目本身的代码、资源以及所有的依赖包
• 使用maven-shade-plugin插件打包 ，只生成一个jar文件，包含项目本身的代码、资源以及所有的依赖包

maven-jar-plugin和maven-dependency-plugin插件打包

 Maven可以使用mvn package指令对项目进行打包，如果使用java -jar xxx.jar执行运行jar文件，会出现"no main manifest attribute, in xxx.jar"（没有设置Main-Class）、ClassNotFoundException等问题

要想jar包能直接通过java -jar xxx.jar运行，需要满足：

1、在jar包中的META-INF/MANIFEST.MF中指定Main-Class，这样才能确定程序的入口在哪里

2、要能加载到依赖包

<build>
    <plugins>
 
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                        <mainClass>com.xxg.Main</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>2.10</version>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
 
    </plugins>
</build>

maven-jar-plugin用于生成META-INF/MANIFEST.MF文件的部分内容

指定MANIFEST.MF中的Main-Class
<mainClass>com.xxg.Main</mainClass>
会在MANIFEST.MF加入ClassPath项并配置依赖包
<addClasspath>true</addClasspath>
指定依赖包所在目录
<classpathPrefix>lib/</classpathPrefix>

maven-dependency-plugin

只是生成MANIFEST.MF文件还不够，还需要maven-dependency-plugin插件用于将依赖包拷贝到指定位置：<outputDirectory>${project.build.directory}/lib</outputDirectory>指定的位置，即lib目录下

maven-dependency-plugin插件用于将依赖包拷贝到指定位置，由于我们加入了classpath，所以能够访问到依赖包

这也是项目中的普遍做法，jar包和依赖分离，瘦身jar包，效率比较高，否则jar包比较大，上传等耗时巨大

配置完成后，通过mvn package指令打包，会在target目录下生成jar包，并将依赖包拷贝到target/lib目录下

maven-assembly-plugin打包

pom配置

build>
    <plugins>
 
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.5.5</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.xxg.Main</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </plugin>
 
    </plugins>
</build>

 打包命令：mvn package assembly:single

打包后会在target目录下生成一个xxx-jar-with-dependencies.jar文件，这个文件不但包含了自己项目中的代码和资源，还包含了所有依赖包的内容。所以可以直接通过java -jar来运行

此外还可以直接通过mvn package来打包，无需assembly:single

<build>
    <plugins>
 
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.5.5</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.xxg.Main</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
 
    </plugins>
</build>

其中<phase>package</phase>、<goal>single</goal>即表示在执行package打包时，执行assembly:single，所以可以直接使用mvn package打包

不过，如果项目中用到spring Framework，用这种方式打出来的包运行时会出错，可以用maven-shade-plugin打包插件来处理

maven-shade-plugin打包

<build>  
    <plugins>  
  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-shade-plugin</artifactId>  
            <version>2.4.1</version>  
            <executions>  
                <execution>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>shade</goal>  
                    </goals>  
                    <configuration>  
                        <transformers>  
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
                                <mainClass>com.xxg.Main</mainClass>  
                            </transformer>  
                        </transformers>  
                    </configuration>  
                </execution>  
            </executions>  
        </plugin>  
  
    </plugins>  
</build>  

如果项目中用到了Spring Framework，将依赖打到一个jar包中，运行时会出现读取XML schema文件出错。

原因是Spring Framework的多个jar包中包含相同的文件spring.handlers和spring.schemas，如果生成一个jar包会互相覆盖。为了避免互相影响，

可以使用AppendingTransformer来对文件内容追加合并：

<build>  
    <plugins>  
  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-shade-plugin</artifactId>  
            <version>2.4.1</version>  
            <executions>  
                <execution>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>shade</goal>  
                    </goals>  
                    <configuration>  
                        <transformers>  
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
                                <mainClass>com.xxg.Main</mainClass>  
                            </transformer>  
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
                                <resource>META-INF/spring.handlers</resource>  
                            </transformer>  
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
                                <resource>META-INF/spring.schemas</resource>  
                            </transformer>  
                        </transformers>  
                    </configuration>  
                </execution>  
            </executions>  
        </plugin>  
  
    </plugins>  
</build> 

springBoot项目打包

插件包：

<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

默认goal：

repackage：这个是默认 goal，在 mvn package 执行之后，这个命令再次打包生成可执行的 jar，同时将 mvn package 生成的 jar 重命名为 *.origin

 springboot项目依赖包分离配置

1、配置ClassPath

 配置maven-jar-plugin加入classpath路径

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <classpathPrefix>lib/</classpathPrefix>
            </manifest>
            <manifestEntries>
                <Class-Path>./</Class-Path>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>

 2、配置依赖拷贝

 配置maven-dependency-plugin依赖拷贝

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>prepare-package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

 3、配置jar包构建信息

 配置spring-boot-maven-plugin打包

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <fork>true</fork>
        <addResources>true</addResources>
        <!--手动设置构建需要加入的依赖，只有配置的依赖才会加入。-->
        <includes>
            <!--配置一个不存在的groupId，这样就不会引入任何依赖，jar包就只包含代码文件-->
            <include>
                <groupId>not-exists</groupId>
            </include>
            <!--如果是多模块项目，其他模块需要手动添加下面-->
        </includes>
    </configuration>
</plugin>

完整配置

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
    <plugins>
        <!-- 自定义ClassPath路径 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <!-- 把构建根目录的lib文件夹配置成ClassPath路径 -->
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                    </manifest>
                    <manifestEntries>
                        <Class-Path>./</Class-Path>
                    </manifestEntries>
                </archive>
            </configuration>
        </plugin>
        <!--配置Jar包构建信息-->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork>
                <addResources>true</addResources>
                <!--手动设置构建需要加入的依赖，只有配置的依赖才会加入。-->
                <includes>
                    <!--配置一个不存在的groupId，这样就不会引入任何依赖，jar包就只包含代码文件-->
                    <include>
                        <groupId>not-exists</groupId>
                    </include>
                    <!--如果是多模块项目，其他模块需要手动添加下面-->
                </includes>
            </configuration>
        </plugin>
        <!--把依赖拷贝到Lib路径-->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>prepare-package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Nexus私服搭建

目的

 如果在公司中多个项目模块中的的公共类用的都是一样的，那么不可能将这些一样的代码写两遍。所以将其中一个项目中的代码打包成私服，然后在另外一个模块中去进行引用。

除此之外，如果大公司中开发人员较多，大家同时去远程仓库将依赖下载到本地，那么对公司的带宽会造成很大的压力。很有可能会造成其他的问题

优点：

      1、  加速下载速度

      2 、 加速带宽，加速项目构建速度

      3、   方便公共使用

      4、   提高maven稳定性，中央仓库需要连外网才能访问，私服只需要连内网就可以访问。

私服的管理网站

Apache基金会的archiva：Archiva 

http://archiva.apache.org/

JFrog的Artifactory：Artifactory 

https://jfrog.com/artifactory/

Sonatype的Nexus：My Sonatype 

https://my.sonatype.com/

Nexus下载及登录

下载地址：https://help.sonatype.com/repomanager3/product-information/download
进入bin目录运行

D:\App\nexus-3.55.0-01-win64\nexus-3.55.0-01\bin>nexus.exe /run

访问8081：http://localhost:8081/

用户名：admin（默认）

密码：第一次启动时生成，(在/sonatype-work/nexus3/admin.password 文件中)  

记得修改密码

设置仓库

设置代理仓库

代理仓库主要是让用户通过代理仓库访问外部第三方仓库，如maven中央仓库、阿里的maven仓库。代理仓库会从被代理的仓库（maven中央仓库、阿里的maven仓库）中下载依赖，缓存在代理仓库中以便让maven用户使用

选择 Create repository 

  选择maven2（proxy）

输入远程仓库信息

 创建完成

 设置宿主仓库和仓库组

宿主仓库主要是供给自己使用：

        1、将私有的一些构建通过网页的方式上传到宿主仓库中供大家使用。

        2、将自己开发好的一些构建发布到nexus的宿主仓库中供大家使用

仓库组的概念

仓库组既然是“组”的概念，说明它里面可以包含多个仓库。

因为maven用户可以从代理仓库和宿主仓库中下载构建至本地仓库，为了方便从代理仓库和宿主仓库下载构建，maven提供了仓库组。

maven用户访问一个仓库组就可以访问该仓库下的所有仓库

仓库组中的多个仓库是有顺序的，当maven用户从仓库组中下载构建时，会按顺序在仓库组中查找组件，查到了就返回给本地仓库，所以一般将速度快的放前面

仓库组内部实际是没有内容的，只是起到一个请求转发的作用，将maven用户的下载请求转发给其它仓库处理，nexus默认有仓库组maven-public

 打开如下：

  仓库组对外url：本地maven可以通过这个url从仓库组中下载构件至本地仓库

仓库组中成员：maven-releases（宿主的releases仓库版本）maven-snapshots（宿主快照版本的仓库）maven-central（maven社区的中央仓库的代理）

刚刚新增的maven-aliyun放在第三个位置，因为上述说过仓库组的查找是有顺序的，需要将速度快的放在前面，这个新增的仓库速度比maven-central速度要快

maven配置使用

项目pom配置私服仓库

  <repositories>
    <repository>
      <id>maven-nexus</id>
      <url>http://localhost:8081/repository/maven-public/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>
 
  <!--该配置是为了防止pom中的jar包从私服下载之后，但是执行mvn中从插件还是从中央仓库中下载-->
  <pluginRepositories>
    <pluginRepository>
      <id>maven-nexus</id>
      <url>http://localhost:8081/repository/maven-public/</url>
    </pluginRepository>
  </pluginRepositories>

setting.xml配置

	<server>
	  <id>maven-nexus</id>
	  <username>admin</username>
	  <password>1e1e7335-e723-441b-9876-a986b53e4130</password>
	</server>

注意事项

 1、 自己在pom文件中配置了私服并且也在idea的maven中配置了settings.xml文件，但是jar包还是从阿里云下载。

原因：自己电脑上有好几个setting.xml文件，默认会找到settings.xml文件，自己当初指定的的xml文件名称并不是settings.xml文件名，

 2、jar包从私服下载之后，但是执行mvn中从插件还是从中央仓库中下载

原因：所有的pom文件都继承了super pom

本地依赖发布到私服

而nexus私服中存储用户的构建用的是宿主仓库，之前说过nexus私服提供了2个默认的宿主仓库分别用来存放SNAPSHOT版本和release版本。如下：

快照版本配置 

pom配置

  <distributionManagement>
    <repository>
      <id>release-nexus</id>
      <url>http://localhost:8081/repository/maven-releases//</url>
      <name>nexus私服中宿主仓库->存放/下载稳定版本的构件</name>
    </repository>
    <snapshotRepository>
      <id>snapshot-nexus</id>
      <url>http://localhost:8081/repository/maven-snapshots/</url>
      <name>nexus私服中宿主仓库->存放/下载快照版本的构件</name>
    </snapshotRepository>
  </distributionManagement>

setting.xml配置 

	<server>
	  <id>release-nexus</id>
	  <username>admin</username>
	  <password>1e1e7335-e723-441b-9876-a986b53e4130</password>
	</server>
 
	<server>
	  <id>snapshot-nexus</id>
	  <username>admin</username>
	  <password>1e1e7335-e723-441b-9876-a986b53e4130</password>
	</server>

 发布到仓库

执行 mvn deploy

修改version为release或者删除掉SNAPSHOT，在次deploy，会提交到私服的release仓库，这里不做演示

手动提交依赖

 注意事项：手动部署只支持release版本