maven学习手册

1.maven简介
- 1.1 传统项目的弊端
- 1.2 Maven是什么
2.maven的安装和配置
- 2.1 maven的安装
- 2.2 为阿里云设置代理仓库
- 2.3 maven常用命令简单说明
3.maven实战
- 3.1 一个简单的maven项目
- 3.2 maven常用命令简单说明
- 3.3 为这个简单的maven项目安装依赖
- 3.4 maven常见标签说明
4.依赖管理
- 4.1 依赖配置
- 4.2 依赖范围
- 4.3 依赖传递
- 4.4 依赖传递的冲突问题
- 4.5 可选依赖
- 4.6 排除依赖
5.生命周期与插件
- 5.1 生命周期
- 5.2 插件
6.maven工程的聚合和继承
- 6.1 maven工程聚合描述
- 6.2 ssm项目聚合maven工程示例
- 6.3 maven过程的继承
- 6.5 maven属性使用
7.maven版本号管理
8.多环境开发配置
9.跳过测试
10.私服
- 1. linux安装nexus
- 2.手动上传jar包
- 3.访问私服配置
- 4.自动上传配置
11.maven插件实战
- 1.springboot 依赖和配置分离

1.maven简介

1.1 传统项目的弊端

jar包不统一，jar包不兼容导致项目问题
工程升级维护过程操作繁琐

1.2 Maven是什么

maven作为一个构建工具，不仅能帮我们自动化构建，还能够抽象构建过程，提供构建任务实现;它跨平台，对外提供了一致的操作接口，这一切足以使它成为优秀的、流行的构建工具。

Maven不仅是构建工具，还是一个依赖管理工具和项目管理工具，它提供了中央仓库，能帮我自动下载构件。

Maven的本质是一个项目管理工具，将项目开发和管理过程抽象成一个项目对象模型POM(Project Object Model：项目对象模型）
Maven是由java语言开发，它管理的东西以面向对象的形式设计，将一个项目看成一个对象，这个对象就叫做POM.

2.maven的安装和配置

2.1 maven的安装

首先需要确认的是你已经成功安装JDK，接着去maven官网下载安装包即可。下载地址：https://maven.apache.org/download.cgi

然后选择自己想要的版本即可。下载完毕后解压到你想要解压的目录即可。

配置环境变量 MAVEN_HOME和path即可

输入mvn-v 如显示如下信息即可安装配置成功

maven目录结构

bin目录：该目录包含了mvn运行的脚本，这些脚本用来配置java命令，准备好classpath和相关的Java系统属性，然后执行Java命令。

boot目录: 该目录只包含一个文件，该文件为plexus-classworlds-2.5.2.jar。plexus-classworlds是一个类加载器框架，相对于默认的java类加载器，它提供了更加丰富的语法以方便配置，Maven使用该框架加载自己的类库。

conf目录: 该目录包含了一个非常重要的文件settings.xml。直接修改该文件，就能在机器上全局地定制Maven的行为，一般情况下，我们更偏向于复制该文件至_{/.m2/目录下（}表示用户目录），然后修改该文件，在用户范围定制Maven的行为。

lib目录: 该目录包含了所有Maven运行时需要的Java类库，Maven本身是分模块开发的，因此用户能看到诸如maven-core-3.0.jar、maven-model-3.0.jar之类的文件，此外这里还包含一些Maven用到的第三方依赖如commons-cli-1.2.jar、commons-lang-2.6.jar等等。

2.2 为阿里云设置代理仓库

为maven设置阿里云代理仓库

因为Maven的镜像默认是国外的网站，我们下载jar包时就会非常慢，所以我们配置一个国内的阿里云镜像。
打开解压Maven的conf目录下的settings.xml文件，在<mirrors></mirrors>中添加如下mirror：

<mirror>
	  <id>aliMaven</id>
	  <name>aliyun maven</name>	  	  
	  <url>https://maven.aliyun.com/nexus/content/groups/public/</url>
	  <mirrorOf>central</mirrorOf>
</mirror>

配置JDK编译版本，防止在编辑器中运行时出现Java版本编译警告：

<profile>
    <id>jdk-1.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>

配置本地仓库目录

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

2.3 maven常用命令简单说明

mvn clean：表示运行清理操作（会默认把target文件夹中的数据清理）。
mvn clean compile：表示先运行清理之后运行编译，会将代码编译到target文件夹中。
mvn clean test：运行清理和测试。
mvn clean package：运行清理和打包。
mvn clean install：运行清理和安装，会将打好的包安装到本地仓库中，以便其他的项目可以调用。
mvn clean deploy：运行清理和发布（发布到私服上面）。

3.maven实战

3.1 一个简单的maven项目

开始一个新的Maven项目，在命令行使用Maven Archetype插件。

mvn -B archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app 
-DartifactId:项目名称
-DgroupId:公司组织名

命令执行成功就会得到这样一个简单的maven项目，使用idea打开查看项目目录结构

3.2 maven常用命令简单说明

mvn clean：表示运行清理操作（会默认把target文件夹中的数据清理）。
mvn clean compile：表示先运行清理之后运行编译，会将代码编译到target文件夹中。
mvn clean test：运行清理和测试。
mvn clean package：运行清理和打包。
mvn clean install：运行清理和安装，会将打好的包安装到本地仓库中，以便其他的项目可以调用。
mvn clean deploy：运行清理和发布（发布到私服上面）。

3.3 为这个简单的maven项目安装依赖

你会希望构建并打包这个应用。想要构建打包这个应用，在包含pom.xml的目录下运行 mvn install

这个pom.xml文件是你将会面对的Maven项目中最基础的POM，一般来说一个 POM文件会复杂得多：定义多个依赖，自定义插件行为。最开始的几个元素 ——groupId，artifactId, packaging, version——是Maven的坐标(coordinates)，它们唯一标识了一个项目。name和url是POM提供的描述性元素，它们给人提供了可阅读的名字，将一个项目关联到了项目web站点。最后，dependencies元素定义了一个单独的，测试范围(test-scoped)依赖，依赖于称为JUnit的单元测试框架。这些话题将会第 3.5 节 “核心概念”被深入介绍，当前，你所需知道的是，pom.xml是一个让 Maven跑起来的文件。当Maven运行的时候，它是根据项目的pom.xml里设置的组合来运行的，一个最上级的 POM定义了Maven的安装目录，在这个目录中全局的默认值被定义了，（可能）还有一些用户定义的设置。想要看这个“有效的 (effective)”POM，或者说Maven真正运行根据的POM，在simple项目的基础目录下跑下面的命令。

 mvn help:effective-pom

一旦你运行了此命令，你应该能看到一个大得多的POM，它暴露了Maven的默认设置

3.4 maven常见标签说明

代码的第一行是XML头，指定了该xml文档的版本和编码方式。 project是所有pom.xml的根元素，它还声明了一些POM相关的命名空间及xsd元素。根元素下的第一个子元素modelVersion指定了当前的POM模型的版本，对于Maven3来说，它只能是4.0.0 代码中最重要是包含了groupId,artifactId和version了。这三个元素定义了一个项目基本的坐标，在Maven的世界，任何的jar、pom或者jar都是以基于这些基本的坐标进行区分的。

groupId 定义了项目属于哪个组，随意命名，比如谷歌公司的myapp项目，就取名为 com.google.myapp

artifactId 定义了当前Maven项目在组中唯一的ID,比如定义hello-world。

version 指定了项目当前的版本0.0.1-SNAPSHOT,SNAPSHOT意为快照，说明该项目还处于开发中，是不稳定的。

name 元素生命了一个对于用户更为友好的项目名称，虽然这不是必须的，但还是推荐为每个POM声明name,以方便信息交流

description 表示一个项目的描述

4.依赖管理

4.1 依赖配置

依赖指当前项目运行所需的jar，一个项目可以设置多个依赖。

<!-当前项目所依赖的所有jar-->
<dependencies>
	<!-设置具体的依赖-->
	<dependency>
		<!-依赖所属群组id-->
		<groupId>junit</groupId>
		<!-依赖所属项目id-->
		<artifactId>junit</artifactId>
		<!-依赖版本号-->
		<version>4.12</version>
	</dependency>
</dependencies>

根元素project下的dependencies可以包含一个或者多个dependency元素，以声明一个或者多个项目依赖。每个依赖可以包含的元素有：

grounpId、artifactId和version:以来的基本坐标，对于任何一个依赖来说，基本坐标是最重要的，Maven根据坐标才能找到需要的依赖。
type:依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
scope:依赖的范围
optional:标记依赖是否可选
exclusions:用来排除传递性依赖

4.2 依赖范围

依赖范围就是用来控制依赖和三种classpath(编译classpath，测试classpath、运行classpath)的关系，Maven有如下几种依赖范围：

**compile:**编译依赖范围。如果没有指定，就会默认使用该依赖范围。使用此依赖范围的Maven依赖，对于编译、测试、运行三种classpath都有效。典型的例子是spring-code,在编译、测试和运行的时候都需要使用该依赖。
test: 测试依赖范围。使用次依赖范围的Maven依赖，只对于测试classpath有效，在编译主代码或者运行项目的使用时将无法使用此依赖。典型的例子是Jnuit,它只有在编译测试代码及运行测试的时候才需要。
**provided:**已提供依赖范围。使用此依赖范围的Maven依赖，对于编译和测试classpath有效，但在运行时候无效。典型的例子是servlet-api,编译和测试项目的时候需要该依赖，但在运行项目的时候，由于容器以及提供，就不需要Maven重复地引入一遍。
**runtime:**运行时依赖范围。使用此依赖范围的Maven依赖，对于测试和运行classpath有效，但在编译主代码时无效。典型的例子是JDBC驱动实现，项目主代码的编译只需要JDK提供的JDBC接口，只有在执行测试或者运行项目的时候才需要实现上述接口的具体JDBC驱动。
**system:**系统依赖范围。该依赖与三种classpath的关系，和provided依赖范围完全一致，但是，使用system范围的依赖时必须通过systemPath元素显示地指定依赖文件的路径。由于此类依赖不是通过Maven仓库解析的，而且往往与本机系统绑定，可能构成构建的不可移植，因此应该谨慎使用。systemPath元素可以引用环境变量，如：

<dependency>
    <groupId>javax.sql</groupId>
    <artifactId>jdbc-stdext</artifactId>
    <Version>2.0</Version>
    <scope>system</scope>
    <systemPath>${java.home}/lib/rt.jar</systemPath>
</dependency>

4.3 依赖传递

依赖具有传递性，分两种

（1）直接依赖：在当前项目中通过依赖配置建立的依赖关系

（2）间接依赖：被依赖的资源如果依赖其他资源，则表明当前项目间接依赖其他资源

以一个项目为根，直接依赖称为1度资源，直接依赖的直接依赖称为2度资源，直接依赖的直接依赖的直接依赖称为3度资源。

4.4 依赖传递的冲突问题

在依赖传递过程中产生了冲突，我们有三种优先法则

（1）路径优先：当依赖中出现相同资源时，层级越深，优先级越低，反之则越高

（2）声明优先：当资源在相同层级被依赖时，配置顺序靠前的覆盖靠后的

（3）特殊优先：当同级配置了相同资源的不同版本时，后配置的覆盖先配置的

4.5 可选依赖

选依赖指的是对外隐藏当前所依赖的资源➡不透明，加一个<optional> 标签，optional中的值设置为true即可

    <dependency>
        <groupId>com.thetransactioncompany</groupId>
        <artifactId>cors-filter</artifactId>
        <version>2.5</version>
     <!-- 此依赖只在当前项目中使用，不对外传递-->
        <optional>true</optional>
    </dependency>

4.6 排除依赖

排除依赖指主动断开间接依赖的资源，被排除的资源无需指定版本一一不需要。

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.6.RELEASE</version>
        <exclusions>
          <!-- 排除依赖 spring-context-->
            <exclusion>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

5.生命周期与插件

5.1 生命周期

Maven构建生命周期描述的是一次构建过程经历经历了多少个事件。
Maven对项目构建的生命周期划分为3个阶段。

clean生命周期：清理工作。
default生命周期：核心工作，例如编译，测试，打包，部署等。
site生命周期：产生报告，发布站点等。

Maven有三个内置的构建生命周期（build lifecycle），它们彼此独立，分别是：clean、default、site。clean生命周期主要负责项目的清理工作，default生命周期主要负责项目的部署工作，site生命周期主要负责创建项目的web站点。我们平常用的maven命令mvn clean package中的clean属于clean生命周期，package属于default生命周期。

每个生命周期都有一些列不同的构建阶段（build phase，也叫build stage）组成。生命周期内的这些阶段是有顺序的，并且后面的阶段依赖于前面的阶段。比如clean生命周期有pre-clean、clean、post-clean三个阶段，当我们执行mvn clean的时候其实相当于执行了mvn pre-clean clean，clean前面的阶段都会被执行。

生命周期及其包含的阶段如下：

Clean生命周期：

阶段（phase）	说明
pre-clean	执行清理前的预处理工作
clean	清理之前构建的结果
post-clean	执行清理后需要做的工作

default生命周期：

阶段（phase）	说明
validate	验证项目有效性还有所有必要的信息是否可以获取到
initialize	初始化构建状态，比如设置一些属性或者创建一些目录
generate-sources	生成一些源码，这些源码在编译的时候可能会用到
process-sources	处理源码，比如过滤一些值
generate-resources	生成一些资源，在打包的时候可能会包含这些资源
process-resources	拷贝或者处理资源，将它们移动到目标目录，用于打包
compile	编译项目的源码
process-classes	后置处理编译阶段生成的文件，比如对Java类进行字节码增强
generate-test-sources	生成一些测试源码，在编译的时候可能会用到
process-test-sources	处理测试源码，比如过滤一些值
generate-test-resources	创建测试需要用的资源
process-test-resources	拷贝或者处理资源，将它们移动到测试用的目录
test-compile	编译测试源码，结果输出到目标目录
process-test-classes	后置处理测试阶段编译产生的文件，比如对Java类进行字节码增强
test	使用合适的单元测试框架进行测试，这些测试不应该依赖被打包或部署的代码
prepare-package	在真正打包前做一些必要的准备操作，这个操作会产生未打包的，处理过的package版本
package	将编译后的代码打包成可分发的格式，比如jar包
pre-integration-test	执行集成测试之前的准备工作，比如设置一些需要的环境信息
integration-test	如果有必要，会处理和部署包到继承测试可以运行的环境中
post-integration-test	集成测试后的后置处理，比如清理集成测试用的环境
verify	运行检测任务，以检查包是否合法，是否符合质量要求
install	将包安装到本地仓库，作为依赖提供给本地的其它项目用
deploy	将包发送到远程仓库，其它的开发者和项目可以使用它作为依赖

site生命周期：

阶段（phase）	说明
pre-site	执行生成项目站点前的准备工作
site	生成项目站点文档
post-site	执行操作用于完成站点文档生成，为站点部署做准备
site-deploy	部署站点文档到指定的web服务器

5.2 插件

生命周期中的阶段，类似java的模版方法，它是抽象的，需要由插件去实现它。执行maven命令的时候都是由各个生命周期阶段的插件来完成具体的工作的。比如default生命周期的package阶段可能就是由maven-jar-plugin完成的，之所以说是可能，是因为maven会给一些阶段绑定默认的插件实现，我们也可以通过提供别的插件来改变阶段的执行。

插件除了和生命周期的阶段绑定执行，也可以单独执行，比如mvn dependency:tree可以直接执行dependency插件的tree目标。即生命周期离不开插件，但是插件却可以离开生命周期单独执行。

Maven的核心是一个插件执行框架; 所有的工作都是通过插件完成的。寻找一个特定的目标来执行？有构建和报告插件：构建期间将执行

构建插件，并且应在POM 的元素中配置它们。

报告插件将在站点生成期间执行，并且应在POM 的元素中进行配置。由于Reporting插件的结果是生成的站点的一部分，因此Reporting插件应该是国际化的和本地化的。

在项目的POM文件中配置插件，

添加标签，在标签内添加，在标签内添加，最后在内指定插件的属性，包括groupId，artifactId，version，configuration等属性

更多插件的使用方式请查看maven官方插件 https://maven.apache.org/plugins/index.html

6.maven工程的聚合和继承

6.1 maven工程聚合描述

项目拆分成多个模块之后，各模块之间相互依赖，并发布到本地仓库中。

聚合用于快速构建maven工程，一次性构建多个项目/模块。

创建一个新的maven工程，然后里面src等东西删除掉，只留下pom文件和项目配置文件

pom配置为：

<packaging>pom</packaging>

然后在这个新建的maven工程里面，新建所需要的子模块即可

假设我们现在是这样一个结构的项目，依次从右至左进行依赖，然后我们每次更改代码，都有install，然后刷新maven，更改的代码才会生效，我们如果做成聚合的就不一样了，我只需要更新一个总的pom，其余的子模块会根据他们的依赖关系依次进行更新

我们现在改变项目目录结构，采用聚合的方式，项目结构如图所示：他们之间的依赖关系不变，但是他们都共同属于father工程的子模块，当father执行maven生命周期指令的时候，会根据依赖关系依次执行子模块的生命周期指令

项目结构图：

点击idea右侧maven工具栏，可以看到father模块变成了root项目

6.2 ssm项目聚合maven工程示例

1.新建一个总的工程 compassFather

pom文件如下：

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

    <groupId>com.compass.example</groupId>
    <artifactId>com.compass.father</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>compassDao</module>
        <module>compassBean</module>
        <module>compassService</module>
        <module>compassController</module>
    </modules>
</project>

2.新建一个实体模块

pom文件如下

<?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>
    <groupId>com.compass.example</groupId>
    <artifactId>com.compass.bean</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
</dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3.新建一个模块dao

pom文件如下

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

    <groupId>com.compass.example</groupId>
    <artifactId>com.compass.dao</artifactId>
    <version>1.0-SNAPSHOT</version>

<dependencies>
    <!-- spring依赖   -->

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>com.compass.example</groupId>
        <artifactId>com.compass.bean</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!-- springJDBC   -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>

    <!--  mybatis整合其他框架的依赖  -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.1</version>
    </dependency>
    <!--  mybatis依赖  -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.1</version>
    </dependency>
    <!--  分页插件-->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper</artifactId>
        <version>5.1.2</version>
    </dependency>

    <!--  mysql驱动依赖  -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>
    <!--  德鲁伊连接池依赖 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.12</version>
    </dependency>

    <!-- log4j   -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.25</version>
    </dependency>

</dependencies>

    <build>
        <finalName>mavenExample</finalName>
        <!--扫描到resources下的xml等资源文件-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

4.新建一个service模块。pom文件如下

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

    <groupId>com.compass.example</groupId>
    <artifactId>com.compass.service</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
    <dependency>
        <groupId>com.compass.example</groupId>
        <artifactId>com.compass.dao</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>


    <!-- spring集成测试依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.6.RELEASE</version>
        <scope>test</scope>
    </dependency>

    <!--junit 测试依赖-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>
    <!--aop 切面需要的依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>

    <!--java中转换json数据类型-->
    <dependency>
        <groupId>net.sf.json-lib</groupId>
        <artifactId>json-lib</artifactId>
        <version>2.4</version>
        <classifier>jdk15</classifier>
    </dependency>
    <dependency>
        <groupId>commons-beanutils</groupId>
        <artifactId>commons-beanutils</artifactId>
        <version>1.7.0</version>
    </dependency>
    <dependency>
        <groupId>commons-collections</groupId>
        <artifactId>commons-collections</artifactId>
        <version>3.1</version>
    </dependency>
    <dependency>
        <groupId>commons-lang</groupId>
        <artifactId>commons-lang</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>net.sf.ezmorph</groupId>
        <artifactId>ezmorph</artifactId>
        <version>1.0.3</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>

    <!--  jackson 依赖-->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.0</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.9.5</version>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.14</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>easyexcel</artifactId>
        <version>2.1.1</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>
</dependencies>

    <build>

        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

5.新建一个controller模块。pom文件如下

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

    <groupId>com.compass.example</groupId>
    <artifactId>com.compass.controller</artifactId>
    <version>1.0-SNAPSHOT</version>

<dependencies>
    <dependency>
        <groupId>com.compass.example</groupId>
        <artifactId>com.compass.service</artifactId>
        <version>1.0-SNAPSHOT</version>

    </dependency>

    <!--    谷歌验证码-->
    <dependency>
        <groupId>com.github.penggle</groupId>
        <artifactId>kaptcha</artifactId>
        <version>2.3.2</version>
    </dependency>
    <!--servlet依赖-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
    <!-- jsp依赖 -->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2.1-b03</version>
        <scope>provided</scope>
    </dependency>
    <!--  jstl依赖  -->
    <dependency>
        <groupId>org.apache.taglibs</groupId>
        <artifactId>taglibs-standard-spec</artifactId>
        <version>1.2.5</version>
    </dependency>
    <dependency>
        <groupId>org.apache.taglibs</groupId>
        <artifactId>taglibs-standard-impl</artifactId>
        <version>1.2.5</version>
    </dependency>
    <!-- 文件上传的jar包 -->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.8.0</version>
    </dependency>
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.3.3</version>
        <exclusions>
            <exclusion>
                <artifactId>commons-io</artifactId>
                <groupId>commons-io</groupId>
            </exclusion>
        </exclusions>
    </dependency>


    <!-- 解决跨域请求问题 -->
    <dependency>
        <groupId>com.thetransactioncompany</groupId>
        <artifactId>cors-filter</artifactId>
        <version>2.5</version>
    </dependency>
</dependencies>
    <build>
        <!--扫描到resources下的xml等资源文件-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

        </plugins>
    </build>
</project>

构建完毕接下来我们来说说看配置文件的整理：

1.bean 模块并没有什么配置文件，不需要整理

2.dao 模块配置文件清单如下：

applicationContext-dao.xml (applicationContext- 配置文件规范)
jdbc.properties
log4j.properties l
og4j.xml mybatis.xml

applicationContext-dao.xml 只配置数据库操作层面相关配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">


    <!--spring配置文件：-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--声明数据源，连接数据库-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.drivers}"/>
        <!-- 最大连接池数量 -->
        <property name="maxActive" value="${jdbc.maxActive}"/>
        <!--初始化连接数  -->
        <property name="initialSize" value="3"/>
        <!--最小空闲值，当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请-->
        <property name="minIdle" value="2"/>
        <!-- 添加此处作用是为了在SQL监控页面显示sql执行语句，不配置不显示 -->
        <property name="filters" value="config,stat,wall" />
    </bean>

    <!--SqlSessionFactoryBean创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"/>
        <property name="configLocation" value="classpath:mybatis.xml"/>

        <!-- mybatis插件 -->
        <property name="plugins">
            <set>
                <!-- pageHelper 分页插件 -->
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <props>
                            <!-- 设置数据库类型：-->
                            <prop key="helperDialect">mysql</prop>
                        </props>
                    </property>
                </bean>
            </set>
        </property>

    </bean>

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"></constructor-arg>
        <constructor-arg name="executorType" value="BATCH"></constructor-arg>
    </bean>

    <!--声明mybatis的扫描器，创建dao对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="com.compass.example.dao"/>
    </bean>

</beans>

3.service配置文件清单：

applicationContext-service.xml

applicationContext-service.xml 配置service层相关配置 , myDataSource提示找不到这个bean，但是无关紧要，因为这些配置文件最终都会加载到类路径下，然后在web工程启动的时候，会从类路径下加载这些配置文件，最终将这些bean都实例化好，不会出现找不到bean的情况

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop  https://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx   https://www.springframework.org/schema/tx/spring-tx.xsd

">
    <!-- 支持注解的使用-->
    <context:annotation-config/>

    <!--声明service的注解@Service所在的包名位置-->
    <context:component-scan base-package="com.compass.example.service"/>

    <!--事务配置：注解的配置， aspectj的配置-->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"></property>
    </bean>

    <!-- 编写通知 -->
    <tx:advice id="txActive" transaction-manager="transactionManager">
        <!-- 通知 那些方法需要使用用 -->
        <tx:attributes>
            <!-- 配置执行的方法  所有 以query 和get开头的方法 为只读模式，并且不打开事务-->
            <tx:method name="select*" read-only="true" propagation="NOT_SUPPORTED"/>
            <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
            <tx:method name="query*" read-only="true" propagation="NOT_SUPPORTED"/>
            <!-- 配置所有以update 开头的方法都打开事务 并且10秒超时 并且遇到运行时异常的时候不回滚 -->
            <tx:method name="update*" isolation="DEFAULT" propagation="REQUIRED" timeout="10" no-rollback-for="RuntimeException" />
            <!-- 配置所有delete开头的方法都打开事务 并且10秒后超时 -->
            <tx:method name="delete*" isolation="DEFAULT" propagation="REQUIRED" timeout="10"/>
            <!--  配置所有add开头的 方法都打开事务 -->
            <tx:method name="add*" isolation="DEFAULT" propagation="REQUIRED" timeout="10"/>
            <!-- 配置所有以save开头的方法都打开事务 -->
            <tx:method name="insert*" isolation="DEFAULT" propagation="REQUIRED" timeout="10"/>
            <tx:method name="create*" isolation="DEFAULT" propagation="REQUIRED" timeout="10"/>

        </tx:attributes>
    </tx:advice>
    <!-- 配置需要使用事务的地方 -->
    <aop:config>
        <!-- 配置切入点-->
        <aop:pointcut id="txPointcut" expression="execution(* com.compass.example.service.*.*(..))"/>
        <!-- 将通知与切入点进入整合 -->
        <aop:advisor advice-ref="txActive" pointcut-ref="txPointcut"/>
    </aop:config>

</beans>

4.controller 配置文件清单

applicationContext-mvc.xml

applicationContext-mvc.xml 只配置和web相关的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">


    <!--springMVC配置文件， 声明controller和其它web相关的对象-->
    <context:component-scan base-package="com.compass.example.web" />

    <!-- 处理返回json格式数据 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!--swagger-->
    <!-- 向容器自动注入配置 -->
    <context:annotation-config/>
    <!-- 配置静态资源不被拦截 -->

    <!-- 声明springMvc拦截器 -->
    <mvc:interceptors>
        <!--  声明一个一个拦截器   -->
        <mvc:interceptor>
            <!-- 拦截的请求url地址 可以使用** 表示任意字符,文件或多级目录中的文件 -->
            <mvc:mapping path="/**"/>

            <mvc:exclude-mapping path="/api/**"/>
            <mvc:exclude-mapping path="/css/**"/>
            <mvc:exclude-mapping path="/images/**"/>
            <mvc:exclude-mapping path="/lib/**"/>
            <mvc:exclude-mapping path="/page/**"/>
            <mvc:exclude-mapping path="/**/login.mvc/**"/>
            <!--  声明拦截器对象   -->
            <bean class="com.compass.example.handler.LoginPermissions"> </bean>
        </mvc:interceptor>
    </mvc:interceptors>

    <!--  配置文件上传解析器 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--  配置字符编码集 -->
        <property name="defaultEncoding" value="utf-8"> </property>
        <!-- 配置文件上传大小 单位是字节    -1代表没有限制 maxUploadSizePerFile是限制每个上传文件的大小，而maxUploadSize是限制总的上传文件大小  -->
        <property name="maxUploadSizePerFile" value="-1"> </property>
        <!-- 不设置默认不限制总的上传文件大小，这里设置总的上传文件大小不超过10MB（10*1024*1024） -->
        <property name="maxUploadSize" value="10485760"/>
    </bean>

</beans>

web.xml中的变动如下, classpath:applicationContext-*.xml 的这种匹配模式，会将dao，service，controller的配置文件都加载，否则会找不到bean的情况

	<!-- 加载spring容器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:applicationContext-*.xml</param-value>
	</context-param>

最后配置好tomcat即可

最终部署到tomcat中，解析完后的文件结构如下：

6.3 maven过程的继承

作用：
通过继承可以实现在子工程中沿用父工程中的配置。
maven中的继承与java中的继承相似，在子工程中配置继承关系。

制作方式：

在子工程中声明其父工程坐标与对应的位置。

<!-- 定义该工程的父工程-->
    <parent>
        <groupId>com.compass.example</groupId>
        <artifactId>com.compass.father</artifactId>
        <version>1.0-SNAPSHOT</version>
        <!-- 填写父工程的pom文件 -->
        <relativePath>../../compassFather/pom.xml</relativePath>
    </parent>

依次在bean，dao，service，controller，模块都加上以上这段配置，接下来father工程就有了4个子工程

继承依赖定义

在父工程中定义依赖管理。

<!--声明此处进行依赖管理 -->
<dependencyManagement>
	<!--具体的依赖 -->
	<dependencies>
		<!--spring环境 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.1.9.RELEASE</version>
		</dependency>
	<dependencies>
<dependencyManagement>

在子工程中定义依赖关系，无需声明依赖版本，版本参照父工程中依赖的版本。

<dependencies>
	<!--spring环境 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
	</dependency>
</dependencies>

承与聚合

作用：

聚合用于快速构建项目。
继承用于快速配置。

相同点：

聚合与继承的pom.xml文件打包方式均为pom，可以将两种关系制作到同一个pom文件中。
聚合与继承均属于设计型模块，并无实际的模块内容。

不同点：

聚合是在当前模块中配置关系，聚合可以感知到参与聚合的模块有哪些。
继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己。

继承小结：

定义在父工程中
使用在子工程中（无需配置version）

6.5 maven属性使用

<!--定义自定义属性 -->
<properties>
	<spring.version>5.1.9.RELEASE</spring.version>
	<junit.version>4.12</junit.version>
</properties>

7.maven版本号管理

SNAPSHOT（快照版本）

项目开发过程中，为方便团队成员合作，解决模块间相互依赖和时时更新的问题，开发者对每个模块进行构建的时候，输出的临时性版本叫做快照版本（测试阶段版本）。快照版本会随着开发的进展不断更新。

RELEASE（发布版本）

项目开发到进入阶段里程碑后，向团队外部发布较为稳定的版本，这种版本所对应的构件文件是稳定的，即便进行功能的后续开发，也不会改变当前发布版本内容，这种版本称为发布版本。

工程版本号约定

约定规范：

<主版本>.<次版本>.<增量版本>.<里程碑版本>
主版本：表示项目重大架构的变更，如：spring5相较于spring4的迭代。
次版本：表示有较大的功能增加和变化，或者全面系统的修复漏洞。
增量版本：表示有重大漏洞的修复。
里程碑版本：表明一个版本的里程碑（版本内部）。

8.多环境开发配置

很多情况下，生产环境、开发环境、测试环境的属性值配置各不同。因此需要在不同的环境上加载其对应的属性配置。达到多环境兼容的目的。

<!--创建多环境 -->
<profiles>
	<!--定义具体的环境：生成环境 -->
	<profile>
		<!--定义环境对应的唯一名称 -->
		<id>pro_env</id>
		<!--定义环境中专用的属性值 -->
		<properties>
			<jdbc.url>jdbc:mysql://127.1.1.1:3306/ssm_db</jdbc.url>
		</properties>
		<!--设置默认启动 -->
		<activation>
			<activeByDefault>true</activeByDefault>
		</activation>
	</profile>
	<!--定义具体的环境：开发环境 -->
	<profile>
		<id>dev_env</id>
		……
	</profile>
</profiles>

加载指定环境

作用：
加载指定环境。

调用格式：
mvn 指令 –P 环境定义id

范例：
mvn install –P pro_env

9.跳过测试

跳过测试环节的应用场景

整体模块功能未开发
模块中某个功能未开发完毕
单个功能更新调试导致其他功能失败
快速打包

三种跳过测试的方式

使用命令跳过测试

命令：
mvn 指令 –D skipTests

使用界面操作跳过测试

使用配置跳过测试

<plugin>
	<artifactId>maven-surefire-plugin</artifactId>
	<version>2.22.1</version>
	<configuration>
		<skipTests>true</skipTests><!--设置跳过测试 -->
		<includes> <!--包含指定的测试用例 -->
			<include>**/User*Test.java</include>
		</includes>
		<excludes><!--排除指定的测试用例 -->
			<exclude>**/User*TestCase.java</exclude>
		</excludes>
	</configuration>
</plugin>

10.私服

现在将一个项目分模块进行开发，不同的开发者开发不同的内容，如果需要用到公共资源可以直接从中央仓库下载。如果开发者之间需要用到对方开发的资源。则可以建立一台公共的计算机（私服），开发者将资源上传到该计算机，即可实现小范围内的资源共享。私服必须与中央服务器分离开，虚线左侧可以理解为公司内部范围，虚线右侧为互联网范围。

1. linux安装nexus

文件名：nexus-3.25.1-04-unix.tar.gz

版本号：3.25.1-04

文件大小：156M左右

百度云链接：https://pan.baidu.com/s/1KzzpfA67En_nb59KQ7efEw

提取码：0000

cd到上传的linux服务器目录下,然后进行解压

tar -zxvf nexus-3.25.1-04-unix.tar.gz

**nexus-3.25.1-04：**用于实现 nexus 功能

**sonatype-work：**用于存储数据

启动：

进入解压后的 nexus-3.25.1-04/bin 目录，可以看见 nexus 文件，这就是 Nexus 服务的脚本文件:

通过观察该文件文本内容，可以看到 start 和 run 命令都可以用来启动 Nexus 服务；区别在于：

start 是后台启动，日志以文件形式保存；

run 是当前进程启动，直接打印在控制台；

拓展：

1、其他常用命令还有：

stop 是停止服务；

restart 是重启服务；

status 是查看服务状态

Nexus 服务的默认端口是 8081 。

默认端口是 8081，如果要修改，可以在 sonatype-work/nexus3/etc 目录下的 nexus.properties 配置文件，将 application-port 配置成你要的端口号即可：

如果是云服务器先去控制台管理中心开放端口 8081 ，然后进入服务器，shell控制台开放端口

firewall-cmd --zone=public --add-port=8081/tcp --permanent
firewall-cmd --reload

在配置文件 nexus 中指定jdk安装路径

INSTALL4J_JAVA_HOME_OVERRIDE=/web/jdk-11.0.8

如果是root用户，他会不建议你怎么启动，我们需要配置一下

找到`nexus-3.16.1-02/bin下nexus`文件，vi编辑，将`run_as_root=false`改为`run_as_root=true`，再次启动

如果启动中出现内存不足无法分配，导致启动失败

编辑nexus.vmoptions 文件
vi nexus.vmoptions
修改Nexus 的内存配置即可

-Xms256M
-Xmx256M
-XX:MaxDirectMemorySize=512M

改为合适的大小，保存。

然后启动： ./nexus start

看到控制台输出：就是启动成功

访问：http://ip:8081 即可访问到效果

初始密码是： admin admin123 但是我输入不对

输入命令： find / -name ‘admin.password’ 查询密码配置文件所在位置找到之后直接第一行就是密码，登录成功后改掉密码就行，登录用户名是： admin

2.手动上传jar包

上传完毕后可以看到

3.访问私服配置

本地仓库访问私服

配置本地仓库访问私服的权限（setting.xml）

<servers>
	<server>
		<id>heima-release</id>
		<username>admin</username>
		<password>admin</password>
	</server>
	<server>
		<id>heima-snapshots</id>
		<username>admin</username>
		<password>admin</password>
	</server>
</servers>

项目工程访问私服

配置当前项目访问私服上传资源的保存位置（pom.xml）

看代码，从命名上就看的出来区别，repository表示表示发布版本（稳定版本）构件的仓库，snapshotRepository表示快照版本（开发测试版本）的仓库。这两个元素都需要配置id、name和url，id为远程仓库的唯一标识，name是为了方便人阅读，关键的url表示该仓库的地址。

配置好了就运行命令mvn clean deploy，Maven就会将项目构建输出的构件部署到配置对应的远程仓库，如果项目当前的版本是快照版本，则部署到快照版本的仓库地址，否则就部署到发布版本的仓库地址。当前项目是快照还是发布版本是通过 true 这个来区分的。忘记的同学在看看上面的## 远程仓库的配置。

<distributionManagement>
	<repository>
		<id>heima-release</id>
		<url>http://localhost:8081/repository/heima-release/</url>
	</repository>
	<snapshotRepository>
		<id>heima-snapshots</id>
		<url>http://localhost:8081/repository/heima-snapshots/</url>
	</snapshotRepository>
</distributionManagement>

发布资源到私服命令 mvn deploy

4.自动上传配置

**repository:**在repositories元素下，可以使用repository子元素声明一个或者多个远程仓库。
**id：**仓库声明的唯一id，尤其需要注意的是，Maven自带的中央仓库使用的id为central，如果其他仓库声明也使用该id，就会覆盖中央仓库的配置。
**name：**仓库的名称，让我们直观方便的知道仓库是哪个，暂时没发现其他太大的含义。
**url：**指向了仓库的地址，一般来说，该地址都基于http协议，Maven用户都可以在浏览器中打开仓库地址浏览构件。
**releases和snapshots：**用来控制Maven对于发布版构件和快照版构件的下载权限。需要注意的是 enabled子元素，该例中releases的enabled值为true，表示开启JBoss仓库的发布版本下载支持，而snapshots的enabled值为false，表示关闭JBoss仓库的快照版本的下载支持。根据该配置，Maven只会从JBoss仓库下载发布版的构件，而不会下载快照版的构件。
**layout：**元素值default表示仓库的布局是Maven2及Maven3的默认布局，而不是Maven1的布局。基本不会用到Maven1的布局。
其他：**对于releases和snapshots来说，除了enabled，它们还包含另外两个子元素updatePolicy和checksumPolicy。
1：元素**updatePolicy用来配置Maven从远处仓库检查更新的频率，默认值是daily，表示Maven每天检查一次。其他可用的值包括：never-从不检查更新；always-每次构建都检查更新；interval：X-每隔X分钟检查一次更新（X为任意整数）。
2：元素checksumPolicy用来配置Maven检查校验和文件的策略。当构建被部署到Maven仓库中时，会同时部署对应的检验和文件。在下载构件的时候，Maven会验证校验和文件，如果校验和验证失败，当checksumPolicy的值为默认的warn时，Maven会在执行构建时输出警告信息，其他可用的值包括：fail-Maven遇到校验和错误就让构建失败；ignore-使Maven完全忽略校验和错误。

 <!--远程仓库地址 依赖获取配置-->
    <repositories>
        <!-- 配置私服地址 -->
        <repository>
            <id>compass-nexus</id>
            <name>Compass Nexus Repository</name>
            <url>http://xxxxx:8081/repository/maven-public/</url>
        </repository>
    </repositories>


    <!--远程仓库地址 上传配置-->
    <distributionManagement>
        <repository>
            <id>maven-public</id>
            <name>CompassNexus3Repository</name>
            <url>http://xxxxx:8081/repository/maven-public/</url>
        </repository>
        <snapshotRepository>
            <id>maven-public</id>
            <name>CompassNexus3Repository</name>
            <url>http://xxxxx:8081/repository/maven-snapshots/</url>
            <uniqueVersion>false</uniqueVersion>
        </snapshotRepository>
    </distributionManagement>

点击deploy即可上传到nexus私服上去

11.maven插件实战

1.springboot 依赖和配置分离

<!--上线部署 JAR启动分离依赖lib和配置-->
<plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <!--不打包资源文件-->
                    <excludes>
                        <exclude>*.**</exclude>
                    </excludes>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <!--jar包不包含唯一版本标识-->
                            <useUniqueVersions>false</useUniqueVersions>
                            <!--程序启动类application.java的路径-->
                            <mainClass>com.springboot.example.SpringBootApp</mainClass>
                        </manifest>
                        <!-- 指定配置文件目录，这样jar运行时会去找到同目录下的config文件夹下查找 -->
                        <manifestEntries>
                            <Class-Path>config/</Class-Path>
                        </manifestEntries>
                    </archive>
                    <outputDirectory>${directory}</outputDirectory>
                </configuration>
            </plugin>

            <!--拷贝依赖 copy-dependencies-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>
                               ${directory}/lib
                            </outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!--拷贝资源文件 copy-resources-->
            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-resources</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-resources</goal>
                        </goals>
                        <configuration>
                            <resources>
                                <resource>
                                    <directory>src/main/resources</directory>
                                    <!-- 指定参与构建的resoures-->
                                    <includes>
                                        <include>*.**</include>
                                    </includes>
                                </resource>
                            </resources>
                            <outputDirectory>${directory}/config</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
</plugins>