第九章 POM 深入与强化

一、重新认识Maven

1、Maven 的完整功能

在入门的时候我们介绍说 Maven 是一款『构建管理』和『依赖管理』的工具。但事实上这只是 Maven 的一部分功能。Maven 本身的产品定位是一款『项目管理工具』。

2、项目管理功能的具体体现

下面是 spring-boot-starter 的 POM 文件，可以看到：除了我们熟悉的坐标标签、dependencies 标签，还有 description、url、organization、licenses、developers、scm、issueManagement 等这些描述项目信息的标签。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  4.   <!-- This module was also published with a richer model, Gradle metadata,  -->
  5.   <!-- which should be used instead. Do not delete the following line which  -->
  6.   <!-- is to indicate to Gradle or any Gradle module metadata file consumer  -->
  7.   <!-- that they should prefer consuming it instead. -->
  8.   <!-- do_not_remove: published-with-gradle-metadata -->
  9.   <modelVersion>4.0.0</modelVersion>
  10.   <groupId>org.springframework.boot</groupId>
  11.   <artifactId>spring-boot-starter</artifactId>
  12.   <version>2.5.6</version>
  13.   <name>spring-boot-starter</name>
  14.   <description>Core starter, including auto-configuration support, logging and YAML</description>
  15.   <url>https://spring.io/projects/spring-boot</url>
  16.   <organization>
  17.     <name>Pivotal Software, Inc.</name>
  18.     <url>https://spring.io</url>
  19.   </organization>
  20.   <licenses>
  21.     <license>
  22.       <name>Apache License, Version 2.0</name>
  23.       <url>https://www.apache.org/licenses/LICENSE-2.0</url>
  24.     </license>
  25.   </licenses>
  26.   <developers>
  27.     <developer>
  28.       <name>Pivotal</name>
  29.       <email>info@pivotal.io</email>
  30.       <organization>Pivotal Software, Inc.</organization>
  31.       <organizationUrl>https://www.spring.io</organizationUrl>
  32.     </developer>
  33.   </developers>
  34.   <scm>
  35.     <connection>scm:git:git://github.com/spring-projects/spring-boot.git</connection>
  36.     <developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-boot.git</developerConnection>
  37.     <url>https://github.com/spring-projects/spring-boot</url>
  38.   </scm>
  39.   <issueManagement>
  40.     <system>GitHub</system>
  41.     <url>https://github.com/spring-projects/spring-boot/issues</url>
  42.   </issueManagement>
  44.   <dependencies>
  45.     <dependency>
  46.       ……
  47.     </dependency>
  48.   </dependencies>
  49. </project>

所以从『项目管理』的角度来看，Maven 提供了如下这些功能：

  • 项目对象模型（POM）：将整个项目本身抽象、封装为应用程序中的一个对象，以便于管理和操作。
  • 全局性构建逻辑重用：Maven 对整个构建过程进行封装之后，程序员只需要指定配置信息即可完成构建。让构建过程从 Ant 的『编程式』升级到了 Maven 的『声明式』。
  • 构件的标准集合：在 Maven 提供的标准框架体系内，所有的构件都可以按照统一的规范生成和使用。
  • 构件关系定义：Maven 定义了构件之间的三种基本关系，让大型应用系统可以使用 Maven 来进行管理
    • 继承关系：通过从上到下的继承关系，将各个子构件中的重复信息提取到父构件中统一管理
    • 聚合关系：将多个构件聚合为一个整体，便于统一操作
    • 依赖关系：Maven 定义了依赖的范围、依赖的传递、依赖的排除、版本仲裁机制等一系列规范和标准，让大型项目可以有序容纳数百甚至更多依赖
  • 插件目标系统：Maven 核心程序定义抽象的生命周期，然后将插件的目标绑定到生命周期中的特定阶段，实现了标准和具体实现解耦合，让 Maven 程序极具扩展性
  • 项目描述信息的维护：我们不仅可以在 POM 中声明项目描述信息，更可以将整个项目相关信息收集起来生成 HTML 页面组成的一个可以直接访问的站点。这些项目描述信息包括：
    • 公司或组织信息
    • 项目许可证
    • 开发成员信息
    • issue 管理信息
    • SCM 信息

      二、POM 的四个层次

      1、超级 POM

      经过我们前面的学习，我们看到 Maven 在构建过程中有很多默认的设定。例如：源文件存放的目录、测试源文件存放的目录、构建输出的目录……等等。但是其实这些要素也都是被 Maven 定义过的。定义的位置就是：超级 POM。
      关于超级 POM，Maven 官网是这样介绍的：

      The Super POM is Maven’s default POM. All POMs extend the Super POM unless explicitly set, meaning the configuration specified in the Super POM is inherited by the POMs you created for your projects. 译文：Super POM 是 Maven 的默认 POM。除非明确设置，否则所有 POM 都扩展 Super POM，这意味着 Super POM 中指定的配置由您为项目创建的 POM 继承。

所以我们自己的 POM 即使没有明确指定一个父工程（父 POM），其实也默认继承了超级 POM。就好比一个 Java 类默认继承了 Object 类。
那么超级 POM 中定义了哪些东西呢？点击这里查看。

2、父 POM

和 Java 类一样，POM 之间其实也是单继承的。如果我们给一个 POM 指定了父 POM，那么继承关系如下图所示：
image.png

3、有效 POM

①概念

有效 POM 英文翻译为 effective POM，它的概念是这样的——在 POM 的继承关系中，子 POM 可以覆盖父 POM 中的配置；如果子 POM 没有覆盖，那么父 POM 中的配置将会被继承。按照这个规则，继承关系中的所有 POM 叠加到一起，就得到了一个最终生效的 POM。显然 Maven 实际运行过程中，执行构建操作就是按照这个最终生效的 POM 来运行的。这个最终生效的 POM 就是有效 POM，英文叫effective POM。

②查看有效 POM

mvn help:effective-pom
运行效果点击这里查看。

4、小结

综上所述，平时我们使用和配置的 POM 其实大致是由四个层次组成的：

  • 超级 POM：所有 POM 默认继承，只是有直接和间接之分。
  • 父 POM：这一层可能没有，可能有一层，也可能有很多层。
  • 当前 pom.xml 配置的 POM：我们最多关注和最多使用的一层。
  • 有效 POM：隐含的一层，但是实际上真正生效的一层。

    三、属性的声明与引用

    1、help 插件的各个目标

    官网说明地址：https://maven.apache.org/plugins/maven-help-plugin
目标 说明
help:active-profiles 列出当前已激活的 profile
help:all-profiles 列出当前工程所有可用 profile
help:describe 描述一个插件和/或 Mojo 的属性
help:effective-pom 以 XML 格式展示有效 POM
help:effective-settings 为当前工程以 XML 格式展示计算得到的 settings 配置
help:evaluate 计算用户在交互模式下给出的 Maven 表达式
help:system 显示平台详细信息列表，如系统属性和环境变量

2、使用 help:evaluate 查看属性值

①定义属性

  1. <properties>
  2.     <com.atguigu.hello>good morning maven</com.atguigu.hello>
  3. </properties>

②运行命令

image.png

③运行结果

image.png

3、通过 Maven 访问系统属性

① Java 系统属性一览

[1] Java 代码
  1. Properties properties = System.getProperties();
  2. Set<Object> propNameSet = properties.keySet();
  3. for (Object propName : propNameSet) {
  4.     String propValue = properties.getProperty((String) propName);
  5.     System.out.println(propName + " = " + propValue);
  6. }

[2]运行结果

java.runtime.name = Java(TM) SE Runtime Environment
sun.boot.library.path = D:\software\Java\jre\bin
java.vm.version = 25.141-b15
java.vm.vendor = Oracle Corporation
java.vendor.url = http://java.oracle.com/
path.separator = ;
java.vm.name = Java HotSpot(TM) 64-Bit Server VM
file.encoding.pkg = sun.io
user.country = CN
user.script =
sun.java.launcher = SUN_STANDARD
sun.os.patch.level =
java.vm.specification.name = Java Virtual Machine Specification
user.dir = D:\idea2019workspace\atguigu-maven-test-prepare
java.runtime.version = 1.8.0_141-b15
java.awt.graphicsenv = sun.awt.Win32GraphicsEnvironment
java.endorsed.dirs = D:\software\Java\jre\lib\endorsed
os.arch = amd64
java.io.tmpdir = C:\Users\ADMINI~1\AppData\Local\Temp\
line.separator =
java.vm.specification.vendor = Oracle Corporation
user.variant =
os.name = Windows 10
sun.jnu.encoding = GBK
java.library.path = D:\software\Java\bin;C:\WINDOWS\Sun\Java\bin;C:\WIN……
java.specification.name = Java Platform API Specification
java.class.version = 52.0
sun.management.compiler = HotSpot 64-Bit Tiered Compilers
os.version = 10.0
user.home = C:\Users\Administrator
user.timezone =
java.awt.printerjob = sun.awt.windows.WPrinterJob
file.encoding = UTF-8
java.specification.version = 1.8
java.class.path = D:\software\Java\jre\lib\charsets.jar;D:\softw……
user.name = Administrator
java.vm.specification.version = 1.8
sun.java.command = com.atguigu.maven.MyTest
java.home = D:\software\Java\jre
sun.arch.data.model = 64
user.language = zh
java.specification.vendor = Oracle Corporation
awt.toolkit = sun.awt.windows.WToolkit
java.vm.info = mixed mode
java.version = 1.8.0_141
java.ext.dirs = D:\software\Java\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext
sun.boot.class.path = D:\software\Java\jre\lib\resources.jar;D:\sof……
java.vendor = Oracle Corporation
file.separator = \
java.vendor.url.bug = http://bugreport.sun.com/bugreport/
sun.io.unicode.encoding = UnicodeLittle
sun.cpu.endian = little
sun.desktop = windows
sun.cpu.isalist = amd64

②使用 Maven 访问系统属性

image.png

4、访问系统环境变量

${env.系统环境变量名}
image.png

5、访问 project 属性

①含义

使用表达式 ${project.xxx} 可以访问当前 POM 中的元素值。

②访问一级标签

${project.标签名}
image.png

③访问子标签

${project.标签名.子标签名}
image.png

④访问列表标签

${project.标签名[下标]}
image.png

6、访问 settings 全局配置

${settings.标签名} 可以访问 settings.xml 中配置的元素值。
image.png

7、用途

  • 在当前 pom.xml 文件中引用属性
  • 资源过滤功能：在非 Maven 配置文件中引用属性，由 Maven 在处理资源时将引用属性的表达式替换为属性值

    四、build 标签详解

    1、一睹真容

    在实际使用 Maven 的过程中，我们会发现 build 标签有时候有，有时候没，这是怎么回事呢？其实通过有效 POM 我们能够看到，build 标签的相关配置其实一直都在，只是在我们需要定制构建过程的时候才会通过配置 build 标签覆盖默认值或补充配置。这一点我们可以通过打印有效 POM 来看到。
    点我查看 build 标签的完整示例
    所以本质上来说：我们配置的 build 标签都是对超级 POM 配置的叠加。那我们又为什么要在默认配置的基础上叠加呢？很简单，在默认配置无法满足需求的时候定制构建过程。

    2、build 标签组成

    从完整示例中我们能够看到，build 标签的子标签大致包含三个主体部分：

    ①定义约定的目录结构

    参考示例中的如下部分：
    1. <sourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\java</sourceDirectory>
    2. <scriptSourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\scripts</scriptSourceDirectory>
    3. <testSourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\test\java</testSourceDirectory>
    4. <outputDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\target\classes</outputDirectory>
    5. <testOutputDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\target\test-classes</testOutputDirectory>
    6. <resources>
    7.   <resource>
    8.       <directory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\resources</directory>
    9.   </resource>
    10. </resources>
    11. <testResources>
    12.   <testResource>
    13.       <directory>D:\idea2019workspace\atguigu-maven-test-prepare\src\test\resources</directory>
    14.   </testResource>
    15. </testResources>
    16. <directory>D:\idea2019workspace\atguigu-maven-test-prepare\target</directory>
    我们能看到各个目录的作用如下：
目录名 作用
sourceDirectory 主体源程序存放目录
scriptSourceDirectory 脚本源程序存放目录
testSourceDirectory 测试源程序存放目录
outputDirectory 主体源程序编译结果输出目录
testOutputDirectory 测试源程序编译结果输出目录
resources 主体资源文件存放目录
testResources 测试资源文件存放目录
directory 构建结果输出目录

②备用插件管理

pluginManagement 标签存放着几个极少用到的插件：

  • maven-antrun-plugin
  • maven-assembly-plugin
  • maven-dependency-plugin
  • maven-release-plugin

通过 pluginManagement 标签管理起来的插件就像 dependencyManagement 一样，子工程使用时可以省略版本号，起到在父工程中统一管理版本的效果。情看下面例子：

  • 被 spring-boot-dependencies 管理的插件信息：

    1. <plugin>
    2.   <groupId>org.springframework.boot</groupId>
    3.   <artifactId>spring-boot-maven-plugin</artifactId>
    4.   <version>2.6.2</version>
    5. </plugin>

  • 子工程使用的插件信息：

    1. <build>
    2.   <plugins>
    3.       <plugin>
    4.           <groupId>org.springframework.boot</groupId>
    5.           <artifactId>spring-boot-maven-plugin</artifactId>
    6.       </plugin>
    7.   </plugins>
    8. </build>

    ③生命周期插件

    plugins 标签存放的是默认生命周期中实际会用到的插件，这些插件想必大家都不陌生，所以抛开插件本身不谈，我们来看看 plugin 标签的结构：

    1. <plugin>
    2.   <artifactId>maven-compiler-plugin</artifactId>
    3.   <version>3.1</version>
    4.   <executions>
    5.       <execution>
    6.           <id>default-compile</id>
    7.           <phase>compile</phase>
    8.           <goals>
    9.               <goal>compile</goal>
    10.           </goals>
    11.       </execution>
    12.       <execution>
    13.           <id>default-testCompile</id>
    14.           <phase>test-compile</phase>
    15.           <goals>
    16.               <goal>testCompile</goal>
    17.           </goals>
    18.       </execution>
    19.   </executions>
    20. </plugin>

    [1]坐标部分

    artifactId 和 version 标签定义了插件的坐标，作为 Maven 的自带插件这里省略了 groupId。

    [2]执行部分

    executions 标签内可以配置多个 execution 标签，execution 标签内：

  • id：指定唯一标识

  • phase：关联的生命周期阶段
  • goals/goal：关联指定生命周期的目标
    • goals 标签中可以配置多个 goal 标签，表示一个生命周期环节可以对应当前插件的多个目标。

另外，插件目标的执行过程可以进行配置，例如 maven-site-plugin 插件的 site 目标：

  1. <execution>
  2.     <id>default-site</id>
  3.     <phase>site</phase>
  4.     <goals>
  5.         <goal>site</goal>
  6.     </goals>
  7.     <configuration>
  8.         <outputDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\target\site</outputDirectory>
  9.         <reportPlugins>
  10.             <reportPlugin>
  11.                 <groupId>org.apache.maven.plugins</groupId>
  12.                 <artifactId>maven-project-info-reports-plugin</artifactId>
  13.             </reportPlugin>
  14.         </reportPlugins>
  15.     </configuration>
  16. </execution>

configuration 标签内进行配置时使用的标签是插件本身定义的。就以 maven-site-plugin 插件为例，它的核心类是 org.apache.maven.plugins.site.render.SiteMojo，在这个类中我们看到了 outputDirectory 属性：
image.png
SiteMojo 的父类是：AbstractSiteRenderingMojo，在父类中我们看到 reportPlugins 属性：
image.png
结论：每个插件能够做哪些设置都是各个插件自己规定的，无法一概而论。

3、典型应用：指定 JDK 版本

①提出问题

前面我们在 settings.xml 中配置了 JDK 版本，那么将来把 Maven 工程部署都服务器上，脱离了 settings.xml 配置，如何保证程序正常运行呢？思路就是我们直接把 JDK 版本信息告诉负责编译操作的 maven-compiler-plugin 插件，让它在构建过程中，按照我们指定的信息工作。

②暂时取消 settings.xml 配置

为了测试对 maven-compiler-plugin 插件进行配置的效果，我们暂时取消 settings.xml 中的 profile 配置。

  1. <!-- 配置Maven工程的默认JDK版本 -->
  2. <!-- <profile>
  3.   <id>jdk-1.8</id>
  4.   <activation>
  5.     <activeByDefault>true</activeByDefault>
  6.     <jdk>1.8</jdk>
  7.   </activation>
  8.   <properties>
  9.     <maven.compiler.source>1.8</maven.compiler.source>
  10.     <maven.compiler.target>1.8</maven.compiler.target>
  11.     <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
  12.   </properties>
  13. </profile> -->

③编写源文件代码

很明显这里用到了 Lambda 表达式，这是 JDK 1.8 才支持的语法。

  1. package com.atguigu.maven;
  3. public class Hello {
  5.     public void hello() {
  6.         new Thread(()->{
  7.             System.out.println("thread ...");
  8.         }).start();
  9.     }
  11. }

此时我们执行编译命令：
image.png

④配置构建过程

  2. <!-- build 标签：意思是告诉 Maven，你的构建行为，我要开始定制了！ -->
  3. <build>
  4.     <!-- plugins 标签：Maven 你给我听好了，你给我构建的时候要用到这些插件！ -->
  5.     <plugins>
  6.         <!-- plugin 标签：这是我要指定的一个具体的插件 -->
  7.         <plugin>
  8.             <!-- 插件的坐标。此处引用的 maven-compiler-plugin 插件不是第三方的，是一个 Maven 自带的插件。 -->
  9.             <groupId>org.apache.maven.plugins</groupId>
  10.             <artifactId>maven-compiler-plugin</artifactId>
  11.             <version>3.1</version>
  13.             <!-- configuration 标签：配置 maven-compiler-plugin 插件 -->
  14.             <configuration>
  15.                 <!-- 具体配置信息会因为插件不同、需求不同而有所差异 -->
  16.                 <source>1.8</source>
  17.                 <target>1.8</target>
  18.                 <encoding>UTF-8</encoding>
  19.             </configuration>
  20.         </plugin>
  21.     </plugins>
  22. </build>

⑤再次执行编译命令

image.png

⑥两种配置方式比较

  • settings.xml 中配置：仅在本地生效，如果脱离当前 settings.xml 能够覆盖的范围，则无法生效。

  • 在当前 Maven 工程 pom.xml 中配置：无论在哪个环境执行编译等构建操作都有效。

    ⑦补充说明

    [1]source 标签含义

    查看 Maven 官网页面(opens new window)，我们找到 source 标签的介绍：
    image.png
    翻译过来就是：调用 Java 编译器命令时传入的 -source 参数。那对编译器来说，-source 参数是啥意思呢？
    image.png
    『提供与指定发行版的源兼容性』这句话我的理解是：

  • 我们写代码是按 JDK 1.8 写的——这就是『源兼容性』里的『源』。

  • 指定发行版就是我们指定的 JDK 1.8。
  • 『兼容性』是谁和谁兼容呢？现在源代码是既定的，所以就是要求编译器使用指定的 JDK 版本来兼容我们的源代码。

另外我们还看到：
image.png
这个功能还可以通过在 properties 标签中配置 maven.compiler.source 属性来实现。所以我们也经常会看到类似这样的配置：

  1. <properties>
  2.     <maven.compiler.source>1.8</maven.compiler.source>
  3.     <maven.compiler.target>1.8</maven.compiler.target>
  4.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  5. </properties>

[2]target 标签含义

image.png
翻译过来就是：调用 Java 编译器命令时传入的 -target 参数。那对编译器来说，-target 参数是啥意思呢？
image.png
『生成特定 VM 版本的类文件』这句话我的理解是：

  • VM 指 JVM
  • 类文件指 *.class 字节码文件
  • 整体意思就是源文件编译后，生成的 *.class 字节码文件要符合指定的 JVM 版本

    4、典型应用：SpringBoot 定制化打包

    ①需求

    很显然 spring-boot-maven-plugin 并不是 Maven 自带的插件，而是 SpringBoot 提供的，用来改变 Maven 默认的构建行为。具体来说是改变打包的行为。默认情况下 Maven 调用 maven-jar-plugin 插件的 jar 目标，生成普通的 jar 包。
    普通 jar 包没法使用 java -jar xxx.jar 这样的命令来启动、运行，但是 SpringBoot 的设计理念就是每一个『微服务』导出为一个 jar 包，这个 jar 包可以使用 java -jar xxx.jar 这样的命令直接启动运行。
    这样一来，打包的方式肯定要进行调整。所以 SpringBoot 提供了 spring-boot-maven-plugin 这个插件来定制打包行为。
    image.png

    ②示例代码

    所有的一切已经都被 SpringBoot 封装好了，所以配置非常简单，提供插件坐标即可。
    1. <build>
    2.   <plugins>
    3.       <plugin>
    4.           <groupId>org.springframework.boot</groupId>
    5.           <artifactId>spring-boot-maven-plugin</artifactId>
    6.           <version>2.5.5</version>
    7.       </plugin>
    8.   </plugins>
    9. </build>

    ③插件的七个目标

    image.png
目标名称 作用
spring-boot:build-image Package an application into a OCI image using a buildpack.
spring-boot:build-info Generate a build-info.properties file based on the content of the current MavenProject.
spring-boot:help Display help information on spring-boot-maven-plugin.
Call mvn spring-boot:help -Ddetail=true -Dgoal= to display parameter details.
spring-boot:repackage Repackage existing JAR and WAR archives so that they can be executed from the command line using java -jar. With layout=NONE can also be used simply to package a JAR with nested dependencies (and no main class, so not executable).
spring-boot:run Run an application in place.
spring-boot:start Start a spring application. Contrary to the run goal, this does not block and allows other goals to operate on the application. This goal is typically used in integration test scenario where the application is started before a test suite and stopped after.
spring-boot:stop Stop an application that has been started by the ‘start’ goal. Typically invoked once a test suite has completed.

5、典型应用：Mybatis 逆向工程

使用 Mybatis 的逆向工程需要使用如下配置，MBG 插件的特点是需要提供插件所需的依赖：

  1. <!-- 控制 Maven 在构建过程中相关配置 -->
  2. <build>
  4.     <!-- 构建过程中用到的插件 -->
  5.     <plugins>
  7.         <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
  8.         <plugin>
  9.             <groupId>org.mybatis.generator</groupId>
  10.             <artifactId>mybatis-generator-maven-plugin</artifactId>
  11.             <version>1.3.0</version>
  13.             <!-- 插件的依赖 -->
  14.             <dependencies>
  16.                 <!-- 逆向工程的核心依赖 -->
  17.                 <dependency>
  18.                     <groupId>org.mybatis.generator</groupId>
  19.                     <artifactId>mybatis-generator-core</artifactId>
  20.                     <version>1.3.2</version>
  21.                 </dependency>
  23.                 <!-- 数据库连接池 -->
  24.                 <dependency>
  25.                     <groupId>com.mchange</groupId>
  26.                     <artifactId>c3p0</artifactId>
  27.                     <version>0.9.2</version>
  28.                 </dependency>
  30.                 <!-- MySQL驱动 -->
  31.                 <dependency>
  32.                     <groupId>mysql</groupId>
  33.                     <artifactId>mysql-connector-java</artifactId>
  34.                     <version>5.1.8</version>
  35.                 </dependency>
  36.             </dependencies>
  37.         </plugin>
  38.     </plugins>
  39. </build>

6、小结

不知大家有没有发现，通常需要用到 build 标签的时候底层都会帮我们封装好，需要我们配置的地方不多。即使有些地方需要我们配置，也不会真的我们自己去写，把现成的案例复制过来就行。
所以对 build 标签来说，我们的掌握要求就是：能大致看懂就行。

五、依赖配置补充

Maven 官网介绍依赖机制(opens new window)

1、依赖范围

①import

管理依赖最基本的办法是继承父工程，但是和 Java 类一样，Maven 也是单继承的。如果不同体系的依赖信息封装在不同 POM 中了，没办法继承多个父工程怎么办？这时就可以使用 import 依赖范围。
典型案例当然是在项目中引入 SpringBoot、SpringCloud 依赖：

  1. <dependencyManagement>
  2.     <dependencies>
  4.         <!-- SpringCloud 依赖导入 -->
  5.         <dependency>
  6.             <groupId>org.springframework.cloud</groupId>
  7.             <artifactId>spring-cloud-dependencies</artifactId>
  8.             <version>Hoxton.SR9</version>
  9.             <type>pom</type>
  10.             <scope>import</scope>
  11.         </dependency>
  13.         <!-- SpringCloud Alibaba 依赖导入 -->
  14.         <dependency>
  15.             <groupId>com.alibaba.cloud</groupId>
  16.             <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  17.             <version>2.2.6.RELEASE</version>
  18.             <type>pom</type>
  19.             <scope>import</scope>
  20.         </dependency>
  22.         <!-- SpringBoot 依赖导入 -->
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-dependencies</artifactId>
  26.             <version>2.3.6.RELEASE</version>
  27.             <type>pom</type>
  28.             <scope>import</scope>
  29.         </dependency>
  30.     </dependencies>
  31. </dependencyManagement>

import 依赖范围使用要求：

  • 打包类型必须是 pom
  • 必须放在 dependencyManagement 中

    官网说明如下： This scope is only supported on a dependency of type pom in the section. It indicates the dependency is to be replaced with the effective list of dependencies in the specified POM’s section. Since they are replaced, dependencies with a scope of import do not actually participate in limiting the transitivity of a dependency.

②system

以 Windows 系统环境下开发为例，假设现在 D:\tempare\atguigu-maven-test-aaa-1.0-SNAPSHOT.jar 想要引入到我们的项目中，此时我们就可以将依赖配置为 system 范围：

  1. <dependency>
  2.     <groupId>com.atguigu.maven</groupId>
  3.     <artifactId>atguigu-maven-test-aaa</artifactId>
  4.     <version>1.0-SNAPSHOT</version>
  5.     <systemPath>D:\tempare\atguigu-maven-test-aaa-1.0-SNAPSHOT.jar</systemPath>
  6.     <scope>system</scope>
  7. </dependency>

但是很明显：这样引入依赖完全不具有可移植性，所以不要使用。如果需要引入体系外 jar 包我们后面会讲专门的办法。

③runtime

专门用于编译时不需要，但是运行时需要的 jar 包。比如：编译时我们根据接口调用方法，但是实际运行时需要的是接口的实现类。典型案例是：

  1. <!--热部署 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-devtools</artifactId>
  5.     <scope>runtime</scope>
  6.     <optional>true</optional>
  7. </dependency>

2、可选依赖

①配置举例

  1. <!--热部署 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-devtools</artifactId>
  5.     <scope>runtime</scope>
  6.     <optional>true</optional>
  7. </dependency>

②本质含义

可选其实就是『可有可无』。官网的解释是：
image.png
其核心含义是：Project X 依赖 Project A，A 中一部分 X 用不到的代码依赖了 B，那么对 X 来说 B 就是『可有可无』的。
image.png

3、版本仲裁

①最短路径优先

在下图的例子中，对模块 pro25-module-a 来说，Maven 会采纳 1.2.12 版本。
image.png

②路径相同时先声明者优先

image.png
此时 Maven 采纳哪个版本，取决于在 pro29-module-x 中，对 pro30-module-y 和 pro31-module-z 两个模块的依赖哪一个先声明。

③小结

其实 Maven 的版本仲裁机制只是在没有人为干预的情况下，自主决定 jar 包版本的一个办法。而实际上我们要使用具体的哪一个版本，还要取决于项目中的实际情况。所以在项目正常运行的情况下，jar 包版本可以由 Maven 仲裁，不必我们操心；而发生冲突时 Maven 仲裁决定的版本无法满足要求，此时就应该由程序员明确指定 jar 包版本。

六、Maven 自定义插件

1、本节定位

其实实际开发中几乎没有什么场景需要我们开发自定义 Maven 插件，所以本节只是通过这个角度帮助我们更好的理解插件的目标和生命周期阶段之间的关系。

2、插件开发

①创建工程

[略]

②设定打包方式

  1. <packaging>maven-plugin</packaging>

③引入依赖

下面两种方式二选一：

[1]将来在文档注释中使用注解
  1. <dependency>
  2.     <groupId>org.apache.maven</groupId>
  3.     <artifactId>maven-plugin-api</artifactId>
  4.     <version>3.5.2</version>
  5. </dependency>

[2]将来直接使用注解
  1. <dependency>
  2.     <groupId>org.apache.maven</groupId>
  3.     <artifactId>maven-plugin-api</artifactId>
  4.     <version>3.5.2</version>
  5. </dependency>

④创建 Mojo 类

Mojo 类是一个 Maven 插件的核心类。
Mojo 这个单词的意思是：Maven Old Java Object，其实 mojo 这个单词本身包含魔力;符咒(袋);护身符;(人的)魅力的含义，Maven 用 Mojo 是因为它是对 POJO 开的一个小玩笑。

[1] Mojo 接口

每一个 Mojo 都需要实现 org.apache.maven.plugin.Mojo 接口。
image.png

[2] AbstractMojo 抽象类

我们实现 Mojo 接口比较困难，幸好可以继承 AbstractMojo，此时我们只要实现 execute() 这一个方法即可。

  1. public class MyHelloPlugin extends AbstractMojo {
  2.     @Override
  3.     public void execute() throws MojoExecutionException, MojoFailureException {
  4.         getLog().info("---> This is my first maven plugin. <---");
  5.     }
  6. }

3、插件配置

①Mojo 类中的配置

[1]文档注释中用注解

对应的 pom.xml 中的依赖： maven-plugin-api
image.png

[2]直接在类上标记注解

对应 pom.xml 中的依赖：maven-plugin-annotations

  1. // name 属性：指定目标名称
  2. @Mojo(name = "firstBlood")
  3. public class MyPluginOfFistBlood extends AbstractMojo {
  4.     @Override
  5.     public void execute() throws MojoExecutionException, MojoFailureException {
  6.         getLog().info("---> first blood <---");
  7.     }
  8. }

②安装插件

要在后续使用插件，就必须至少将插件安装到本地仓库。

③注册插件

我们需要将插件坐标中的 groupId 部分注册到 settings.xml 中。

  1. <pluginGroups>
  2.     <!-- pluginGroup
  3.      | Specifies a further group identifier to use for plugin lookup.
  4.     <pluginGroup>com.your.plugins</pluginGroup>
  5.     -->
  6.     <pluginGroup>com.atguigu.maven</pluginGroup>
  7. </pluginGroups>

4、使用插件

①识别插件前缀

Maven 根据插件的 artifactId 来识别插件前缀。例如下面两种情况：

[1]前置匹配
  • 匹配规则：${prefix}-maven-plugin
  • artifactId：hello-maven-plugin

  • 前缀：hello

    [2]中间匹配

  • 匹配规则：maven-${prefix}-plugin

  • artifactId：maven-good-plugin

  • 前缀：good

    ②在命令行直接用

  • 命令：

    mvn hello:sayHello

  • 效果：

image.png

③配置到 build 标签里

这里找一个和插件无关的 Maven 工程配置才有说服力。

[1]配置
  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>com.atguigu.maven</groupId>
  5.             <artifactId>hello-maven-plugin</artifactId>
  6.             <version>1.0-SNAPSHOT</version>
  7.             <executions>
  8.                 <execution>
  9.                     <id>hello</id>
  10.                     <!-- 指定和目标关联的生命周期阶段 -->
  11.                     <phase>clean</phase>
  12.                     <goals>
  13.                         <goal>sayHello</goal>
  14.                     </goals>
  15.                 </execution>
  16.                 <execution>
  17.                     <id>blood</id>
  18.                     <phase>validate</phase>
  19.                     <goals>
  20.                         <goal>firstBlood</goal>
  21.                     </goals>
  22.                 </execution>
  23.             </executions>
  24.         </plugin>
  25.     </plugins>
  26. </build>

[2]效果

image.png

[3]图形化界面使用

image.png

[4]命令行使用

执行已和插件目标绑定的生命周期：
image.png

第七节 profile 详解

1、profile 概述

①单词释义

image.png
这里我们可以对接 profile 这个单词中『侧面』这个含义：项目的每一个运行环境，相当于是项目整体的一个侧面。
image.png

②项目的不同运行环境

image.png
通常情况下，我们至少有三种运行环境：

  • 开发环境：供不同开发工程师开发的各个模块之间互相调用、访问；内部使用
  • 测试环境：供测试工程师对项目的各个模块进行功能测试；内部使用
  • 生产环境：供最终用户访问——所以这是正式的运行环境，对外提供服务

而我们这里的『环境』仍然只是一个笼统的说法，实际工作中一整套运行环境会包含很多种不同服务器：

  • MySQL
  • Redis
  • ElasticSearch
  • RabbitMQ
  • FastDFS
  • Nginx
  • Tomcat
  • ……

就拿其中的 MySQL 来说，不同环境下的访问参数肯定完全不同：

开发环境 测试环境 生产环境
dev.driver=com.mysql.jdbc.Driver
dev.url=jdbc:mysql://124.71.36.17:3306/db-sys
dev.username=root
dev.password=atguigu		 test.driver=com.mysql.jdbc.Driver
test.url=jdbc:mysql://124.71.36.89:3306/db-sys
test.username=dev-team
test.password=atguigu		 product.driver=com.mysql.jdbc.Driver
product.url=jdbc:mysql://39.107.88.164:3306/prod-db-sys
product.username=root
product.password=atguigu

可是代码只有一套。如果在 jdbc.properties 里面来回改，那就太麻烦了，而且很容易遗漏或写错，增加调试的难度和工作量。所以最好的办法就是把适用于各种不同环境的配置信息分别准备好，部署哪个环境就激活哪个配置。
在 Maven 中，使用 profile 机制来管理不同环境下的配置信息。但是解决同类问题的类似机制在其他框架中也有，而且从模块划分的角度来说，持久化层的信息放在构建工具中配置也违反了『高内聚，低耦合』的原则。
所以 Maven 的 profile 我们了解一下即可，不必深究。

③profile 声明和使用的基本逻辑

  • 首先为每一个环境声明一个 profile
    • 环境 A：profile A
    • 环境 B：profile B
    • 环境 C：profile C
    • ……

  • 然后激活某一个 profile

    ④默认 profile

    其实即使我们在 pom.xml 中不配置 profile 标签，也已经用到 profile了。为什么呢？因为根标签 project 下所有标签相当于都是在设定默认的 profile。这样一来我们也就很容易理解下面这句话：project 标签下除了 modelVersion 和坐标标签之外，其它标签都可以配置到 profile 中。

    2、profile 配置

    ①外部视角：配置文件

    从外部视角来看，profile 可以在下面两种配置文件中配置：

  • settings.xml：全局生效。其中我们最熟悉的就是配置 JDK 1.8。

  • pom.xml：当前 POM 生效

    ②内部实现：具体标签

    从内部视角来看，配置 profile 有如下语法要求：

    [1] profiles/profile 标签

  • 由于 profile 天然代表众多可选配置中的一个所以由复数形式的 profiles 标签统一管理。

  • 由于 profile 标签覆盖了 pom.xml 中的默认配置，所以 profiles 标签通常是 pom.xml 中的最后一个标签。

    [2]id 标签

    每个 profile 都必须有一个 id 标签，指定该 profile 的唯一标识。这个 id 标签的值会在命令行调用 profile 时被用到。这个命令格式是：-D。

    [3]其它允许出现的标签

    一个 profile 可以覆盖项目的最终名称、项目依赖、插件配置等各个方面以影响构建行为。

  • build

    • defaultGoal
    • finalName
    • resources
    • testResources
    • plugins
  • reporting
  • modules
  • dependencies
  • dependencyManagement
  • repositories
  • pluginRepositories

  • properties

    3、激活 profile

    ①默认配置默认被激活

    前面提到了，POM 中没有在 profile 标签里的就是默认的 profile，当然默认被激活。

    ②基于环境信息激活

    环境信息包含：JDK 版本、操作系统参数、文件、属性等各个方面。一个 profile 一旦被激活，那么它定义的所有配置都会覆盖原来 POM 中对应层次的元素。大家可以参考下面的标签结构：

    1. <profile>
    2.   <id>dev</id>
    3.   <activation>
    4.       <!-- 配置是否默认激活 -->
    5.       <activeByDefault>false</activeByDefault>
    6.       <jdk>1.5</jdk>
    7.       <os>
    8.           <name>Windows XP</name>
    9.           <family>Windows</family>
    10.           <arch>x86</arch>
    11.           <version>5.1.2600</version>
    12.       </os>
    13.       <property>
    14.           <name>mavenVersion</name>
    15.           <value>2.0.5</value>
    16.       </property>
    17.       <file>
    18.           <exists>file2.properties</exists>
    19.           <missing>file1.properties</missing>
    20.       </file>
    21.   </activation>
    22. </profile>

    这里有个问题是：多个激活条件之间是什么关系呢？

  • Maven 3.2.2 之前：遇到第一个满足的条件即可激活——或的关系。

  • Maven 3.2.2 开始：各条件均需满足——且的关系。

下面我们来看一个具体例子。假设有如下 profile 配置，在 JDK 版本为 1.6 时被激活：

  1. <profiles>
  2.     <profile>
  3.         <id>JDK1.6</id>
  4.         <activation>
  5.             <!-- 指定激活条件为：JDK 1.6 -->
  6.             <jdk>1.6</jdk>
  7.         </activation>
  8.         ……
  9.     </profile>
  10. </profiles>

这里需要指出的是：Maven 会自动检测当前环境安装的 JDK 版本，只要 JDK 版本是以 1.6 开头都算符合条件。下面几个例子都符合：

  • 1.6.0_03
  • 1.6.0_02

  • ……

    ③命令行激活

    [1]列出活动的 profile
    1. # 列出所有激活的 profile，以及它们在哪里定义
    2. mvn help:active-profiles

    [2]指定某个具体 profile
    1. mvn compile -P<profile id>

    4、操作举例

    ①编写 Lambda 表达式代码

    Lambda 表达式代码要求 JDK 版本必须是 1.8，我们可以以此来判断某个指定更低 JDK 版本的 profile 是否被激活生效。

    1. @Test
    2. public void test() {
    3.   new Thread(()->{
    4.       System.out.println(Thread.currentThread().getName() + " is working");
    5.   }).start();
    6. }

    以目前配置运行这个测试方法：
    image.png

    ②配置 profile

    1. <profiles>
    2.   <profile>
    3.       <id>myJDKProfile</id>
    4.       <!-- build 标签：意思是告诉 Maven，你的构建行为，我要开始定制了！ -->
    5.       <build>
    6.           <!-- plugins 标签：Maven 你给我听好了，你给我构建的时候要用到这些插件！ -->
    7.           <plugins>
    8.               <!-- plugin 标签：这是我要指定的一个具体的插件 -->
    9.               <plugin>
    10.                   <!-- 插件的坐标。此处引用的 maven-compiler-plugin 插件不是第三方的，是一个 Maven 自带的插件。 -->
    11.                   <groupId>org.apache.maven.plugins</groupId>
    12.                   <artifactId>maven-compiler-plugin</artifactId>
    13.                   <version>3.1</version>
    15.                   <!-- configuration 标签：配置 maven-compiler-plugin 插件 -->
    16.                   <configuration>
    17.                       <!-- 具体配置信息会因为插件不同、需求不同而有所差异 -->
    18.                       <source>1.6</source>
    19.                       <target>1.6</target>
    20.                       <encoding>UTF-8</encoding>
    21.                   </configuration>
    22.               </plugin>
    23.           </plugins>
    24.       </build>
    25.   </profile>
    26. </profiles>

    ③执行构建命令

    1. mvn clean test -PmyJDKProfile

    image.png

    5、资源属性过滤

    ①简介

    Maven 为了能够通过 profile 实现各不同运行环境切换，提供了一种『资源属性过滤』的机制。通过属性替换实现不同环境使用不同的参数。

    ②操作演示

    [1]配置 profile

    ```xml

    devJDBCProfile root atguigu http://localhost:3306/db_good com.mysql.jdbc.Driver src/main/resources true 
  1. <a name="a32nx"></a>
  2. ##### [2]创建待处理的资源文件
  3. ```properties
  4. dev.user=${dev.jdbc.user}
  5. dev.password=${dev.jdbc.password}
  6. dev.url=${dev.jdbc.url}
  7. dev.driver=${dev.jdbc.driver}

[3]执行处理资源命令

mvn clean resources:resources -PdevJDBCProfile

[4]找到处理得到的资源文件

image.png

[5]延伸

我们时不时会在 resource 标签下看到 includes 和 excludes 标签。它们的作用是：

  • includes：指定执行 resource 阶段时要包含到目标位置的资源
  • excludes：指定执行 resource 阶段时要排除的资源

情看下面的例子：

  1. <build>
  2.     <resources>
  3.         <resource>
  4.             <!-- 表示为这里指定的目录开启资源过滤功能 -->
  5.             <directory>src/main/resources</directory>
  7.             <!-- 将资源过滤功能打开 -->
  8.             <filtering>true</filtering>
  10.             <includes>
  11.                 <include>*.properties</include>
  12.             </includes>
  14.             <excludes>
  15.                 <exclude>happy.properties</exclude>
  16.             </excludes>
  17.         </resource>
  18.     </resources>
  19. </build>

执行处理资源命令：

mvn clean resources:resources -PdevJDBCProfile

执行效果如下：
image.png
当然我们这里只是以 properties 文件为例，并不是只能处理 properties 文件。

第十章 生产实践

一、搭建 Maven 私服：Nexus

1、Nexus 安装

①下载地址

小诀窍：使用迅雷下载比直接用浏览器下载快很多
https://download.sonatype.com/nexus/3/latest-unix.tar.gz

②上传、解压

上传到 Linux 系统，解压后即可使用，不需要安装。但是需要注意：必须提前安装 JDK。

[root@x nexus-3.37.0-01]# ll
总用量 96
drwxr-xr-x. 3 root root 4096 2月 13 17:33 bin
drwxr-xr-x. 2 root root 4096 2月 13 17:33 deploy
drwxr-xr-x. 7 root root 4096 2月 13 17:33 etc
drwxr-xr-x. 5 root root 4096 2月 13 17:33 lib
-rw-r—r—. 1 root root 651 11月 20 01:40 NOTICE.txt
-rw-r—r—. 1 root root 17321 11月 20 01:40 OSS-LICENSE.txt
-rw-r—r—. 1 root root 41954 11月 20 01:40 PRO-LICENSE.txt
drwxr-xr-x. 3 root root 4096 2月 13 17:33 public
drwxr-xr-x. 3 root root 4096 2月 13 17:33 replicator
drwxr-xr-x. 23 root root 4096 2月 13 17:33 system

③启动 Nexus

[root@x ~]# /opt/nexus-3.37.0-01/bin/nexus start
WARNING: **
WARNING: Detected execution as “root” user. This is NOT recommended!
WARNING: **
Starting nexus
[root@x ~]# /opt/nexus-3.37.0-01/bin/nexus status
WARNING: **
WARNING: Detected execution as “root” user. This is NOT recommended!
WARNING: **
nexus is running.

④查看端口占用情况

[root@x ~]# netstat -anp | grep java
tcp 0 0 127.0.0.1:45614 0.0.0.0: LISTEN 9872/java
tcp 0 0 0.0.0.0:8081 0.0.0.0: LISTEN 9872/java

上面 45614 这个每次都不一样，不用管它。我们要访问的是 8081 这个端口。但是需要注意：8081 端口的这个进程要在启动 /opt/nexus-3.37.0-01/bin/nexus 这个主体程序一、两分钟后才会启动，请耐心等待。

⑤访问 Nexus 首页

首页地址：http://[Linux 服务器地址]:8081/
初始化界面还是很酷的：
image.png

2、初始设置

image.png
image.png
这里参考提示：

  • 用户名：admin
  • 密码：查看 /opt/sonatype-work/nexus3/admin.password 文件

[root@hello ~]# cat /opt/sonatype-work/nexus3/admin.password
ed5e96a8-67aa-4dca-9ee8-1930b1dd5415
所以登录信息输入如下：
image.png
继续执行初始化：
image.png
给 admin 用户指定新密码：
image.png
匿名登录，启用还是禁用？由于启用匿名登录后，后续操作比较简单，这里我们演示禁用匿名登录的操作方式：
image.png
完成：
image.png

3、对接 Nexus

①通过 Nexus 下载 jar 包

[1]了解 Nexus 上的各种仓库

image.png

仓库类型 说明
proxy 某个远程仓库的代理
group 存放：通过 Nexus 获取的第三方 jar 包
hosted 存放：本团队其他开发人员部署到 Nexus 的 jar 包
仓库名称 说明
maven-central Nexus 对 Maven 中央仓库的代理
maven-public Nexus 默认创建，供开发人员下载使用的组仓库
maven-releasse Nexus 默认创建，供开发人员部署自己 jar 包的宿主仓库
要求 releasse 版本
maven-snapshots Nexus 默认创建，供开发人员部署自己 jar 包的宿主仓库
要求 snapshots 版本

初始状态下，这几个仓库都没有内容：
image.png

[2]使用空的本地仓库

image.png

  1.   <!-- 配置一个新的 Maven 本地仓库 -->
  2.   <localRepository>D:/maven-repository-new</localRepository>

[3]指定 Nexus 服务器地址

把我们原来配置阿里云仓库地址的 mirror 标签改成下面这样：

  1. <mirror>
  2.     <id>nexus-mine</id>
  3.     <mirrorOf>central</mirrorOf>
  4.     <name>Nexus mine</name>
  5.     <url>http://192.168.198.100:8081/repository/maven-public/</url>
  6. </mirror>

这里的 url 标签是这么来的：
image.png

image.png
把上图中看到的地址复制出来即可。如果我们在前面允许了匿名访问，到这里就够了。但如果我们禁用了匿名访问，那么接下来我们还要继续配置 settings.xml：

  1. <server>
  2.   <id>nexus-mine</id>
  3.   <username>admin</username>
  4.   <password>atguigu</password>
  5. </server>

这里需要格外注意：server 标签内的 id 标签值必须和 mirror 标签中的 id 值一样。

[4]效果

找一个用到框架的 Maven 工程，执行命令：

mvn clean compile

下载过程日志：

Downloading from nexus-mine: http://192.168.198.100:8081/repository/maven-public/com/jayway/jsonpath/json-path/2.4.0/json-path-2.4.0.pom
Downloaded from nexus-mine: http://192.168.198.100:8081/repository/maven-public/com/jayway/jsonpath/json-path/2.4.0/json-path-2.4.0.pom (2.6 kB at 110 kB/s)
Downloading from nexus-mine: http://192.168.198.100:8081/repository/maven-public/net/minidev/json-smart/2.3/json-smart-2.3.pom
Downloaded from nexus-mine: http://192.168.198.100:8081/repository/maven-public/net/minidev/json-smart/2.3/json-smart-2.3.pom (9.0 kB at 376 kB/s)
Downloading from nexus-mine: http://192.168.198.100:8081/repository/maven-public/net/minidev/minidev-parent/2.3/minidev-parent-2.3.pom
Downloaded from nexus-mine: http://192.168.198.100:8081/repository/maven-public/net/minidev/minidev-parent/2.3/minidev-parent-2.3.pom (8.5 kB at 404 kB/s)
Downloading from nexus-mine: http://192.168.198.100:8081/repository/maven-public/net/minidev/accessors-smart/1.2/accessors-smart-1.2.pom
Downloaded from nexus-mine: http://192.168.198.100:8081/repository/maven-public/net/minidev/accessors-smart/1.2/accessors-smart-1.2.pom (12 kB at 463 kB/s)

下载后，Nexus 服务器上就有了 jar 包：
image.png

②将 jar 包部署到 Nexus

[1]配置 Maven 工程
  1. <distributionManagement>
  2.     <snapshotRepository>
  3.         <id>nexus-mine</id>
  4.         <name>Nexus Snapshot</name>
  5.         <url>http://192.168.198.100:8081/repository/maven-snapshots/</url>
  6.     </snapshotRepository>
  7. </distributionManagement>

这里 snapshotRepository 的 id 标签也必须和 settings.xml 中指定的 mirror 标签的 id 属性一致。

[2]执行部署命令

mvn deploy

Uploading to nexus-mine: http://192.168.198.100:8081/repository/maven-snapshots/com/atguigu/demo/demo07-redis-data-provider/1.0-SNAPSHOT/maven-metadata.xml
Uploaded to nexus-mine: http://192.168.198.100:8081/repository/maven-snapshots/com/atguigu/demo/demo07-redis-data-provider/1.0-SNAPSHOT/maven-metadata.xml (786 B at 19 kB/s)
Uploading to nexus-mine: http://192.168.198.100:8081/repository/maven-snapshots/com/atguigu/demo/demo07-redis-data-provider/maven-metadata.xml
Uploaded to nexus-mine: http://192.168.198.100:8081/repository/maven-snapshots/com/atguigu/demo/demo07-redis-data-provider/maven-metadata.xml (300 B at 6.5 kB/s)
[INFO] ————————————————————————————————————
[INFO] Reactor Summary:
[INFO]
[INFO] demo-imperial-court-ms-show 1.0-SNAPSHOT ……….. SUCCESS [ 1.875 s]
[INFO] demo09-base-entity …………………………… SUCCESS [ 21.883 s]
[INFO] demo10-base-util …………………………….. SUCCESS [ 0.324 s]
[INFO] demo08-base-api ……………………………… SUCCESS [ 1.171 s]
[INFO] demo01-imperial-court-gateway …………………. SUCCESS [ 0.403 s]
[INFO] demo02-user-auth-center ………………………. SUCCESS [ 2.932 s]
[INFO] demo03-emp-manager-center …………………….. SUCCESS [ 0.312 s]
[INFO] demo04-memorials-manager-center ……………….. SUCCESS [ 0.362 s]
[INFO] demo05-working-manager-center …………………. SUCCESS [ 0.371 s]
[INFO] demo06-mysql-data-provider ……………………. SUCCESS [ 6.779 s]
[INFO] demo07-redis-data-provider 1.0-SNAPSHOT ………… SUCCESS [ 0.273 s]

image.png

③引用别人部署的 jar 包

[1]提出问题
  • 默认访问的 Nexus 仓库：maven-public

  • 存放别人部署 jar 包的仓库：maven-snapshots

    [2]配置 Maven 工程
    1. <repositories>
    2.   <repository>
    3.       <id>nexus-mine</id>
    4.       <name>nexus-mine</name>
    5.       <url>http://192.168.198.100:8081/repository/maven-snapshots/</url>
    6.       <snapshots>
    7.           <enabled>true</enabled>
    8.       </snapshots>
    9.       <releases>
    10.           <enabled>true</enabled>
    11.       </releases>
    12.   </repository>
    13. </repositories>

    4、修改仓库配置

    举例：修改 maven-central 仓库代理的远程库地址
    image.png
    image.png
    image.png

    二、jar包冲突问题

    1、谁需要面对 jar 包冲突？

    先给结论：编订依赖列表的程序员。初次设定一组依赖，因为尚未经过验证，所以确实有可能存在各种问题，需要做有针对性的调整。那么谁来做这件事呢？我们最不希望看到的就是：团队中每个程序员都需要自己去找依赖，即使是做同一个项目，每个模块也各加各的依赖，没有统一管理。那前人踩过的坑，后人还要再踩一遍。而且大家用的依赖有很多细节都不一样，版本更是五花八门，这就让事情变得更加复杂。
    所以虽然初期需要根据项目开发和实际运行情况对依赖配置不断调整，最终确定一个各方面都 OK 的版本。但是一旦确定下来，放在父工程中做依赖管理，各个子模块各取所需，这样基本上就能很好的避免问题的扩散。
    即使开发中遇到了新问题，也可以回到源头检查、调整 dependencyManagement 配置的列表——而不是每个模块都要改。所以学完这一节你应该就会对前面讲过的『继承』有了更深的理解。

    2、表现形式

    由于实际开发时我们往往都会整合使用很多大型框架，所以一个项目中哪怕只是一个模块也会涉及到大量 jar 包。数以百计的 jar 包要彼此协调、精密配合才能保证程序正常运行。而规模如此庞大的 jar 包组合在一起难免会有磕磕碰碰。最关键的是由于 jar 包冲突所导致的问题非常诡异，这里我们只能罗列较为典型的问题，而没法保证穷举。
    但是我们仍然能够指出一点：一般来说，由于我们自己编写代码、配置文件写错所导致的问题通常能够在异常信息中看到我们自己类的全类名或配置文件的所在路径。如果整个错误信息中完全没有我们负责的部分，全部是框架、第三方工具包里面的类报错，这往往就是 jar 包的问题所引起的。
    而具体的表现形式中，主要体现为找不到类或找不到方法。

    ①抛异常：找不到类

    此时抛出的常见的异常类型：

  • java.lang.ClassNotFoundException：编译过程中找不到类

  • java.lang.NoClassDefFoundError：运行过程中找不到类
  • java.lang.LinkageError：不同类加载器分别加载的多个类有相同的全限定名

我们来举个例子：

  1. <dependency>
  2.     <groupId>org.apache.httpcomponents</groupId>
  3.     <artifactId>httpclient</artifactId>
  4.     <version>4.x.x</version>
  5. </dependency>

httpclient 这个 jar 包中有一个类：org.apache.http.conn.ssl.NoopHostnameVerifier。这个类在较低版本中没有，但在较高版本存在。比如：

jar 包版本 是否存在
4.3.6 否
4.4 是

那当我们确实需要用到 NoopHostnameVerifier 这个类，我们看到 Maven 通过依赖传递机制引入了这个 jar 包，所以没有明确地显式声明对这个 jar 包的依赖。可是 Maven 传递过来的 jar 包是 4.3.6 版本，里面没有包含我们需要的类，就会抛出异常。
而『冲突』体现在：4.3.6 和 4.4 这两个版本的 jar 包都被框架所依赖的 jar 包给传递进来了，但是假设 Maven 根据『版本仲裁』规则实际采纳的是 4.3.6。

②抛异常：找不到方法

程序找不到符合预期的方法。这种情况多见于通过反射调用方法，所以经常会导致：java.lang.NoSuchMethodError。比如 antlr:antlr:x.x.x 这个包中有一个接口：antlr.collections.AST

版本 getLine()方法
2.7.2 无
2.7.6 有

③没报错但结果不对

发生这种情况比较典型的原因是：两个 jar 包中的类分别实现了同一个接口，这本来是很正常的。但是问题在于：由于没有注意命名规范，两个不同实现类恰巧是同一个名字。
image.png
具体例子是有的同学在实际工作中遇到过：项目中部分模块使用 log4j 打印日志；其它模块使用 logback，编译运行都不会冲突，但是会引起日志服务降级，让你的 log 配置文件失效。比如：你指定了 error 级别输出，但是冲突就会导致 info、debug 都在输出。

3、本质

以上表现形式归根到底是两种基本情况导致的：

①同一jar包的不同版本

image.png

②不同jar包中包含同名类

这里我们拿 netty 来举个例子，netty 是一个类似 Tomcat 的 Servlet 容器。通常我们不会直接依赖它，所以基本上都是框架传递进来的。那么当我们用到的框架很多时，就会有不同的框架用不同的坐标导入 netty。大家可以参照下表对比一下两组坐标：

截止到3.2.10.Final版本以前的坐标形式： 从3.3.0.Final版本开始以后的坐标形式：

org.jboss.netty
netty
3.2.10.Final
io.netty
netty
3.9.2.Final

但是偏偏这两个『不同的包』里面又有很多『全限定名相同』的类。例如：

org.jboss.netty.channel.socket.ServerSocketChannelConfig.class org.jboss.netty.channel.socket.nio.NioSocketChannelConfig.class org.jboss.netty.util.internal.jzlib.Deflate.class org.jboss.netty.handler.codec.serialization.ObjectDecoder.class org.jboss.netty.util.internal.ConcurrentHashMap$HashIterator.class org.jboss.netty.util.internal.jzlib.Tree.class org.jboss.netty.util.internal.ConcurrentIdentityWeakKeyHashMap$Segment.class org.jboss.netty.handler.logging.LoggingHandler.class org.jboss.netty.channel.ChannelHandlerLifeCycleException.class org.jboss.netty.util.internal.ConcurrentIdentityHashMap$ValueIterator.class org.jboss.netty.util.internal.ConcurrentIdentityWeakKeyHashMap$Values.class org.jboss.netty.util.internal.UnterminatableExecutor.class org.jboss.netty.handler.codec.compression.ZlibDecoder.class org.jboss.netty.handler.codec.rtsp.RtspHeaders$Values.class org.jboss.netty.handler.codec.replay.ReplayError.class org.jboss.netty.buffer.HeapChannelBufferFactory.class ……

其实还有很多，这里列出的只是冰山一角。
当然，如果全限定名相同，类中的代码也完全相同，那么用着也行。问题是如果『全限定名相同』，但是『代码不同』，那可太坑了。我们随便找一个来看看：

坐标信息：org.jboss.netty:netty:jar:3.2.10.Final
代码截图：
image.png
坐标信息：io.netty:netty:jar:3.9.2.Final
代码截图：
image.png

4、解决办法

①概述

很多情况下常用框架之间的整合容易出现的冲突问题都有人总结过了，拿抛出的异常搜索一下基本上就可以直接找到对应的 jar 包。我们接下来要说的是通用方法。
不管具体使用的是什么工具，基本思路无非是这么两步：

  • 第一步：把彼此冲突的 jar 包找到

  • 第二步：在冲突的 jar 包中选定一个。具体做法无非是通过 exclusions 排除依赖，或是明确声明依赖。

    ②IDEA 的 Maven Helper 插件

    这个插件是 IDEA 中安装的插件，不是 Maven 插件。它能够给我们罗列出来同一个 jar 包的不同版本，以及它们的来源。但是对不同 jar 包中同名的类没有办法。

  • 在 IDEA 中安装 Maven helper 插件。

  • 基于 pom.xml 的依赖冲突分析。

    ③Maven 的 enforcer 插件

    使用 Maven 的 enforcer 插件既可以检测同一个 jar 包的不同版本，又可以检测不同 jar 包中同名的类。

    [1]引入 netty 依赖

    这里我们引入两个对 netty 的依赖，展示不同 jar 包中有同名类的情况。

    1. <dependencies>
    2.   <dependency>
    3.       <groupId>org.jboss.netty</groupId>
    4.       <artifactId>netty</artifactId>
    5.       <version>3.2.10.Final</version>
    6.   </dependency>
    8.   <dependency>
    9.       <groupId>io.netty</groupId>
    10.       <artifactId>netty</artifactId>
    11.       <version>3.9.2.Final</version>
    12.   </dependency>
    13. </dependencies>

    [2]配置 enforcer 插件
    1. <build>
    2.   <pluginManagement>
    3.       <plugins>
    4.           <plugin>
    5.               <groupId>org.apache.maven.plugins</groupId>
    6.               <artifactId>maven-enforcer-plugin</artifactId>
    7.               <version>1.4.1</version>
    8.               <executions>
    9.                   <execution>
    10.                       <id>enforce-dependencies</id>
    11.                       <phase>validate</phase>
    12.                       <goals>
    13.                           <goal>display-info</goal>
    14.                           <goal>enforce</goal>
    15.                       </goals>
    16.                   </execution>
    17.               </executions>
    18.               <dependencies>
    19.                   <dependency>
    20.                       <groupId>org.codehaus.mojo</groupId>
    21.                       <artifactId>extra-enforcer-rules</artifactId>
    22.                       <version>1.0-beta-4</version>
    23.                   </dependency>
    24.               </dependencies>
    25.               <configuration>
    26.                   <rules>
    27.                       <banDuplicateClasses>
    28.                           <findAllDuplicates>true</findAllDuplicates>
    29.                       </banDuplicateClasses>
    30.                   </rules>
    31.               </configuration>
    32.           </plugin>
    33.       </plugins>
    34.   </pluginManagement>
    35. </build>

    [3]测试

    执行如下 Maven 命令：

    mvn clean package enforcer:enforce

    部分运行结果：

    [INFO] —- maven-enforcer-plugin:1.4.1:enforce (default-cli) @ pro32-duplicate-class —-
    [WARNING] Rule 0: org.apache.maven.plugins.enforcer.BanDuplicateClasses failed with message:
    Duplicate classes found:

Found in:
io.netty:netty:jar:3.9.2.Final:compile
org.jboss.netty:netty:jar:3.2.10.Final:compile
Duplicate classes:
org/jboss/netty/channel/socket/ServerSocketChannelConfig.class
org/jboss/netty/channel/socket/nio/NioSocketChannelConfig.class
org/jboss/netty/util/internal/jzlib/Deflate.class
org/jboss/netty/handler/codec/serialization/ObjectDecoder.class
org/jboss/netty/util/internal/ConcurrentHashMap$HashIterator.class

……

三、体系外 jar 包引入

1、提出问题

『体系外 jar 包』这个名字是我起的，来源是这样——目前来说我们在 Maven 工程中用到的 jar 包都是通过 Maven 本身的机制导入进来的。
而实际开发中确实有可能用到一些 jar 包并非是用 Maven 的方式发布，那自然也没法通过 Maven 导入。
此时如果我们能够拿到该 jar 包的源码那还可以自己建一个 Maven 工程，自己打包。可是如果连源码都没有呢？
这方面的例子包括一些人脸识别用的 jar 包、海康视频监控 jar 包等等。

2、解决办法

①准备一个体系外 jar 包

我们通过学 Maven 以前的方式创建一个 Java 工程，然后导出 jar 包即可用来测试。
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png

②将该 jar 包安装到 Maven 仓库

这里我们使用 install 插件的 install-file 目标：

mvn install:install-file -Dfile=[体系外 jar 包路径] \ -DgroupId=[给体系外 jar 包强行设定坐标] \ -DartifactId=[给体系外 jar 包强行设定坐标] \ -Dversion=1 \ -Dpackage=jar

例如（Windows 系统下使用 ^ 符号换行；Linux 系统用 \）：

mvn install:install-file -Dfile=D:\idea2019workspace\atguigu-maven-outer\out\artifacts\atguigu_maven_outer\atguigu-maven-outer.jar ^ -DgroupId=com.atguigu.maven ^ -DartifactId=atguigu-maven-outer ^ -Dversion=1 ^ -Dpackaging=jar

执行结果：
image.png
再看本地仓库中确实有：
image.png
我们打开 POM 文件看看：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  4.   <modelVersion>4.0.0</modelVersion>
  5.   <groupId>com.atguigu.maven</groupId>
  6.   <artifactId>atguigu-maven-outer</artifactId>
  7.   <version>1</version>
  8.   <description>POM was created from install:install-file</description>
  9. </project>

③测试

在其它地方依赖这个 jar 包：

  1. <dependency>
  2.     <groupId>com.atguigu.maven</groupId>
  3.     <artifactId>atguigu-maven-outer</artifactId>
  4.     <version>1</version>
  5. </dependency>

创建对象、调用方法：
image.png