一，Maven的依赖管理和依赖传递

一，依赖管理

在Maven通过<dependencies> 和<dependency>引入依赖

依赖引用分为两种：

• 本地依赖：本地模块的间的依赖
• 外部依赖：使用中央仓库中开源的jar包依赖s

格式：

<!--设置当前项目所依赖的所有jar包-->
<dependencies>
    <!--设置具体的依赖-->
    <dependency>
        <!--依赖所属群组id-->
        <groupId>org.example</groupId>
        <!--依赖所属项目id-->
        <artifactId>maven-mod2</artifactId>
        <!--依赖版本号-->
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

二，依赖传递

一，依赖传递的概念

Maven的依赖传递和linux中yum解决原生rpm依赖问题有点类似，都是使用传递导入的方式

依赖传递的概念：假如两个模块进行依赖，被依赖方可以使用依赖方的jar包文件

例如：现在有模块A，模块B，模块C，A依赖B，B依赖C，那么通过依赖传递A可以用B和C的所有依赖，B可以使用C的所有依赖

二，依赖传递的原则

依赖传递有三大原则：

• 路径优先：当依赖中出现相同的资源，层级越深，优先级越低，层级越浅，优先级越高
• 声明优先：资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的
• 特殊优先：当同级配置了相同资源的不同版本，后配置覆盖前配置

注：依赖传递性原则的主要目的就是避免依赖冲突问题

三，可选依赖和排除依赖

可选依赖：指对外隐藏或者显示当前所依赖的资源--透明(但该依赖依然是可以被使用的)

可选依赖使用<optional>true|flase</optional>，true为显示依赖，false为隐藏依赖(默认)

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.11</version>
    <optional>true</optional>
</dependency>

排除依赖：指主动断开依赖的资源，被排除的资源无需指定版本(排除依赖，被依赖方不能使用依赖资源)

排除依赖的格式：使用exclusions和exclusion标签

<!--排除哪些资源依赖-->
<exclusions>
    <!--排除具体的资源依赖(里面写排除的坐标即可)-->
    <exclusion>
        <!--排除依赖的坐标-->
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </exclusion>
</exclusions>

例：现在有两两个模块maven-mod1和maven-mod2，其中maven-mod1依赖maven-mod2

① maven-mod1的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>org.example</groupId>
    <artifactId>maven-mod1</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
    <!--依赖maven-mod2文件-->
    <dependency>
        <groupId>org.example</groupId>
        <artifactId>maven-mod2</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

</dependencies>
</project>

② maven-mod2的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>org.example</groupId>
    <artifactId>maven-mod2</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>

    <!--引入junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

</dependencies>
</project>

③ 结果

二，Maven依赖范围和传递性

一，Maven的传递性

 依赖的jar默认情况可以在任何地方使用，可以通过scope标签设定其作用范围

作用范围分三类：

• 主程序范围有效(main文件夹范围内)
• 测试程序范围有效(test文件夹范围内)
• 是否参与打包(package指令范围内)

范围参数有四中：

• compile(默认)：主代码，测试代码，打包都有效
• test：测试代码有效，主代码和打包无效
• provided：主代码和测试代码有效，打包无效
• runtime：打包有效，测试和主代码无效

带有依赖范围的资源在进行传递时，作用范围将受影响

当同样的jar包不同的范围，产生的结果是不一样的

三，Maven的生命周期和插件

一，Maven的生命周期

Maven生命周期描述的是一次构建过程中经历了多少个事件

Maven生命周期划分为三个主要阶段：

1. clean：清理阶段
2. default：核心工作，例如：编译，测试，打包，部署等
3. site：产生报告，发布站点等

这三个主要阶段又有若干个子阶段

Clean生命周期阶段：

1. pro-clean：执行一些需要在clean完成之前的工作
2. clear：移除所有上一次构建生成的文件
3. post-clear：执行一些需要clear之后立刻完成的工作

Default生命周期阶段：

1. validate 校验：校验项目是否正确并且所有必要的信息可以完成项目的构建过程
2. initialize 初始化：初始化构建状态，比如设置属性值
3. generate-sources 生成源代码：生成包含在编译阶段中的任何源代码
4. process-sources 处理源代码：处理源代码，比如说，过滤任意值
5. generate-resources 生成资源文件：生成将会包含在项目包中的资源文件
6. process-resources 编译：复制和处理资源到目标目录，为打包阶段最好准备
7. compile 处理类文件：编译项目的源代码
8. process-classes 处理类文件：处理编译生成的文件，比如说对Java class文件做字节码改善优化
9. generate-test-sources 生成测试源代码：生成包含在编译阶段中的任何测试源代码
10. process-test-sources 处理测试源代码：处理测试源代码，比如说，过滤任意值
11. generate-test-resources 生成测试源文件：为测试创建资源文件
12. process-test-resources 处理测试源文件：复制和处理测试资源到目标目录
13. test-compile 编译测试源码：编译测试源代码到测试目标目录
14. process-test-classes 处理测试类文件：处理测试源码编译生成的文件
15. test 测试：使用合适的单元测试框架运行测试（Juint是其中之一）
16. prepare-package 准备打包：在实际打包之前，执行任何的必要的操作为打包做准备
17. package 打包：将编译后的代码打包成可分发格式的文件，比如JAR、WAR或者EAR文件
18. pre-integration-test 集成测试前：在执行集成测试前进行必要的动作。比如说，搭建需要的环境
19. integration-test 集成测试：处理和部署项目到可以运行集成测试环境中
20. post-integration-test集成测试后：在执行集成测试完成后进行必要的动作。比如说，清理集成测试环境
21. verify 验证：运行任意的检查来验证项目包有效且达到质量标准
22. install 安装：安装项目包到本地仓库，这样项目包可以用作其他本地项目的依赖
23. deploy 部署：将最终的项目包复制到远程仓库中与其他开发者和项目共享

site生命周期阶段：

1. pre-site：执行一些需要在生成站点文档之前完成的工作
2. site：生产项目站点文档
3. post-site：执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
4. site-deploy：将生成的站点文档部署到特定的服务器上

这个生命过程，一个节点事件完成时，这个事件之前的事件必须要被执行一遍，比如：现在压迫package打包，那么在打包之前的操作如编译，测试都必须先执行

二，生命周期和插件

这个生命过程的每一个过程都绑定了一个插件，表面上是一个完整的周期，但它是一个完成不同功能的插件组合起来共同实现的

在Maven中默认工程中就自带了前面的插件，maven也提供其他插件的绑定，如：tomcat插件，source打源码包的插件

Maven官网提供的插件概述地址：http://maven.apache.org/plugins/index.html

一，自定义插件

提供自定义插件可以为Mavne添加其他功能

插件的配置方式：以source插件为例

<!--构建-->
<build>
    <!--添加插件-->
    <plugins>
        <!--添加具体插件-->
        <plugin>
            <!--插件的坐标-->
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <!--表示这个插件执行在生命周期的那个阶段-->
               <executions>
                <!--具体指定-->
                <execution>
                    <!--具体指定在那个阶段执行，这里是package，表示在package这个阶段执行source-->
                    <phase>package</phase>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

四，Maven的聚合

聚合的作用：主要用于快速构建maven工程，一次性可以构建多个项目/模块

聚合可以一次构建多个项目/模块，在没有聚合构建项目/模块只能每一次在一个项目/模块下进行构建，如果项目模块过多时，单个进行构建就会很麻烦，而且容易出现多模块依赖错误等问题，聚合就能很好的避免这些问题

实现聚合的步骤：

1，创建一个空的项目构建模块，定义打包类型为pom

<packaging>pom</packaging>

<modules>
    <module>其他模块路径</module>
    <module>其他模块路径</module>
</modules>

① 在maven-dome的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>org.example</groupId>
    <artifactId>maven-dome</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--定义打包方式为pom-->
    <packaging>pom</packaging>

    <!--关联的其他模块-->
    <modules>
        <!--具体关联的模块-->
        <module>../maven-mod1</module>
        <module>../maven-mod2</module>
    </modules>
</project>

② maven-mod1中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>org.example</groupId>
    <artifactId>maven-mod1</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
     <!--这个模块依赖，maven-mod2-->
    <dependency>
        <groupId>org.example</groupId>
        <artifactId>maven-mod2</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>
</project>

<?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>org.example</groupId>
    <artifactId>maven-mod2</artifactId>
    <version>1.0-SNAPSHOT</version>
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>
</project>

五，Maven的继承

继承的作用：通过继承实现在子过程中沿用父工程中的配置

maven中的继承和java的继承有点相似，在父工程中声明需要被继承的配置信息，子工程配置继承关系

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

1，继承的实现过程：

① 在父工程中通过dependencyManagement声明需被继承的配置信息

<!--表示这些依赖为父工程依赖，可以被子类继承-->
<dependencyManagement>
<!--依赖配置-->
<dependencies>
    <!--具体依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>
</dependencyManagement>

<!--继承父工程-->
<parent>
    <!--父工程的坐标-->
    <groupId>org.example</groupId>
    <artifactId>maven-dome</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--父工程pom文件地址-->
    <relativePath>../maven-dome/pom.xml</relativePath>
</parent>

① 在maven-dom1的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>org.example</groupId>
    <artifactId>maven-mod1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--声明父类继承-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>

            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>2.11.2</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

<?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>org.example</groupId>
    <artifactId>maven-mod2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--继承maven-dom1-->
    <parent>
        <groupId>org.example</groupId>
        <artifactId>maven-mod1</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../maven-mod1/pom.xml</relativePath>
    </parent>

    <dependencies>

    <!--继承了父工程中的junit和log4j，这里可以不写版本号，默认是父工程中的版本，假如父工程中版本修改，          子模块中的依赖版本也会改变-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
        </dependency>
    </dependencies>
</project>

六，Maven属性的定义和使用

Maven属性的定义就相当于java变量的定义，定义属性之后具体表达式可以调用属性值

Maven属性的几大类型：

• 自定义属性
• 内置属性
• Setting属性
• Java系统属性
• 环境变量属性

一，自定义属性

作用：等同于java中的自定义变量

定义的格式：通过properties标签，<属性名>属性值</属性名>

<!--定义属性-->
<properties>
    <!--定义具体属性格式，比如下面属性名分别为wql.version和fq.version，值分别为4.11.1和1.1.1-->
    <wql.version>4.11</wql.version>
    <fq.version>1.1.1</fq.version>
</properties>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>${wql.version}</version>
</dependency>

<?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>org.example</groupId>
    <artifactId>maven-mod2</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <!--自定义属性-->
    <properties>
        <!--定义junit的版本-->
        <junit.version>4.11.1</wql.version>
    </properties>

    <dependencies>
      
        <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <!--调用junit的版本-->
        <version>${junit.version}</version>
        </dependency>
    </dependencies>

</project>

七，Maven的版本约定

八，其他资源加载Maven属性值

Maven的属性定义除了本地当前pom文件可以调用外，其他资源文件如properties,yml等都可以调用该属性

加载步骤：

1，在pom文件中定义属性

<properties>
    <属性名>属性值</属性名>
</properties>

2，开启配置文件加载maven属性值

<build>
    <resources>
        <resource>
            <!--设置外部配置的位置，支持使用内置属性动态配置-->
            <directory>../maven-mod2/src/main/resources</directory>
            <!--开启外部配置文件加载过滤-->
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

3，其他资源调用

${属性名}

<?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>org.example</groupId>
    <artifactId>maven-mod2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <jdbc.name>user</jdbc.name>
        <jdbc.password>123</jdbc.password>
        <jdbc.url>jdbc:mysql://localhost:3306/test</jdbc.url>
        <jdbc.drive>com.mysql.jdbc.Driver</jdbc.drive>
    </properties>

<build>
    <resources>
        <resource>
            <!--设置外部配置的位置，支持使用内置属性动态配置-->
            <directory>../maven-mod2/src/main/resources</directory>
            <!--开启外部配置文件加载过滤-->
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

</project>

② jdbc.properties

username=${jdbc.name}
password=${jdbc.password}
url=${jdbc.url}
drive=${jdbc.drive}

③ 将模块进行package打包，看里面的值是否改变

九，Maven多环境配置

Maven多环境配置是在开发过程中很实用的功能

在开发过程中大体分三个阶段：

• 开发阶段
• 测试阶段
• 部署阶段

这三个阶段可能需要的环境都不一样，传统方式是在不同的阶段修改不同的文件依赖，假如依赖文件过多这会很麻烦，多个环境配置则直接定义三套环境，在不同的阶段使用的不同的依赖文件

1，创建多个环境的格式：

<!--定义多环境-->
<profiles>
    <!--创建具体环境-->
    <profile>
    <!--创建的唯一标识，必须指定-->
    <id>env</id>
        <!--定义这个环境的属性-->
    <properties>

    </properties>
        <!--定义这个环境的依赖-->
    <dependencies>
            
    </dependencies>
    </profile>
</profiles>

2，激活环境：加载指定的环境

在启动项的Command lint添加参数（这里的命令不用加mvn）

指令 -P 环境定义的ID

<profile>
</properties>
    <activation>
         <!--定义为默认环境-->
        <activeByDefault>true</activeByDefault>
    </activation>
</profile>

<?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>org.example</groupId>
    <artifactId>maven-mod1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--定义多环境-->
    <profiles>
        <!--开发环境(默认环境)-->
        <profile>
        <id>dev</id>
            <properties>
                <jdbc.name>user</jdbc.name>
                <jdbc.password>123</jdbc.password>
                <jdbc.url>jdbc:mysql://localhost:3306/dev</jdbc.url>
                <jdbc.drive>com.mysql.jdbc.Driver</jdbc.drive>
            </properties>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>

        <!--测试环境-->
        <profile>
            <id>test</id>
            <properties>
                <jdbc.name>user</jdbc.name>
                <jdbc.password>123</jdbc.password>
                <jdbc.url>jdbc:mysql://localhost:3306/test</jdbc.url>
                <jdbc.drive>com.mysql.jdbc.Driver</jdbc.drive>
            </properties>
        </profile>

        <!--生产环境-->
        <profile>
            <id>pro</id>
            <properties>
                <jdbc.name>user</jdbc.name>
                <jdbc.password>123</jdbc.password>
                <jdbc.url>jdbc:mysql://localhost:3306/pro</jdbc.url>
                <jdbc.drive>com.mysql.jdbc.Driver</jdbc.drive>
            </properties>
        </profile>
    </profiles>
</project>

② 外部的properties文件

username=${jdbc.name}
password=${jdbc.password}
url=${jdbc.url}
drive=${jdbc.drive}