Maven入门到进阶：构建、依赖与插件管理详解

news2024/10/21 22:00:06

文章目录

  • 一、Maven介绍
    • 1、什么是Maven
    • 2、Maven的核心功能
  • 二、Maven核心概念
    • 1、坐标GAVP
      • 1.1、GroupId
      • 1.2、ArtifactId
      • 1.3、Version
        • 1.3.1、版本号的组成
      • 1.4、Packaging
    • 2、POM、父POM和超级POM
      • 2.1、POM (Project Object Model)
      • 2.1、父POM（Parent POM）
      • 2.3、超级POM（Super POM）
      • 2.4、有效POM（Effective POM）
        • 2.4.1、如何查看有效POM？
        • 2.4.2、有效POM的用途
  • 三、Maven依赖管理
    • 1、依赖范围
      • 1.1、compile（编译范围）
      • 1.2、provided（已提供范围）
      • 1.3、runtime（运行时范围）
      • 1.4、test（测试范围）
      • 1.5、system（系统范围）
      • 1.6、import（导入范围）
    • 2、依赖传递
      • 2.1、依赖传递的作用范围
      • 2.2、可选依赖
      • 2.3、依赖冲突与版本控制
  • 四、Maven工程构建
    • 1、生命周期
    • 2、构建命令
      • 2.1、常见组合命令
      • 2.2、命令选项
    • 3、插件
      • 3.1、Maven默认的插件
      • 3.2、生成微服务可运行jar包
        • 3.2.1、添加spring-boot-maven-plugin插件后的打包流程
        • 3.2.2、常规打包方式
        • 3.2.3、进阶打包方式
      • 3.3、\<resources>标签
  • 五、Maven继承和聚合
    • 1、继承
      • 1.1、父项目的pom.xml
      • 1.2、子项目pom.xml
        • 1.2.1、\<relativePath>标签
    • 2、聚合
  • 五、Maven仓库
    • 1、Maven仓库
      • 1.1、本地仓库（Local Repository）
      • 1.2、中央仓库（Central Repository）
      • 1.3、远程仓库（Remote Repository）
      • 1.4、Maven仓库的工作原理
    • 2、Maven私服
      • 2.1、Nexus仓库
      • 2.2、通过Nexus下载jar包
      • 2.3、将jar包部署到Nexus
    • 3、repositories和mirrors
      • 3.1、repositories(仓库)
      • 3.2、mirrors(镜像)

一、Maven介绍

1、什么是Maven

  Maven是Apache软件基金会开发的一款项目管理和构建工具，主要用于Java 项目的构建、依赖管理和项目生命周期管理。Maven通过声明性配置（XML 文件）定义项目构建流程及依赖项，使得项目管理更简单、更高效，特别适合于多模块、大型项目。

2、Maven的核心功能

  • 依赖管理：自动解析、下载和管理项目所需的外部依赖库，避免手动查找和添加 JAR 包
  • 构建管理：通过标准化的构建生命周期（例如 clean、compile、test、package、install、deploy），帮助用户自动化地编译代码、运行测试、打包成JAR/WAR包等
  • 插件扩展：Maven 拥有丰富的插件生态系统，能够扩展构建过程中的功能，包括代码质量检查、测试覆盖率报告、打包部署等
  • 项目统一管理：Maven允许通过父子项目、聚合项目等结构，统一管理多模块项目，使团队协作更高效

二、Maven核心概念

1、坐标GAVP

  在Maven中，GAVP是构建项目的四个核心属性的缩写，分别代表GroupId、ArtifactId、Version和Packaging。这四个属性在pom.xml文件中定义，用于唯一标识一个Maven项目或依赖。

1.1、GroupId

  • 定义：项目或组件的组ID，通常表示项目所在的组织、公司或团队
  • 用途：帮助区分不同的项目组和模块。GroupId通常以域名倒置的格式（如com.example）命名，以避免命名冲突
  • 示例：
    <groupId>com.example</groupId>

1.2、ArtifactId

  • 定义：项目或模块的标识符，是项目的名称或模块名称，通常是小写的、简短的名称
  • 用途：用于唯一标识项目中的某个模块。通常一个项目会有多个模块，每个模块的ArtifactId都是唯一的
  • 示例：
    <artifactId>my-app</artifactId>

1.3、Version

  • 定义：项目的版本号，通常遵循语义化版本号（如1.0.0、1.0-SNAPSHOT等）
  • 用途：帮助区分不同版本的构件。Maven支持SNAPSHOT版本（用于开发阶段）和RELEASE版本（用于发布的稳定版本）
  • 示例：
    <version>1.0.0</version>
1.3.1、版本号的组成
  • Maven的版本号通常由主版本号、次版本号、补丁版本号和标识符组成。其基本格式如下：
<major>.<minor>.<patch>-<qualifier>
  • 主版本号 (Major Version)
    • 作用: 主版本号在项目发生重大更改，可能导致向后不兼容时会更新。例如，修改了API接口或删除了某些功能，升级主版本号
    • 示例: 1.0.0 → 2.0.0
  • 次版本号 (Minor Version)
    • 作用: 次版本号通常表示项目有了新功能，但向后兼容。例如，增加了新功能，但不影响现有功能的使用
    • 示例: 1.0.0 → 1.1.0
  • 补丁版本号 (Patch Version)
    • 作用: 补丁版本号通常用于修复错误或进行小的改进，确保向后兼容
    • 示例: 1.0.0 → 1.0.1
  • 标识符 (Qualifier)
    • 作用: 标识符用于标识预发布版本或特殊版本，比如快照版本、测试版或里程碑版本
    • 常见的附加标识符有以下几种
附加标识符含义适用阶段示例
SNAPSHOT开发中的不稳定版本，尚未发布开发过程1.0.0-SNAPSHOT
ALPHA早期测试版本，可能包含较多 bug，功能未完全实现内部测试1.0.0-ALPHA
BETA稳定性较高的测试版本，功能基本完成公开测试1.0.0-BETA
RC候选发布版本，接近正式版本发布前测试1.0.0-RC1
M里程碑版本，标志关键特性的阶段性完成项目阶段性成果1.0.0-M1
GA正式发布版本，供所有用户使用正式发布1.0.0-GA
FINAL最终稳定版本，适合大规模使用正式发布1.0.0-FINAL
HOTFIX紧急修复版本，快速解决严重问题紧急修复1.0.1-HOTFIX
DEV开发版本，类似于 SNAPSHOT开发过程1.0.0-DEV
CUSTOM定制版本，针对特定客户或项目需求定制化发布1.0.0-CUSTOM
PREVIEW预览版本，展示即将发布的功能用户或客户展示1.0.0-PREVIEW
CANARY实验版，用于有限发布和生产环境验证实验性发布1.0.0-CANARY
EAPEarly Access Program，早期访问版内部或有限外部访问1.0.0-EAP
NIGHTLY每晚构建的版本，通常用于开发中的自动化测试开发过程1.0.0-NIGHTLY
STAGING预发布版本，通常用于发布到生产环境前的测试预生产环境1.0.0-STAGING
TEST用于测试目的的版本，可能包含调试信息内部测试1.0.0-TEST
INTEGRATION用于集成测试的版本集成测试1.0.0-INTEGRATION
DEMO演示版本，通常用于客户或内部展示展示用途1.0.0-DEMO
EXPERIMENTAL实验版本，包含实验性功能或不稳定的更改开发测试1.0.0-EXPERIMENTAL
LTS长期支持版本，通常包含稳定且经验证的功能正式发布1.0.0-LTS
RELEASE稳定的正式发布版本，类似于 GA 和 FINAL正式发布1.0.0-RELEASE
ROLLOUT渐进式发布版本，逐步向用户推广渐进式发布1.0.0-ROLLOUT
PATCH小型补丁版本，用于特定问题的快速修复快速修复1.0.1-PATCH
  • snapshot表示快照版，它不是个稳定版本，属于开发过程中使用的版本
  • 当一个项目开发完成后，就会进入测试版本，而测试版本一般会分为内部测试alpha版、外部测试beta版两种
  • 当测试通过后，将会进入正式版本，大部分的正式版是啥也不带，就一个单纯的版本号，比如1.0、1.7.1等。也有个别的是这些rc、final、release、ga等

1.4、Packaging

  • 定义：指定项目的打包类型，决定了Maven最终生成的文件格式
  • 常见的打包类型：
    • jar：用于生成Java的jar文件
    • war：用于生成Web应用的war文件
    • pom：通常用于父项目或聚合项目，表示该项目不会打包成可执行文件，而是用于组织多个模块
  • 示例：
    <packaging>jar</packaging>

2、POM、父POM和超级POM

2.1、POM (Project Object Model)

  POM是Maven项目的核心文件，通常命名为pom.xml，包含了项目的配置信息、依赖关系、插件、构建设置等。每个Maven项目都需要一个POM文件，它决定了如何构建和管理项目。

以下是一个详细的 pom.xml 样例：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                             http://maven.apache.org/maven-v4_0_0.xsd">
    <!-- modelVersion: 定义 POM 文件的版本，通常为 4.0.0 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- groupId: 项目的组 ID，通常是项目所在组织的域名反转形式 -->
    <groupId>com.example</groupId>

    <!-- artifactId: 项目的标识符，通常是项目的名称 -->
    <artifactId>my-app</artifactId>

    <!-- version: 项目的版本号 -->
    <version>1.0.0</version>

    <!-- packaging: 打包类型，默认为 jar。其他值可以是 war、pom 等 -->
    <packaging>jar</packaging>

    <!-- name: 项目的名称（可选） -->
    <name>My Application</name>

    <!-- description: 项目的简短描述（可选） -->
    <description>This is my first Maven project.</description>

    <!-- url: 项目主页的 URL（可选） -->
    <url>http://www.example.com/my-app</url>

    <!-- licenses: 项目使用的许可证信息 -->
    <licenses>
        <license>
            <name>Apache License, Version 2.0</name>
            <url>http://www.apache.org/licenses/LICENSE-2.0</url>
            <distribution>repo</distribution>
        </license>
    </licenses>

    <!-- developers: 项目的开发人员信息 -->
    <developers>
        <developer>
            <id>johndoe</id>
            <name>John Doe</name>
            <email>johndoe@example.com</email>
            <organization>Example Org</organization>
            <roles>
                <role>developer</role>
            </roles>
        </developer>
    </developers>

    <!-- dependencies: 定义项目依赖的外部库 -->
    <dependencies>
        <dependency>
            <!-- groupId: 依赖的组 ID -->
            <groupId>org.springframework</groupId>
            <!-- artifactId: 依赖的标识符 -->
            <artifactId>spring-core</artifactId>
            <!-- version: 依赖的版本 -->
            <version>5.2.9.RELEASE</version>
            <!-- scope: 依赖的作用范围，默认为 compile，还可以是 test、provided、runtime 等 -->
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope> <!-- 仅在测试阶段使用 -->
        </dependency>
    </dependencies>

    <!-- build: 构建配置，如插件、资源等 -->
    <build>
        <plugins>
            <plugin>
                <!-- 编译插件 -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!-- 设置 Java 编译版本 -->
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <plugin>
                <!-- 测试报告生成插件 -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
            </plugin>
        </plugins>
    </build>

    <!-- properties: 项目属性，通常用来定义全局变量 -->
    <properties>
        <!-- Maven 编译器的 Java 源代码版本 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <!-- repositories: 自定义 Maven 仓库 -->
    <repositories>
        <repository>
            <id>central</id>
            <name>Maven Central Repository</name>
            <url>https://repo.maven.apache.org/maven2</url>
        </repository>
    </repositories>

    <!-- profiles: 定义构建配置的不同环境 -->
    <profiles>
        <profile>
            <id>development</id>
            <properties>
                <!-- 开发环境专用属性 -->
                <maven.compiler.source>11</maven.compiler.source>
            </properties>
        </profile>

        <profile>
            <id>production</id>
            <properties>
                <!-- 生产环境专用属性 -->
                <maven.compiler.source>1.8</maven.compiler.source>
            </properties>
        </profile>
    </profiles>
</project>

2.1、父POM（Parent POM）

  父POM文件位于项目的根目录，通常用于多模块项目的配置。它包含公共依赖项、插件版本、构建配置等，供子模块继承。父POM可以被称为“聚合POM”或“根POM”，并且会定义<modules>标签来指定所有子模块。

以下是一个详细的父pom.xml 样例：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                             http://maven.apache.org/maven-v4_0_0.xsd">
    <!-- modelVersion: 定义 POM 文件的版本，通常为 4.0.0 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- groupId: 定义父 POM 的组 ID -->
    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0.0</version>

    <!-- packaging: 父 POM 一般使用 pom 作为打包类型 -->
    <packaging>pom</packaging>

    <!-- modules: 定义子模块 -->
    <modules>
        <module>module-one</module>
        <module>module-two</module>
    </modules>

    <!-- properties: 定义共享的属性，用于子项目继承 -->
    <properties>
        <!-- 定义所有模块的全局 Java 编译器版本 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!-- 项目版本定义，可供子模块继承使用 -->
        <spring.version>5.2.9.RELEASE</spring.version>
        <junit.version>4.13.1</junit.version>
    </properties>

    <!-- dependencyManagement: 用于管理子模块的依赖版本 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- build: 配置构建相关信息 -->
    <build>
        <plugins>
            <plugin>
                <!-- maven-compiler-plugin 插件，用于设置编译器版本 -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${maven.compiler.source}</source>
                    <target>${maven.compiler.target}</target>
                </configuration>
            </plugin>

            <plugin>
                <!-- maven-surefire-plugin 插件，用于执行单元测试 -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
            </plugin>
        </plugins>
    </build>

    <!-- profiles: 用于定义不同环境下的构建配置 -->
    <profiles>
        <profile>
            <id>development</id>
            <properties>
                <!-- 开发环境中使用 Java 11 -->
                <maven.compiler.source>11</maven.compiler.source>
                <maven.compiler.target>11</maven.compiler.target>
            </properties>
        </profile>
        <profile>
            <id>production</id>
            <properties>
                <!-- 生产环境中使用 Java 8 -->
                <maven.compiler.source>1.8</maven.compiler.source>
                <maven.compiler.target>1.8</maven.compiler.target>
            </properties>
        </profile>
    </profiles>

    <!-- repositories: 定义自定义 Maven 仓库 -->
    <repositories>
        <repository>
            <id>central</id>
            <url>https://repo.maven.apache.org/maven2</url>
        </repository>
    </repositories>
</project>

2.3、超级POM（Super POM）

  超级POM是Maven提供的默认全局POM文件，所有的Maven项目都会隐式继承这个超级POM。它是Maven的顶级POM，定义了Maven项目构建的默认行为。即使项目没有显式指定任何父POM，它也会自动继承超级POM中的基本设置。

  超级pom定义在maven-model-builder.jar中，如果想查看其定义，需要将jar包解压，解压后超级pom的完整路径为： maven 安装目录\lib\maven-model-builder-3.8.6.jar\org\apache\maven\model\pom-4.0.0.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<project>
  <!-- 定义 POM 文件的版本，通常为 4.0.0 -->
  <modelVersion>4.0.0</modelVersion>

  <!-- repositories 元素定义 Maven 用于解析依赖的仓库 -->
  <repositories>
    <repository>
      <!-- id 是仓库的唯一标识符，代表 Maven Central 仓库 -->
      <id>central</id>
      <!-- name 是仓库的名称，描述性字段 -->
      <name>Central Repository</name>
      <!-- url 定义了仓库的网络地址 -->
      <url>https://repo.maven.apache.org/maven2</url>
      <!-- layout 定义了仓库的布局，默认为 default -->
      <layout>default</layout>
      <snapshots>
        <!-- 禁用从该仓库下载快照版本 -->
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

  <!-- pluginRepositories 元素用于定义 Maven 插件的仓库 -->
  <pluginRepositories>
    <pluginRepository>
      <!-- 插件仓库的唯一标识符，与普通仓库类似 -->
      <id>central</id>
      <!-- 仓库的名称 -->
      <name>Central Repository</name>
      <!-- 仓库的 URL 地址 -->
      <url>https://repo.maven.apache.org/maven2</url>
      <!-- 仓库的布局，默认值为 default -->
      <layout>default</layout>
      <snapshots>
        <!-- 禁用快照版本的插件下载 -->
        <enabled>false</enabled>
      </snapshots>
      <releases>
        <!-- 定义如何更新发布版本的策略，never 表示从不更新 -->
        <updatePolicy>never</updatePolicy>
      </releases>
    </pluginRepository>
  </pluginRepositories>

  <!-- build 元素定义了构建过程中的目录、插件和资源管理 -->
  <build>
    <!-- 定义编译输出的目录，通常为 target 文件夹 -->
    <directory>${project.basedir}/target</directory>
    <!-- 定义编译后的类文件的输出目录 -->
    <outputDirectory>${project.build.directory}/classes</outputDirectory>
    <!-- 定义构建输出文件的最终名称，通常包括 artifactId 和版本号 -->
    <finalName>${project.artifactId}-${project.version}</finalName>
    <!-- 定义测试编译后的输出目录 -->
    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
    <!-- Java 源代码的目录，默认为 src/main/java -->
    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
    <!-- 脚本源文件的目录 -->
    <scriptSourceDirectory>${project.basedir}/src/main/scripts</scriptSourceDirectory>
    <!-- 测试源代码的目录，默认为 src/test/java -->
    <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
    <!-- 定义项目的主资源文件目录，通常用于配置文件等 -->
    <resources>
      <resource>
        <directory>${project.basedir}/src/main/resources</directory>
      </resource>
    </resources>
    <!-- 定义测试资源文件目录 -->
    <testResources>
      <testResource>
        <directory>${project.basedir}/src/test/resources</directory>
      </testResource>
    </testResources>

    <!-- pluginManagement 元素管理所有的插件版本和配置，供子项目继承 -->
    <pluginManagement>
      <!-- NOTE: 以下插件将在未来版本的超级 POM 中移除 -->
      <plugins>
        <!-- 定义了 maven-antrun-plugin 插件及其版本 -->
        <plugin>
          <artifactId>maven-antrun-plugin</artifactId>
          <version>1.3</version>
        </plugin>
        <!-- 定义了 maven-assembly-plugin 插件及其版本，用于生成项目打包配置 -->
        <plugin>
          <artifactId>maven-assembly-plugin</artifactId>
          <version>2.2-beta-5</version>
        </plugin>
        <!-- 定义了 maven-dependency-plugin 插件及其版本，管理项目依赖 -->
        <plugin>
          <artifactId>maven-dependency-plugin</artifactId>
          <version>2.8</version>
        </plugin>
        <!-- 定义了 maven-release-plugin 插件及其版本，管理项目发布流程 -->
        <plugin>
          <artifactId>maven-release-plugin</artifactId>
          <version>2.5.3</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

  <!-- reporting 元素用于生成项目报告的输出目录 -->
  <reporting>
    <outputDirectory>${project.build.directory}/site</outputDirectory>
  </reporting>

  <!-- 
  	profiles 元素定义了项目的构建配置文件
  	需要mvn clean install -DperformRelease=true才能生效
   -->
  <profiles>
    <!-- 定义一个 profile，名为 release-profile -->
    <profile>
      <id>release-profile</id>

      <!-- activation 元素定义激活 profile 的条件 -->
      <activation>
        <!-- 当属性 performRelease 为 true 时激活此 profile -->
        <property>
          <name>performRelease</name>
          <value>true</value>
        </property>
      </activation>

      <build>
        <plugins>
          <!-- 继承自父 POM 的 maven-source-plugin 插件 -->
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-source-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-sources</id>
                <goals>
                  <!-- 生成源码 jar 包 -->
                  <goal>jar-no-fork</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <!-- 继承自父 POM 的 maven-javadoc-plugin 插件，用于生成 Javadoc -->
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-javadoc-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-javadocs</id>
                <goals>
                  <!-- 生成 Javadoc jar 包 -->
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <!-- 继承自父 POM 的 maven-deploy-plugin 插件 -->
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-deploy-plugin</artifactId>
            <configuration>
              <!-- 配置更新发布信息 -->
              <updateReleaseInfo>true</updateReleaseInfo>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>

</project>

  也正是超级pom中build元素定义了构建过程中的源码文件、配置文件等资源的目录，才有如下约定的目录要求。

在这里插入图片描述

2.4、有效POM（Effective POM）

  有效POM(Effective POM)是Maven生成的最终POM文件，它将项目POM文件与父POM、超级POM以及各种继承和聚合的配置组合在一起，形成一个完整的项目配置。有效POM包含了项目中所有继承的配置、依赖、插件等信息，即项目实际构建时使用的完整POM。

2.4.1、如何查看有效POM？
mvn help:effective-pom

示例输出：

<project>
  <modelVersion>4.0.0</modelVersion>
  
  <groupId>com.example</groupId>
  <artifactId>my-project</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
  
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.22.2</version>
      </plugin>
      <plugin>
        <artifactId>maven-jar-plugin</artifactId>
        <version>3.1.0</version>
      </plugin>
      <!-- 其他插件 -->
    </plugins>
  </build>
  
  <dependencies>
    <!-- 列出所有依赖，包括直接声明的和继承来的 -->
  </dependencies>
  
  <!-- 其他配置 -->
</project>

  如果使用mvn help:effective-pom命令时，输出的内容过多导致最上面的部分被截断，输出到文件并打开。

  • 在Linux或macOS中，执行以下命令可以将输出保存到文件后立即打开它
mvn help:effective-pom > effective-pom.xml && open effective-pom.xml
  • 在Windows上可以使用
mvn help:effective-pom > effective-pom.xml && start effective-pom.xml
2.4.2、有效POM的用途
  • 调试配置问题：帮助你理解为什么某个依赖或插件会被使用，或者为何某个插件没有被使用
  • 查看默认插件：帮助查看所有自动添加的插件和它们的版本
  • 验证继承和聚合：确保项目继承了正确的配置，尤其是当项目使用多模块或父子POM时

三、Maven依赖管理

  Maven依赖管理是Maven最强大的功能之一，它通过自动下载和管理项目所需的外部库和插件，使开发者无需手动配置这些依赖项。

1、依赖范围

  • 通过设置坐标的依赖范围，可以设置对应jar包的作用范围
    • 编译环境：在源代码的目录src/main/java下可以使用
    • 测试环境：在测试源代码的目录src/test/java下可以使用
    • 运行环境：生成的war或可执行jar的lib下有对应的jar

1.1、compile（编译范围）

  • 描述：默认依赖范围。所有没有明确指定范围的依赖，都会使用compile范围
  • 作用：在编译、测试和运行时均可用
  • 使用场景：对于大多数核心库，如框架类库（例如 Spring），都应使用compile范围
  • 示例：
    <dependency>
    <groupId>org.example</groupId>
    <artifactId>example-lib</artifactId>
    <version>1.0</version>
</dependency>

1.2、provided（已提供范围）

  • 描述：运行时需要由应用服务器或容器提供该依赖
  • 作用：在编译和测试时可用，但不会在运行时包含在打包文件中
  • 使用场景：适用于需要在应用服务器或其他容器（如 Tomcat）中提供的依赖。例如，Servlet API 需要由 Web 服务器提供
  • 示例：
    <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>
  • 如图tomcat也就是部署的服务器本身就提供了
    在这里插入图片描述

1.3、runtime（运行时范围）

  • 描述：主要用于那些不在编译阶段使用，但需要在项目运行时加载的库
  • 作用：在运行和测试时可用，但不会在编译时使用
  • 使用场景：JDBC驱动实现依赖，其在编译时只需JDK提供的JDBC接口，只有测试、运行阶段才需要实现了JDBC接口的驱动
  • 示例：
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.25</version>
    <scope>runtime</scope>
</dependency>

1.4、test（测试范围）

  • 描述：通常用于JUnit、TestNG等测试框架
  • 作用：只在测试环境src/test/java下可用，编译和运行时不可用
  • 使用场景：适用于所有测试相关的库，如测试框架
  • 示例：
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

1.5、system（系统范围）

  • 描述：系统范围的依赖类似于provided，但它需要手动提供JAR文件，并通过systemPath明确指明依赖的路径
  • 作用：在编译和测试时可用，但不会在运行时包含。（project.basedir是maven的预定义变量，表示当前项目的根目录路径）
  • 使用场景：适用于系统自带的库，或需要本地使用的特定JAR文件
  • 打包插件配置<includeSystemScope>true</includeSystemScope>，否则可执行jar中lib没有此依赖
  • 示例：
      <dependency>
      <groupId>com.xc.maven</groupId>
      <artifactId>xc-maven-test</artifactId>
      <version>1.0-SNAPSHOT</version>
      <systemPath>${project.basedir}/src/main/resources/lib/open-api-sdk-2.0.jar</systemPath>
      <scope>system</scope>
  </dependency>
  <!--配合打包插件配置-->
  <build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
              <configuration>
                  <includeSystemScope>true</includeSystemScope>
              </configuration>
          </plugin>
      </plugins>
  </build>

1.6、import（导入范围）

  • 描述：import是一种特殊的依赖范围，通常在依赖管理（<dependencyManagement>）中使用，用来导入POM类型的依赖。通过import，可以将另一个POM中定义的依赖管理配置应用到当前项目中
  • 作用：引入另一项目的依赖配置，不直接应用于编译、测试或运行时
  • 使用场景：在一个父pom中的dependencyManagement标签中需要导入另一个pom中的dependencyManagement的时候
  • <type>元素用于指定依赖的打包类型，默认依赖是.jar文件，是最常见的依赖类型
  • 示例：
    <dependencyManagement>
	<dependency>
  	  <groupId>org.example</groupId>
    	<artifactId>example-dependencies</artifactId>
    	<version>1.0</version>
    	<type>pom</type>
    	<scope>import</scope>
	</dependency>
</dependencyManagement>

<type>单独使用的场景

  • 指定依赖的类型为POM，表明这是一个POM文件，而不是一个实际的库
  • 这个配置用于将指定POM文件中的依赖管理或其他配置引入到当前项目中
<dependencies>
    <dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-dependencies</artifactId>
	    <version>2.7.11</version>
        <type>pom</type>
    </dependency>
</dependencies>

2、依赖传递

  假设项目A依赖于库B，而库B依赖于库C，那么当你在项目A中声明依赖库B时，Maven会自动为你将库C也加入到A的类路径中。这就是依赖传递的效果，Maven会递归解析每个依赖的依赖。

2.1、依赖传递的作用范围

  Maven支持不同的依赖范围（scope），依赖传递的行为会受到这些范围的影响。以下是各范围在依赖传递中的行为：

作用范围传递性原因
compile是默认范围，可在编译、运行和测试时使用，传递性强
provided否仅在编译和测试时使用，不会在运行时加入，传递性关闭
runtime是仅在运行时使用，编译时不可用，传递性仍然保留
test否仅在测试时使用，不会传递给其他模块
system否需要手动指定的外部依赖，不能传递
import仅导入依赖管理仅用于导入依赖管理，不导入具体依赖

2.2、可选依赖

  当你为某个依赖指定<optional>true</optional>时，这个依赖就不会自动传递给下游的依赖（即其他依赖这个项目的项目）。一句话，阻止依赖传递。

<!--热部署依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

2.3、依赖冲突与版本控制

  Maven通过依赖传递机制可能会引入多个不同版本的同一个库，这时就会发生依赖冲突。

依赖冲突优先级规则

  • 首要判断：最短路径优先
    在这里插入图片描述

  • 再者判断：路径相同时先声明者优先
    在这里插入图片描述

依赖冲突手动排除

  • 在对依赖冲突默认规则生效的版本不满意时候，可以自己选择手动排除
<dependency>
    <groupId>com.xc</groupId>
    <artifactId>project2</artifactId>
    <version>1.0-SNAPSHOT</version>
    <scope>compile</scope>
    <!-- 使用excludes标签配置依赖的排除	-->
    <exclusions>
        <!-- 在exclude标签中配置一个具体的排除 -->
        <exclusion>
            <!-- 指定要排除的依赖的坐标（不需要写version） -->
            <groupId>com.xc</groupId>
            <artifactId>project3</artifactId>
        </exclusion>
    </exclusions>
</dependency>

四、Maven工程构建

  项目构建是指将源代码、依赖库和资源文件等转换成可执行或可部署的应用程序的过程，在这个过程中包括编译源代码、链接依赖库、打包和部署等多个步骤。

在这里插入图片描述

1、生命周期

  Maven的生命周期（Lifecycle）是构建项目的步骤集合，定义了从项目编译到部署的一系列过程。

下面是Maven生命周期及其阶段的表格：

生命周期阶段描述
Clean 生命周期pre-clean执行清理之前的工作
clean(重点)移除上一次构建生成的文件
post-clean执行清理之后的工作
Default 生命周期validate验证项目结构和必要信息
initialize初始化构建状态，例如设置属性
generate-sources生成源代码（如果需要）
process-sources处理源代码（如代码增强）
generate-resources生成资源文件
process-resources复制并处理资源到输出目录，准备打包
compile(重点)编译项目main目录下的源代码
process-classes处理编译后的类文件
generate-test-sources生成测试源代码
process-test-sources处理测试源代码
generate-test-resources生成测试资源
process-test-resources处理测试资源
test-compile编译测试代码
test(重点)运行测试代码
prepare-package打包前的准备工作
package(重点)将编译结果打包（如 JAR、WAR）
pre-integration-test运行集成测试前的准备工作
integration-test运行集成测试
post-integration-test集成测试后的清理工作
verify验证项目是否符合标准
install(重点)安装包到本地仓库
deploy(重点)将包发布到远程仓库
Site 生命周期pre-site生成站点之前的准备工作
site生成项目站点文档
post-site生成站点之后的处理工作
site-deploy发布生成的站点到服务器
  • 生命周期独立：clean、default和site生命周期彼此独立，执行一个生命周期时，不会自动触发其他生命周期
  • 阶段顺序执行：在一个生命周期内，Maven从最初阶段开始执行，依次运行到你指定的阶段。如果指定了一个中间阶段，之前的所有阶段都会被执行，确保构建流程的完整性和一致性

2、构建命令

  需要在包含pom.xml的项目根目录执行Maven构建命令，因为Maven是基于这个文件来读取构建配置、依赖和插件信息的。

命令描述
mvn compile编译项目，生成target文件
mvn package打包项目，生成jar或war文件
mvn clean清理编译或打包后的项目结构
mvn install打包后上传到maven本地仓库
mvn deploy只打包，上传到maven私服仓库
mvn site生成站点
mvn test执行测试源码

2.1、常见组合命令

  • mvn clean install：清理项目后，重新构建并将包安装到本地仓库
  • mvn clean package：清理项目后，重新生成可分发的包（如 JAR 或 WAR）

2.2、命令选项

  • -DskipTests：跳过测试，例如：mvn clean install -DskipTests
  • -X：启用详细的调试日志信息，例如：mvn clean install -X
  • -T 1C：使用多线程构建，1C表示使用与CPU核数相同的线程数，例如：mvn clean install -T 1C

3、插件

  Maven插件是执行项目构建和管理的实际工具。所有的构建任务（例如编译、测试、打包、部署等）都是由插件来执行的。Maven本身是一个框架，它通过插件来调用具体的功能。

3.1、Maven默认的插件

  • maven-compiler-plugin：用于编译源代码。默认Java1.5版本，可以通过配置更改为其他版本

方式一：并设置source和target版本

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.8.1</version> <!-- 插件版本 -->
  <configuration>
    <source>1.8</source> <!-- 指定源代码使用的Java版本 -->
    <target>1.8</target> <!-- 指定生成字节码的Java版本 -->
  </configuration>
</plugin>

方式二：使用properties设置全局Java版本

<!-- properties: 项目属性，通常用来定义全局变量 -->
<properties>
    <!-- Maven 编译器的 Java 源代码版本 -->
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>
  • maven-surefire-plugin：用于运行单元测试，主要是通过 JUnit 或 TestNG
  • maven-jar-plugin：用于创建jar文件。默认把编译后的class文件打包为一个jar文件（只是一个标准的库 JAR，不包含所有的依赖项）
  • maven-install-plugin：用于把生成的工件（JAR、WAR 文件等）安装到本地Maven仓库
  • maven-deploy-plugin：用于将工件发布到远程仓库，供其他开发人员使用
  • maven-site-plugin：用于生成站点文档，通常基于项目的POM文件信息生成报告和文档
  • maven-clean-plugin：用于清除项目生成的文件，例如target目录下的编译输出
  • maven-resources-plugin：用于处理项目中的资源文件（如将资源从 src/main/resources 复制到目标目录）

从idea可视化工具查看maven的默认插件：

在这里插入图片描述

3.2、生成微服务可运行jar包

  由以上插件maven-jar-plugin可知，默认情况只能生成依赖jar，而不是微服务可执行的jar，一般使用SpringBoot插件spring-boot-maven-plugin，这个插件负责打包微服务为一个可运行的jar包。

<!--    SpringBoot应用打包插件-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
3.2.1、添加spring-boot-maven-plugin插件后的打包流程
  • 第一步：打包生成普通JAR
    • Maven会使用默认打包插件maven-jar-plugin生成一个普通的JAR文件
    • 标准JAR文件，不可执行，用于依赖作为库或被引用
  • 第二步：生成可执行JAR
    • 将第一步生成的JAR文件重命名为xxx.jar.original文件
    • repackage命令会将应用的所有依赖项（包括嵌入式的 Tomcat、Jetty 或其他服务器）打包进JAR中，并且指定JAR的入口点（即 Main-Class）
    • 可执行的JAR，包含所有依赖和嵌入式服务器，能够独立运行

在这里插入图片描述

3.2.2、常规打包方式

pom文件：

...
    <groupId>com.xc</groupId>
    <artifactId>springboot-mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
...

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

打包结果：

在这里插入图片描述

  • springboot-mybatis-1.0-SNAPSHOT.jar
    • 命名： artifactId + 版本号，用“-”连接
    • 可以使用java -jar xxx直接运行的服务，里面包含依赖的jar
  • springboot-mybatis-1.0-SNAPSHOT.jar.original
    • 去掉后缀.original则是可以被其他项目依赖的jar
3.2.3、进阶打包方式

pom文件：

...
    <groupId>com.xc</groupId>
    <artifactId>springboot-mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
...

    <build>
        <finalName>my-mybatis</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <classifier>exec</classifier>
                    <skip>false</skip>
                </configuration>
            </plugin>
        </plugins>
    </build>

打包结果：

在这里插入图片描述

  • my-mybatis.jar：依赖jar，不可执行
  • my-mybatis-exec.jar：可执行依赖
  • <finalName>标签：设置打包的名称，不再使用artifactId + 版本号方式
  • <classifier>标签：设置可运行服务jar的后缀
    • 因为可运行jar有了后缀
    • 所有依赖jar就不会重名，也就不用添加后缀.original
  • <skip>标签：mavn执行插件选择是否跳过，默认false，true则不执行当前插件

3.3、<resources>标签

不写<resources>标签

  • src/main/java下非java文件都不会编译
    • target当中的classes和打出的包解压BOOT-INF当中的classes都找不到
  • src/main/resources下的文件都会被编译
    • target当中的classes和打出的包解压BOOT-INF当中的classes都可以找到

<resources>标签只设置src/main/java

  • 假如代码中有xml想加载编译，添加如下
<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>
  • <filtering>标签：默认值为false。指定打包时的配置文件其中${}引用会换成直接引用
  • 此时src/main/java中的xml会编译，但是src/main/resource中的所有资源都没有加载
  • 可以理解为：
    • 不加<resource>则默认只加载resource文件
    • 添加<resource>则是加哪个路径，只加载哪个路径的文件

最终方案

  • 如此，java和resources下需要的资源都会加载
<build>
	<resources>
		<resource>
			<directory>src/main/java</directory>
			<filtering>true</filtering>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
		<resource>
			<directory>src/main/resources</directory>
			<filtering>true</filtering>
        </resource>
	</resources>
</build>

Maven生命周期、命令、插件之间的关系

  Maven的生命周期定义了项目构建的步骤，每个阶段通过绑定的插件目标执行具体任务。命令用于触发生命周期的某个阶段或直接调用插件目标。三者通过插件绑定阶段、命令触发生命周期，协同完成项目的自动化构建。

五、Maven继承和聚合

1、继承

  Maven工程之间，A工程继承B工程。本质上是A工程的pom.xml中的配置继承了B工程中pom.xml的配置

1.1、父项目的pom.xml

  • 父项目是作为顶层项目，包含多个子项目的通用配置。父项目的打包类型是pom
  • 使用dependencyManagement标签配置只对依赖的管理，不导入
<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.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
            </plugin>
        </plugins>
    </build>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>5.3.9</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

1.2、子项目pom.xml

  • 子项目通过在pom.xml中使用<parent>标签指定父项目，从而继承父项目的配置
  • 子项目可以继承父项目的依赖、插件、属性等，也可以在子项目中覆盖父项目的配置
  • 如果子工程坐标中的groupId和version与父工程一致，那么可以省略
<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>

    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../parent-pom.xml</relativePath> <!-- 相对路径 -->
    </parent>

    <artifactId>child-project</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>
</project>
1.2.1、<relativePath>标签
  • <relativePath>标签用于在子项目的pom.xml中指定父项目的相对路径
  • 如果父项目位于子项目上一级目录，通常不需要显式指定<relativePath>，Maven会默认使用../pom.xml
  • 在非标准目录结构或父项目位于远程仓库时，使用<relativePath/>忽略远程父项目

2、聚合

  Maven聚合是通过在一个主项目的pom.xml文件中使用<modules>标签定义多个子模块来实现的。聚合项目本身的pom.xml文件不会直接生成可执行文件，而是负责将多个子模块集中构建。

聚合项目pom.xml：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!-- 列出所有模块 -->
    <modules>
        <module>module-a</module>
        <module>module-b</module>
        <module>module-c</module>
    </modules>
</project>

  在这个例子中，聚合项目parent-project聚合了三个子模块module-a、module-b和module-c。通过运行聚合项目的mvn install或mvn clean install命令，可以一次性构建这三个子模块。

五、Maven仓库

1、Maven仓库

  Maven仓库（Maven Repository）是用于存储和管理Maven项目构建过程中所需的依赖库、插件以及构件的存储库。

1.1、本地仓库（Local Repository）

  本地仓库位于开发者的本地机器上，存储Maven构建过程中下载的所有依赖和插件。当项目构建时，Maven 首先会检查本地仓库中是否已经存在需要的依赖，如果没有，则会从远程仓库或中央仓库下载。

  • 默认路径：~/.m2/repository
  • 特性：缓存下载的依赖，减少重复下载，提高构建速度

settings.xml文件修改本地仓库地址，将中央仓库地址替换为阿里云Maven仓库

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
                              http://maven.apache.org/xsd/settings-1.0.0.xsd">

    <localRepository>/path/to/your/repo</localRepository>

    <mirrors>
        <mirror>
            <id>aliyun-maven</id>
            <mirrorOf>central</mirrorOf>
            <name>Aliyun Maven Repository</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <layout>default</layout>
        </mirror>
    </mirrors>

    <!-- 其他配置 -->
</settings>

1.2、中央仓库（Central Repository）

  中央仓库是Maven官方维护的公共仓库，存储了开源项目常用的依赖库。它是Maven的默认远程仓库，当本地仓库中没有找到某个依赖时，Maven会自动从中央仓库下载。

  • 中央仓库地址：https://repo.maven.apache.org/maven2
  • 特性：全球公开访问，涵盖了大量开源项目的库和插件

1.3、远程仓库（Remote Repository）

  远程仓库是除了中央仓库，任何其他的远程仓库，包括第三方仓库和私有仓库。

  • 其中，远程仓库可以分为两种子类型：
    • 快照仓库（Snapshot Repository）：用于存储开发中的快照版本，支持不断更新
    • 发布仓库（Release Repository）：用于存储稳定的已发布版本，内容不会改变

1.4、Maven仓库的工作原理

  1. 本地仓库查找：Maven 首先从本地仓库查找构建所需的依赖和插件
  2. 远程仓库下载：如果本地仓库没有该依赖，Maven 会从配置的远程仓库或中央仓库下载该依赖，并存储到本地仓库中
  3. 依赖缓存：一旦依赖下载到本地仓库，后续构建中无需再次下载，除非依赖的版本发生变化（如 SNAPSHOT版本）
  4. 发布到仓库：开发人员可以将构件（如打包的JAR文件）发布到远程仓库（如企业私有仓库），供其他团队成员或项目共享使用

2、Maven私服

  Maven私服是一种特殊的Maven远程仓库，它是架设在局域网内的仓库服务，用来代理位于外部的远程仓库（中央仓库、其他远程公共仓库）。

在这里插入图片描述

以下是搭建 Maven 私服常用的工具：

  • Nexus Repository Manager：由Sonatype提供的开源仓库管理器（当前最流行、使用最广泛）
  • Artifactory：Jfrog提供的仓库管理工具，支持多种格式的包管理（包括 Maven）
  • Apache Archiva：Apache提供的开源工具，专注于Maven仓库管理

2.1、Nexus仓库

在这里插入图片描述

仓库类型说明
proxy代理仓库：用于从远程存储库获取组件
group组仓库：它将多个仓库聚合为一个访问入口，可以一并访问多个底层仓库
hosted托管仓库：用于存储由内部开发者创建的jar包
  • maven-central：代理了远程的Maven中央仓库，构建项目时会从该仓库下载依赖

在这里插入图片描述

  • maven-public：一个组仓库，聚合了多个仓库的内容
    • 它将多个仓库整合成一个统一的入口，便于开发者访问
    • 在这个组中，通常包含maven-releases、maven-snapshots和maven-central等仓库
    • 那么只需要配置一个maven-public仓库，就能同时访问这些托管的和代理的仓库

在这里插入图片描述

  • maven-releases：专门用于存储发布的版本（release versions）的构件
    • 当一个项目发布了稳定的版本（非SNAPSHOT），可以将这些构件发布到maven-releases仓库中
    • 其他团队成员或相关项目可以直接从这个仓库下载发布的版本
  • maven-snapshots：专门用于存储开发中的SNAPSHOT版本的构件
    • SNAPSHOT版本代表开发中的构件，它们可能会频繁更新，不像release版本那样稳定
    • 每次构建的SNAPSHOT版本都会覆盖先前版本，而不是生成新的版本号

2.2、通过Nexus下载jar包

  • 修改settings.xml
<mirrors>
    <mirror>
        <id>nexus-mirror</id> <!-- 这是镜像仓库的唯一标识符，不用于认证 -->
        <mirrorOf>central</mirrorOf> <!-- 重定向中央仓库的请求 -->
        <url>http://your-nexus-repo-url/repository/maven-public/</url>
    </mirror>
</mirrors>

<servers>
    <server>
        <id>nexus-mirror</id> <!-- 如果上面仓库需要认证，这个ID必须与上面id一致 -->
        <username>your-username</username>
        <password>your-password</password>
    </server>
</servers>
  • url标签的来源

在这里插入图片描述

  • 本地仓库下载完包以后，nexus的组仓库maven-public就能看见jar包了

在这里插入图片描述

  • 若下载速度太慢，可以设置私服中中央仓库的地址为阿里云仓库地址

在这里插入图片描述
在这里插入图片描述

2.3、将jar包部署到Nexus

步骤 1：在pom.xml中配置发布仓库

  • 一个用于发布正式的release版本，另一个用于发布snapshot（快照）版本
<distributionManagement>
    <repository>
        <id>nexus-releases</id> <!-- 正式发布仓库的 ID -->
        <url>http://your-nexus-repo-url/repository/maven-releases/</url> <!-- Nexus Releases 仓库的 URL -->
    </repository>
    <snapshotRepository>
        <id>nexus-snapshots</id> <!-- 快照仓库的 ID -->
        <url>http://your-nexus-repo-url/repository/maven-snapshots/</url> <!-- Nexus Snapshots 仓库的 URL -->
    </snapshotRepository>
</distributionManagement>

步骤 2：在 settings.xml 中配置认证信息

  • 为distributionManagement中的仓库id添加相应的认证信息
<servers>
    <server>
        <id>nexus-releases</id> <!-- 对应 pom.xml 中的 repository ID -->
        <username>your-username</username>
        <password>your-password</password>
    </server>
    <server>
        <id>nexus-snapshots</id> <!-- 对应 pom.xml 中的 snapshotRepository ID -->
        <username>your-username</username>
        <password>your-password</password>
    </server>
</servers>
  • 上传成功

在这里插入图片描述

3、repositories和mirrors

3.1、repositories(仓库)

  repositories 是Maven用于查找和下载项目依赖的远程或本地存储库。Maven在构建项目时，会从这些仓库中查找所需的依赖（如 JAR 包）并下载到本地存储库。

主要功能

  • 定义Maven用来查找项目依赖的存储库位置
  • 可以在pom.xml中为每个项目单独配置，也可以在settings.xml中全局配置

示例

在 pom.xml 中定义仓库：

<repositories>
    <repository>
        <id>company-repo</id> <!-- 仓库的唯一 ID，用于认证等 -->
        <url>http://your-company-repo-url/repository/maven-releases/</url> <!-- 仓库 URL -->
        <releases>
            <enabled>true</enabled> <!-- 指定是否用于发布版本 -->
        </releases>
        <snapshots>
            <enabled>false</enabled> <!-- 指定是否用于快照版本 -->
        </snapshots>
    </repository>
</repositories>

3.2、mirrors(镜像)

  mirrors 用于对某个特定仓库（如Maven中央仓库）的请求重定向到另一个仓库（如公司内部的Nexus仓库）。它的主要作用是将对中央仓库、快照仓库等的请求重定向到另一个地方。

主要功能

  • 当Maven请求中央仓库时，它会自动将请求转发到定义的镜像仓库，而不需要手动配置每个项目的repositories
  • 配置在settings.xml中（而不是 pom.xml），适用于全局配置

示例

在 settings.xml 中定义镜像：

<mirrors>
    <mirror>
        <id>nexus-mirror</id> <!-- 镜像仓库的唯一标识符 -->
        <mirrorOf>central</mirrorOf> <!-- 指定要镜像的仓库，如 Maven 中央仓库 -->
        <url>http://your-company-repo-url/repository/maven-public/</url> <!-- 镜像仓库的 URL -->
    </mirror>
</mirrors>
  • id：为镜像指定的唯一标识符。它可以是任意值，用于区分不同的镜像配置
  • mirrorOf：定义要镜像的仓库。常见的值包括：
    • central：表示Maven中央仓库
    • *：表示镜像所有仓库
    • repo1,repo2：表示镜像多个指定的仓库
    • !central：表示镜像所有仓库，除了中央仓库
  • url：镜像仓库的实际URL，Maven将通过这个URL下载依赖

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2220318.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

算法的学习笔记—丑数(牛客JZ49)

算法的学习笔记—丑数(牛客JZ49)

&#x1f600;前言 在程序设计和算法竞赛中&#xff0c;丑数问题是一个经典的动态规划题目。丑数&#xff08;Ugly Number&#xff09;定义为只包含质因子 2、3 和 5 的数。举例来说&#xff0c;数字 6&#xff08;因子为 2 和 3&#xff09;、数字 8&#xff08;因子为 2&…
阅读更多...
gewechat免费开源微信机器人开发

gewechat免费开源微信机器人开发

​聊天机器人&#xff0c;是一种通过自然语言模拟人类进行对话的程序。通常运行在特定的软件平台上&#xff0c;如PC平台或者移动终端设备平台。聊天机器人系统的主要功能是同用户进行基本沟通并自动回复用户有关产品或服务的问题&#xff0c;以实现降低企业客服运营成本、提升…
阅读更多...
珊瑚岛风灵月影四十九项修改器：体力不减/生命不减/开启金钱修改

珊瑚岛风灵月影四十九项修改器：体力不减/生命不减/开启金钱修改

珊瑚岛是一款以模拟经营岛屿为特色的休闲养成游戏。在游戏中&#xff0c;玩家需设法吸引顾客消费。同时&#xff0c;还需投入时间和资源修复遗址&#xff0c;过程中或会遇到技术、资金及文化保护等挑战&#xff0c;增添游戏趣味与深度。 修改器地址&#xff1a; https://downf…
阅读更多...
力扣——链表的中间结点（链表）C语言

力扣——链表的中间结点（链表）C语言

题目&#xff1a; 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点。 返回中间3这个结点&#xff1b; 返回中4这个结点&#xff1b; 原理&#xff1a; 思路1&#xff1a;利用遍历链表&#xff0c;统…
阅读更多...
图文深入理解java的内存分配

图文深入理解java的内存分配

本篇图文深入讨论java的内存分配。当然&#xff0c;这里所说的深入&#xff0c;并不是指长篇大论&#xff0c;而是就事论事重点深入介绍java的内存分配原理机制。 在理解java如何为变量或者对象分配内存之前&#xff0c;我们先来了解一个问题&#xff1a;为什么需要分配内存&am…
阅读更多...
新电脑Win11家庭中文版跳过联网激活方法（教程）

新电脑Win11家庭中文版跳过联网激活方法（教程）

预装Win11家庭中文版的新电脑&#xff0c;如何跳过联网激活&#xff1b;由于微软限制必须要联网激活&#xff0c;需要使用已有的微软账户登入或者注册新的微软账户后才可以继续开机使用&#xff0c;Win11联网后系统会自动激活。下面介绍一下初次开机初始化电脑时如何跳过联网激…
阅读更多...
今年双十一最值得入手的好物有哪些？双十一值得选购的好物盘点！

今年双十一最值得入手的好物有哪些？双十一值得选购的好物盘点！

在这个全民狂欢的购物盛宴——双十一&#xff0c;每一个角落都弥漫着诱人的优惠与不可错过的精品。从科技潮品到生活必需品&#xff0c;从时尚尖货到家居好物&#xff0c;无数精选商品在这一季集中绽放&#xff0c;等待着慧眼识珠的你将它们带回家&#xff0c;今年的双十一&…
阅读更多...
除GOF23种设计模式之简单工厂模式

除GOF23种设计模式之简单工厂模式

文章目录 1. 简介2. 代码2.1 抽象类&#xff1a;Course.java2.2 产品A:JavaCourse.java2.3 产品B:PythonCourse.java2.4 工厂:CourseFactory.java2.5 测试&#xff1a;Test.java 3. 心得参考链接&#xff08;无&#xff09; 1. 简介 简单工厂模式(Simple Factory Patern):又称…
阅读更多...
Java项目-基于springboot框架的网上书城系统项目实战(附源码+文档)

Java项目-基于springboot框架的网上书城系统项目实战(附源码+文档)

作者&#xff1a;计算机学长阿伟 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、ElementUI等&#xff0c;“文末源码”。 开发运行环境 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringBoot、Vue、Mybaits Plus、ELementUI工具&#xff1a;IDEA/…
阅读更多...
【番外】软件设计师中级笔记关于数据库技术更新笔记问题

【番外】软件设计师中级笔记关于数据库技术更新笔记问题

提问 由于软件设计师中级笔记中第九章数据库技术基础的笔记内容太多&#xff0c;我应该分几期发布呢&#xff1f;还是一期一次性发布完成。 如果分为一期发布&#xff0c;可能需要给我多一些时间&#xff0c;由于markdown格式有所差异&#xff0c;所以我需要部分进行修改与调…
阅读更多...
策略路由---选路

策略路由---选路

目录 拓扑图 配置IP 配置静态路由 配置ospf nat 配置路由策略 流分类 流行为 流策略 应用接口 测试流量路径 拓扑图 配置IP [R1]int g0/0/0 [R1-GigabitEthernet0/0/0]ip add 192.168.1.254 24 [R1-GigabitEthernet0/0/0]int g0/0/1 [R1-GigabitEthernet0/0/1]ip add…
阅读更多...
Java项目-基于Springboot的车辆充电桩项目(源码+说明).zip

Java项目-基于Springboot的车辆充电桩项目(源码+说明).zip

作者&#xff1a;计算机学长阿伟 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、ElementUI等&#xff0c;“文末源码”。 开发运行环境 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringBoot、Vue、Mybaits Plus、ELementUI工具&#xff1a;IDEA/…
阅读更多...
Javascript算法——二分查找

Javascript算法——二分查找

1.数组 1.1二分查找 1.搜索索引 开闭matters&#xff01;&#xff01;&#xff01;[left,right]与[left,right) /*** param {number[]} nums* param {number} target* return {number}*/ var search function(nums, target) {let left0;let rightnums.length-1;//[left,rig…
阅读更多...
⌈ 传知代码 ⌋ 无监督动画中关节动画的运动表示

⌈ 传知代码 ⌋ 无监督动画中关节动画的运动表示

&#x1f49b;前情提要&#x1f49b; 本文是传知代码平台中的相关前沿知识与技术的分享~ 接下来我们即将进入一个全新的空间&#xff0c;对技术有一个全新的视角~ 本文所涉及所有资源均在传知代码平台可获取 以下的内容一定会让你对AI 赋能时代有一个颠覆性的认识哦&#x…
阅读更多...
PP-ChatOCRv3—文档场景信息抽取v3产线使用教程

PP-ChatOCRv3—文档场景信息抽取v3产线使用教程

文档场景信息抽取v3产线使用教程 1. 文档场景信息抽取v3产线介绍 文档场景信息抽取v3&#xff08;PP-ChatOCRv3&#xff09;是飞桨特色的文档和图像智能分析解决方案&#xff0c;结合了 LLM 和 OCR 技术&#xff0c;一站式解决版面分析、生僻字、多页 pdf、表格、印章识别等常…
阅读更多...
Spring连接数据库:Mybatis

Spring连接数据库:Mybatis

MyBatis是一款优秀的框架 在数据库中创建表 1.创建项目mybatis 2.在proxml文件中导入必要配置并进行编译 <dependencies><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.33<…
阅读更多...
电能表预付费系统-标准传输规范(STS)（15）

电能表预付费系统-标准传输规范(STS)（15）

6.3.7 CRC: CyclicRedundancyCheck (循环冗余校验) The CRC is a checksum field used to verify the integrity of the data transferred for all tokens, except for Class 0 with SubClass 4 to 7, which uses CRC_C (see 6.3.22). The checksum is derived using the foll…
阅读更多...
网络基础知识：交换机关键知识解析

网络基础知识：交换机关键知识解析

了解交换机的关键知识对网络工程师至关重要。 以下是交换机的基础知识解析&#xff0c;包括其基本概念、工作原理和关键技术点&#xff1a; 01-交换机的基本概念 交换机是一种网络设备&#xff0c;用于在局域网&#xff08;LAN&#xff09;中连接多个设备&#xff0c;如计算机…
阅读更多...
如何恢复U盘里格式化数据？别慌，有带图详细步骤！

如何恢复U盘里格式化数据？别慌，有带图详细步骤！

U盘&#xff0c;这个小巧的存储神器&#xff0c;我们几乎天天都在用。但有时候&#xff0c;一不小心手滑&#xff0c;U盘就被格式化了&#xff0c;里面的东西好像全没了&#xff0c;别急&#xff0c;其实数据恢复没那么难。这篇文章就来告诉你&#xff0c;怎么把格式化的U盘里的…
阅读更多...
NVR录像机汇聚管理EasyNVR多品牌NVR管理工具/设备云台接入及控制详解

NVR录像机汇聚管理EasyNVR多品牌NVR管理工具/设备云台接入及控制详解

在当今快速发展的信息化时代&#xff0c;视频监控系统已成为企业管理和安全防范的重要工具。随着技术的不断进步&#xff0c;多品牌NVR&#xff08;网络视频录像机&#xff09;管理工具如海康NVR管理平台/工具EasyNVR多个NVR同时管理凭借其强大的兼容性和智能化管理功能&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023