SpringBoot项目构建Maven标签及属性用法详解

目录

• 一、序言
• 二、Maven标签介绍

一、序言

在 Spring Boot 项目中，Maven 是最常用的构建工具之一。通过 Maven，我们可以轻松地管理项目的依赖、构建流程和插件。本文将详细介绍 Maven 依赖管理中的主要标签及其使用方法，帮助开发者更好地理解和使用 Maven 构建工具。

二、Maven标签介绍

在 Maven 项目中，用于描述项目信息的标签通常位于 pom.XML 文件的<project>根元素下。这些标签帮助 Maven 构建工具和其他开发者了解项目的基本信息、项目开发者、组织、许可证等。以下是 Maven 中常见的用于项目描述的标签：

项目描述类标签

1. <modelVersion>标签

描述： 指定 POM 文件的模型版本。对于 Maven 2 和更高版本，通常为 4.0.0。

<modelVersion>4.0.0</modelVersion>

2. <groud>标签

描述： 项目的组标识符，通常表示组织或公司名称。与 <artifactId> 共同唯一标识项目。

<groupId>com.example</groupId>

3. <artifactId>标签

描述： 项目的工件标识符，通常是模块或项目的名称。与 <groupId> 共同唯一标识项目。

<artifactId>my-project</artifactId>

4. <version>标签

描述： 项目的版本号。可以是 1.0.0-SNAPSHOT 表示开发中的版本，或者1.0.0表示正式版本。

<version>1.0.0-SNAPSHOT</version>

5. <packaging>标签

描述： 定义项目的打包方式。常见的值有 jar, war, pom 等，默认为 jar。

<packaging>jar</packaging>

6. <name>标签

描述： 项目的名称。

<name>My Project</name>

7. <description>标签

描述： 对项目的简要描述。通常用于进一步解释项目的功能或目的。

<description>This is a sample project to demonstrate Maven project descriptors.</description>

8. <url>标签

描述： 目的主页或相关文档的 URL。可以是项目的官网地址或代码托管平台的链接。

<description>This is a sample project to demonstrate Maven project descriptors.</description>

9. <inceptionYear>标签

描述： 项目的启动年份，通常用于版权声明中。

<inceptionYear>2024</inceptionYear>

10. <organization>标签

描述： 定义项目所属的组织信息，包括组织名称和 URL。

<organization>
    <name>Example Corp</name>
    <url>https://www.example.com</url>
</organization>

11. <licenses>标签

描述： 描述项目使用的许可证信息。包括许可证名称、URL、分发方式等。

<licenses>
    <license>
        <name>Apache License, Version 2.0</name>
        <url>https://www.apache.org/licenses/LICENSE-2.0</url>
        <distribution>repo</distribution>
    </license>
</licenses>

12. <developers>标签

描述： 列出项目的开发人员及其相关信息，如 ID、姓名、电子邮件等。

 <developers>
        <developer>
            <id>123</id> <!-- 开发者ID -->
            <name>yjp</name> <!-- 姓名 -->
            <email>yjp@example.com</email>  <!-- 邮箱 -->
            <organization>sis</organization> <!-- 组织 -->
            <roles> <!-- 角色 -->
                <role>Developer</role> 
            </roles>
        </developer>
    </developers>

13. <contributors>标签

描述： 列出对项目做出贡献的人员及其相关信息，类似于 ，但通常不是核心开发人员。

   <!-- 贡献者信息 -->
    <contributors>
        <contributor>
            <name>Jane Smith</name> <!-- 姓名 -->
            <email>janesmith@example.com</email> <!-- 邮箱 -->
            <organization>Example Corp</organization> <!-- 组织 -www.devze.com->
        </contributor>
    </contributors>

14. <issueManagement>标签

描述： 项目的问题管理系统的信息，如 JIRA、github Issues 等。通常包括系统的类型和 URL。

<issueManagement>
    <system>GitHub Issues</system>
    <url>https://github.com/example/my-project/issues</url>
</issueManagement>

15. <scm>标签

描述： 项目的源码管理（Source Code Management）信息。包括版本控制系统的类型和访问 URL。

 <scm>
    <url>https://github.com/example/my-project</url>
    <connection>scm:git:git://github.com/example/my-project.git</connection>
    <developerConnection>scm:git:ssh://git@github.com/example/my-project.git</developerConnection>
    <tag>HEAD</tag>
</scm>

依赖管理类标签

1. <dependencyManagement>标签

描述： <dependencyManagement>标签用于集中管理依赖的版本号和范围。它不会直接引入依赖，而是为项目中的其他模块提供版本号的定义，避免在各模块中重复定义版本号。子项目可以在使用这些依赖时，不必再次声明版本号。

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.5.4</version>
        </dependency>
    </dependencies>
</dependencyManagement>

2. <dependencies> 和 <dependency> 标签

• <dependencies>：该标签是一个容器，用于包含项目中所需的所有依赖。每个依赖项由<dependency>标签来定义。
• <dependency>：定义了一个具体的依赖项。通常包含以下几个子标签：
  • <groupId>：依赖的组织标识符，通常代表某个组织或公司名称。
  • <artifactId>：依赖的工件标识符，通常是模块或项目的名称。
  • <version>：依赖的版本号。
  • <scope>：依赖的作用域（稍后详细介绍）。
  • <optional>：指定该依赖是否为可选依赖，默认值为 false。

    <dependencyManagement> <!-- 依赖管理 -->
        <dependencies> 
            <dependency> 
                <groupId>cn.iocoder.boot</groupId> <!-- 组织ID -->
                <artifactId>yjp-dependencies</artifactId> <!-- 项目名称 -->
                <version>${revision}</version> <!-- 版本号 -->
                <type>pom</type> <!-- 导入类型:pom 表示该依赖是一个POM类型，而不是一个标准的Java库（如JAR）。POM类型通常用于依赖管理或继承。 -->
                <scope>import</scope>  <!-- 导入范围:import 表示该依赖将导入另一个POM文件，而不是直接作为一个库。 -->
                <optional>false</optional> <!-- 可选依赖:optional 表示该依赖是可选的，即在使用该依赖时，可以选择性地导入。 -->
            </dependency>
        </dependencies>
    </dependencyManagement>

3. <scope> 标签

描述： <scope>属性用于指定依赖的作用域，决定了该依赖在构建生命周期的哪些阶段可用，以及它是否会被传递给依赖它的项目。Maven支持的主要作用域包括以下几种：

(1) compile (默认作用域)

• 说明: 这是默认的作用域，如果没有显式指定<scope>，Maven会将其视为compile。
• 适用范围: 编译、测试和运行时都可用。
• 传递性: 会传递给依赖此项目的所有项目。

<dependency>
    <groupId>org.example</groupId>
    <artifactId>example-lib</artifactId>
    <version>1.0.0</version>
    <!-- compile是默认的，不需要显式指定 -->
</dependency>

(2) provided

• 说明: 依赖在编译和测试阶段可用，但运行时不包含该依赖。通常用于由运行环境（如Servlet容器、应用服务器）提供的依赖。
• 适用范围: 编译和测试时可用，但运行时不包含。
• 传递性: 不会传递给依赖此项目的其他项目。

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

(3) runtime

• 说明: 依赖在运行时和测试阶段可用，但在编译时不可用。通常用于那些仅在运行时需要的库。
• 适用范围: 测试和运行时可用，编译时不可用。
• 传递性: 会传递给依赖此项目的其他项目。

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.30</version>
    <scope>runtime</scope>
</dependency>

(编程4) test

• 说明: 依赖仅在测试编译和测试运行时可用，不会包含在最终的构建成果中。
• 适用范围: 仅测试时可用，编译和运行时不可用
• 传递性: 不会传递给依赖此项目的其他项目。

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

(5) system

• 说明: 依赖类似于provided作用域，但必须显式提供依赖的路径（通过systemPath元素），不会从Maven仓库中下载该依赖。通常不推荐使用。
• 适用范围: 编译和测试时可用，运行时不包含。
• 传递性: 不会传递给依赖此项目的其他项目。

<dependency>
    <groupId>com.example</groupId>
    <artifactId>example-lib</artifactId>
    <version>1.0.0</version>
    <scope>system</scope>
    <systemPath>${basedir}/libs/example-lib.jar</systemPath>
</dependency>

(6) import

• 说明: 这个作用域仅用于依赖管理（通常是BOM文件- Bill of Materials），可以将指定POM文件中的依赖版本管理导入到当前项目中。
• 适用范围: 仅用于<dependencyManagement>内的依赖声明，不能用于常规依赖。
• 传递性: 导入的版本管理会影响当前项目及其子模块。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.5.4</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

这些作用域帮助开发者在构建过程中有效管理依赖的使用范围和传递性，根据具体场景选择合适的作用域可以避免不必要的依赖引入，提高项目的可维护性和构建效率。

4. <exclusions> 标签

描述： 当一个依赖引入了不需要的传递依赖时，我们可以使用 <exclusions> 标签将其排除。每个 <exclusion> 元素定义一个要排除的依赖，通常包含<groupId>和 <artifactId> 子标签。

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.5.4</version>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

5. <optional> 标签

描述： <optional> 标签用于标记一个依赖是否为可选。可选依赖不会自动传递给依赖此项目的其他项目。

<dependency>
    <groupId>com.example</groupId>
    <artifactId>example-lib</artifactId>
    <version>1.0.0</version>
    <optional>true</optional>
</dependency>

项目构建类标签

1. <build>标签

**描述：**定义项目的构建配置，如构建目录、插件、资源、配置文件等。

    <build>
        <!-- 设置构建的 jar 包名 -->
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 打包 -->
            <plugin>
                <groupId>org.springframework.boot</groupId> 
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring.boot.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal> <!-- 将引入的 jar 打入其中 -->
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2. <sourceDirectory>标签

描述： 定义项目的主源代码目录。默认情况下，该目录为 src/main/java。如果你的源代码存放在其他目录中，可以通过该标签进行修改。

 <sourceDirectory>src/main/java</sourceDirectory>

3. <testSourceDirectory>标签

描述： 定义项目的测试源代码目录。默认情况下，该目录为 src/test/java。如果你的测试代码存放在其他目录中，可以通过该标签进行修改。

<testSourceDirectory>src/test/java</testSourceDirectory>

4. <outputDirectory>标签

描述： 指定编译后的主代码输出目录。默认值为 target/classes。

<outputDirectory>target/classes</outputDirectory>

5. <finalName>标签

描述： 定义构建输出的最终名称，不包括文件扩展名。默认情况下，Maven 会将输出文件命名为 ${artifactId}-${version}。你可以通过此标签自定义输出文件的名称。

<finalName>my-custom-name</finalName>

6. <resources>标签

描述： 定义项目的资源目录及资源文件。资源文件会被打包到最终的构建产物中（如 JAR 包）。通常资源目录为 src/main/resources，该标签允许你自定义资源的路径和处理方

<resources>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>**/*.properties</include>
        </includes>
    </resource>
</resources>

7. <plugins>标签

描述： 定义 Maven 构建生命周期中的插件。插件是 Maven 的核心组件，用于执行各种任务（如编译、打包、测试、部署等）。你可以在此标签中配置和使用不同的插件。

<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
            <source>1.8</source>
            <target>1.8</target>
        </configuration>
    </plugin>
</plugins>

8. <executions>标签

描述： 用于配置特定插件在构建生命周期中的不同阶段执行的行为。每个 <executions> 元素可以包含多个 <execution> 子元素，这些子元素定义了插件的一个执行任务，包括其执行的阶段、目标和其他配置。

<build>
    <plugins>
        <plugin>
            <!-- 插件的基本信息 -->
            <groupId>...</groupId>
            <artifactId>...</artifactId>
            <version>...</version>
            <!-- 执行配置 -->
            <executions>
                <execution>
                    <id>execution-id</id> <!-- 可选：执行的标识符，用于区分多个执行 -->
                    <phase>phase-name</phase> <!-- 可选：指定该执行应绑定的构建生命周期阶段 -->
                    <goals>
                        <goal>goal-name</goal> <!-- 必须：定义要执行的目标（可以有多个） -->
                    </goals>
                    <configuration>
                        <!-- 可选：插件特定的配置项 -->
                    </configuration>
                </execution>
                <!-- 可以有多个 <execution> 元素 -->
            </executions>
        </plugin>
    </plugins>
</build>

9. <execution>子标签解释

<id>: 可选的执行标识符，用于唯一标识每个执行。这在多个 元素存在时特别有用。

<phase>: 指定执行绑定到 Maven 构建生命周期中的特定阶段。比如，compile、test、package、install、deploy 等。如果没有指定 <phase>，插件的执行目标（goal）不会自动绑定到任何生命周期阶段，必须手动调用。

<goals>: 一个或多个 <goal> 标签，指定插件的具体目标（或任务），如 compile、test、package 等。

<configuration>: 为该执行配置插件的特定参数。配置项会覆盖 <plugin> 元素中的<configuration>部分。

10.项目构建总结 （1）<repackage> 目标的作用

（1）重新打包现有的 JAR 或 WAR：它将现有的 JAR 或 WAR 文件重新打包成一个可执行的 JAR 或 WAR。这意味着这个 JAR 或 WAR 包包含了所有的应用程序代码和依赖，并且可以通过 java -jar 命令直接运行。

（2）添加 Spring Boot 启动器：repackage 目标会在生成的 JAR 中添加一个 Spring-Boot-Loader 作为启动器，这个启动器负责处理应用程序的启动和依赖加载。

（3）简化部署：通过创建一个可执行的 JAR 文件，可以大大简化 Spring Boot 应用程序的部署过程，因为不需要将应用程序部署到外部的应用服务器中。

（2）repackage目标的常用配置参数

在使用 <goal>r编程客栈epackage</goal> 时，可以通过<configuration>元素进行多种配置。以下是一些常用的配置参数：

• <classifier>: 生成可执行 JAR 的分类器（例如：exec）。这会影响最终 JAR 文件的名称。
• <mainClass>: 指定主类（即 public static void main(String[] args) 所在的类）。如果没有指定，插件会尝试自动检测。
• <layout>: 指定重新打包 JAR 的布局（例如：JAR、WAR、ZIP、DIR 等）。默认为 JAR。
• <outputDirectory>: 指定重新打包的 JAR 文件的输出目录。默认为项目的构建目录。
• <skip>: 如果设置为 true，则跳过重新打包阶段。

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>3.1.2</version>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal> <!-- 这是 repackage 目标 -->
                    </goals>
                    <configuration>
                        <mainClass>com.example.MyApppythonlication</mainClass> <!-- 指定主类 -->
                        <classifier>exec</classifier> <!-- 设置生成的可执行 JAR 文件的分类器 -->
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugjavascriptins>
</build>

11.基础打包构建示例

    <build>
        <!-- 设置构建的 jar 包名 -->
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 打包 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring.boot.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal> <!-- 将引入的 jar 打入其中 -->
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

到此这篇关于SpringBoot项目构建Maven标签及属性用法详解的文章就介绍到这了,更多相关SpringBoot Maven标签内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！