Maven全网最细学习手册（上篇）

原创 已于 2025-08-28 09:55:03 修改 · 932 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#maven #学习 #java

于 2025-08-28 08:33:52 首次发布

🚀 Maven 全网最细学习手册（上篇）

💡 基础到进阶：掌握Maven核心概念、POM配置、生命周期与插件，为企业级开发打下坚实基础！

📖 学习导航

  • 🎯 适合人群：Java开发初学者、想深入学习Maven的开发者
  • ⏱️ 学习时长：建议3-4天完成上篇内容
  • 🎓 学习目标：掌握Maven核心概念、熟练配置POM文件、理解生命周期和插件机制
  • 📚 学习方式：理论+实践，每个知识点都有详细示例

📚 系列文章导航

  • 📖 上篇：基础概念 + POM配置 + 生命周期与插件
  • 📖 下篇：高级应用 + 多模块项目 + 实战案例 + 最佳实践

📌 第一阶段：Maven 基础概念与环境搭建

🎯 1. Maven 是什么？深度解析

1.1 Maven 的核心作用

Maven（意为"专家"、“内行”）是Apache软件基金会的一个项目管理和构建自动化工具，主要用于Java项目。

🔧 三大核心功能：

  1. 依赖管理：自动下载和管理项目所需的第三方库
  2. 项目构建：编译、测试、打包、部署的自动化流程
  3. 项目标准化：统一的项目结构和构建流程
1.2 Maven vs. 其他构建工具对比
特性MavenAntGradle
配置方式XML声明式XML过程式Groovy/Kotlin DSL
依赖管理✅ 内置强大❌ 需要手动✅ 内置强大
学习曲线中等简单较陡
构建速度中等快最快
生态系统最成熟较少快速发展
企业采用最广泛逐渐减少快速增长
1.3 Maven 的核心思想

🎯 约定优于配置（Convention over Configuration）

  • 标准化的目录结构
  • 预定义的构建生命周期
  • 默认的插件配置
  • 统一的依赖管理方式

💡 好处：

  • 减少配置工作量
  • 提高项目的可维护性
  • 团队协作更加高效
  • 降低学习成本

🛠️ 2. Maven 安装与配置详解

2.1 下载和安装 Maven

📥 下载步骤：

  1. 访问官网：https://maven.apache.org/download.cgi
  2. 选择最新稳定版本（推荐3.8.x或3.9.x）
  3. 下载二进制包：apache-maven-3.9.5-bin.zip

💻 Windows 安装：

# 1. 解压到指定目录（建议无中文路径）
C:\Program Files\Apache\maven\apache-maven-3.9.5

# 2. 配置环境变量
MAVEN_HOME = C:\Program Files\Apache\maven\apache-maven-3.9.5
PATH = %PATH%;%MAVEN_HOME%\bin

# 3. 验证安装
mvn -version

🐧 Linux/Mac 安装：

# 1. 解压
tar -xzf apache-maven-3.9.5-bin.tar.gz
sudo mv apache-maven-3.9.5 /opt/maven

# 2. 配置环境变量（~/.bashrc 或 ~/.zshrc）
export MAVEN_HOME=/opt/maven
export PATH=$PATH:$MAVEN_HOME/bin

# 3. 重新加载配置
source ~/.bashrc

# 4. 验证安装
mvn -version

✅ 安装成功标志：

Apache Maven 3.9.5 (57804ffe001d7215b5e7bcb531cf83df38f93546)
Maven home: /opt/maven
Java version: 11.0.16, vendor: Eclipse Adoptium
Java home: /usr/lib/jvm/temurin-11-jdk-amd64
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "5.4.0-74-generic", arch: "amd64", family: "unix"
2.2 配置 Maven 本地仓库

📁 默认仓库位置：

  • Windows: C:\Users\{用户名}\.m2\repository
  • Linux/Mac: ~/.m2/repository

🔧 自定义仓库位置（settings.xml）：

步骤1：找到settings.xml文件

# Maven安装目录下的全局配置
{MAVEN_HOME}/conf/settings.xml

# 用户目录下的个人配置（优先级更高）
~/.m2/settings.xml

步骤2：配置本地仓库

<?xml version="1.0" encoding="UTF-8"?>
<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>D:\maven\repository</localRepository>
  
  <!-- 离线模式 -->
  <offline>false</offline>
  
  <!-- 插件组 -->
  <pluginGroups>
    <pluginGroup>org.apache.maven.plugins</pluginGroup>
    <pluginGroup>org.codehaus.mojo</pluginGroup>
  </pluginGroups>
  
  <!-- 镜像配置（加速下载） -->
  <mirrors>
    <!-- 阿里云镜像 -->
    <mirror>
      <id>aliyunmaven</id>
      <mirrorOf>*</mirrorOf>
      <name>阿里云公共仓库</name>
      <url>https://maven.aliyun.com/repository/public</url>
    </mirror>
  </mirrors>
  
  <!-- 配置文件 -->
  <profiles>
    <profile>
      <id>jdk-11</id>
      <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>11</jdk>
      </activation>
      <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <maven.compiler.compilerVersion>11</maven.compiler.compilerVersion>
      </properties>
    </profile>
  </profiles>
</settings>

🚀 常用镜像配置：

<!-- 华为云镜像 -->
<mirror>
  <id>huaweicloud</id>
  <mirrorOf>*</mirrorOf>
  <url>https://repo.huaweicloud.com/repository/maven/</url>
</mirror>

<!-- 腾讯云镜像 -->
<mirror>
  <id>nexus-tencentyun</id>
  <mirrorOf>*</mirrorOf>
  <url>http://mirrors.cloud.tencent.com/nexus/repository/maven-public/</url>
</mirror>

📁 3. Maven 项目结构深度解析

3.1 标准目录布局详解
my-project/                    # 项目根目录
├── src/                       # 源代码目录
│   ├── main/                  # 主要源代码
│   │   ├── java/              # Java源代码
│   │   │   └── com/example/   # 包结构
│   │   │       └── App.java   # 主类
│   │   ├── resources/         # 资源文件
│   │   │   ├── application.properties  # 配置文件
│   │   │   ├── logback.xml    # 日志配置
│   │   │   └── static/        # 静态资源
│   │   └── webapp/            # Web应用资源（仅Web项目）
│   │       ├── WEB-INF/       # Web配置
│   │       │   └── web.xml    # Web部署描述符
│   │       ├── css/           # 样式文件
│   │       ├── js/            # JavaScript文件
│   │       └── index.html     # 首页
│   └── test/                  # 测试代码
│       ├── java/              # 测试Java代码
│       │   └── com/example/   # 测试包结构
│       │       └── AppTest.java # 测试类
│       └── resources/         # 测试资源文件
│           └── test.properties # 测试配置
├── target/                    # 编译输出目录（自动生成）
│   ├── classes/               # 编译后的class文件
│   ├── test-classes/          # 测试class文件
│   ├── surefire-reports/      # 测试报告
│   └── my-project-1.0.jar     # 打包后的jar文件
├── pom.xml                    # Maven项目对象模型文件
└── README.md                  # 项目说明文档
3.2 为什么采用这种目录结构？

🎯 设计原则：

  1. 关注点分离：源码、测试、资源分别存放
  2. 约定优于配置：标准化减少配置工作
  3. 构建工具友好：IDE和构建工具都能识别
  4. 团队协作：统一结构便于团队开发

💡 各目录作用详解：

目录作用说明
src/main/java主要Java源代码业务逻辑代码
src/main/resources主要资源文件配置文件、静态资源等
src/main/webappWeb应用资源仅Web项目需要
src/test/java测试Java代码单元测试、集成测试
src/test/resources测试资源文件测试配置文件
target构建输出目录编译、打包结果
3.3 手动创建 Maven 项目

方法1：使用Maven原型（推荐）

# 创建简单Java项目
mvn archetype:generate \
  -DgroupId=com.example \
  -DartifactId=my-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

# 创建Web项目
mvn archetype:generate \
  -DgroupId=com.example \
  -DartifactId=my-web-app \
  -DarchetypeArtifactId=maven-archetype-webapp \
  -DinteractiveMode=false

方法2：手动创建目录结构

# 创建项目根目录
mkdir my-project && cd my-project

# 创建标准目录结构
mkdir -p src/main/java/com/example
mkdir -p src/main/resources
mkdir -p src/test/java/com/example
mkdir -p src/test/resources

# 创建基本的pom.xml文件
touch pom.xml

📝 基础pom.xml模板：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>my-project</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    
    <name>My Project</name>
    <description>A sample Maven project</description>
    
    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <dependencies>
        <!-- JUnit 5 测试框架 -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.9.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

📌 第二阶段：POM 文件深度解析

📋 4. pom.xml 完全详解

POM（Project Object Model）是Maven的核心，包含了项目的所有信息和配置。

4.1 GAV 坐标详解

🎯 GAV坐标是Maven项目的唯一标识符：

<!-- G: Group ID - 组织或公司的标识 -->
<groupId>com.example</groupId>

<!-- A: Artifact ID - 项目的标识 -->
<artifactId>my-project</artifactId>

<!-- V: Version - 版本号 -->
<version>1.0.0-SNAPSHOT</version>

📝 命名规范：

元素命名规范示例
groupId反向域名com.alibaba, org.apache.commons
artifactId项目名称（小写，用连字符分隔）spring-boot, mysql-connector-java
version语义化版本1.0.0, 2.1.3-SNAPSHOT

🔢 版本号规范：

  • SNAPSHOT：开发版本，会自动更新
  • RELEASE：正式发布版本
  • 语义化版本：主版本.次版本.修订版本
    • 主版本：不兼容的API修改
    • 次版本：向下兼容的功能性新增
    • 修订版本：向下兼容的问题修正
4.2 packaging 打包类型
<!-- 打包类型决定了项目的构建方式和输出格式 -->
<packaging>jar</packaging>

📦 常用打包类型：

类型说明输出文件适用场景
jarJava归档文件（默认）.jar普通Java项目、库项目
warWeb应用归档文件.warWeb应用项目
pom仅包含POM文件无父项目、聚合项目
ear企业应用归档文件.earJava EE应用
maven-pluginMaven插件.jarMaven插件开发
4.3 properties 属性配置
<properties>
    <!-- 编译器版本 -->
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>

    <!-- 编码设置 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

    <!-- 依赖版本管理 -->
    <spring.version>5.3.21</spring.version>
    <junit.version>5.9.2</junit.version>
    <mysql.version>8.0.33</mysql.version>

    <!-- 插件版本 -->
    <maven-compiler-plugin.version>3.11.0</maven-compiler-plugin.version>
    <maven-surefire-plugin.version>3.0.0</maven-surefire-plugin.version>

    <!-- 自定义属性 -->
    <project.mainClass>com.example.Application</project.mainClass>
    <docker.image.prefix>example</docker.image.prefix>
</properties>

💡 属性使用方式：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
</dependency>
4.4 dependencies 依赖管理详解
<dependencies>
    <!-- 基础依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
        <!-- 依赖范围 -->
        <scope>compile</scope>
        <!-- 可选依赖 -->
        <optional>false</optional>
        <!-- 排除传递依赖 -->
        <exclusions>
            <exclusion>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>${junit.version}</version>
        <scope>test</scope>
    </dependency>

    <!-- 运行时依赖 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
        <scope>runtime</scope>
    </dependency>

    <!-- 提供的依赖 -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
</dependencies>
4.5 scope 依赖范围详解
范围编译时测试时运行时传递性说明
compile✅✅✅✅默认范围，所有阶段都需要
provided✅✅❌❌编译和测试时需要，运行时由容器提供
runtime❌✅✅✅运行和测试时需要，编译时不需要
test❌✅❌❌仅测试时需要
system✅✅❌❌类似provided，但需要显式指定jar路径
import----仅用于dependencyManagement中导入BOM

🔍 实际应用示例：

<!-- compile: 业务逻辑依赖 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
    <!-- scope默认为compile，可以省略 -->
</dependency>

<!-- provided: Servlet API（Tomcat提供） -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

<!-- runtime: 数据库驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
    <scope>runtime</scope>
</dependency>

<!-- test: 测试框架 -->
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>4.11.0</version>
    <scope>test</scope>
</dependency>
4.6 optional 可选依赖
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.21</version>
    <optional>true</optional>
</dependency>

💡 可选依赖的作用：

  • 当前项目可以使用该依赖
  • 但依赖当前项目的其他项目不会自动获得该依赖
  • 需要显式声明才能使用
4.7 build 构建配置
<build>
    <!-- 最终构建的文件名 -->
    <finalName>my-application</finalName>

    <!-- 源码目录（默认src/main/java） -->
    <sourceDirectory>src/main/java</sourceDirectory>

    <!-- 测试源码目录（默认src/test/java） -->
    <testSourceDirectory>src/test/java</testSourceDirectory>

    <!-- 资源文件配置 -->
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>

    <!-- 插件配置 -->
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <source>11</source>
                <target>11</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>
4.8 parent 父POM继承
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.0</version>
    <relativePath/>
</parent>

💡 继承的内容：

  • 依赖版本管理
  • 插件配置
  • 属性配置
  • 仓库配置
4.9 modules 多模块项目
<modules>
    <module>my-project-core</module>
    <module>my-project-web</module>
    <module>my-project-service</module>
</modules>

🔍 5. 依赖管理深度实践

5.1 如何查找依赖？

🌐 主要依赖搜索网站：

  1. Maven Central Repository

    • 网址：https://search.maven.org/
    • 特点：官方仓库，最权威
    • 使用：搜索artifact名称或groupId

  2. MVN Repository

    • 网址：https://mvnrepository.com/
    • 特点：界面友好，信息详细
    • 优势：显示依赖统计、版本历史

  3. Spring Initializr

    • 网址：https://start.spring.io/
    • 特点：Spring生态专用
    • 优势：自动生成项目结构

🔍 搜索技巧：

# 1. 按类名搜索
搜索关键词：StringUtils
结果：org.apache.commons:commons-lang3

# 2. 按功能搜索
搜索关键词：JSON parser
结果：com.fasterxml.jackson.core:jackson-core

# 3. 按厂商搜索
搜索关键词：alibaba fastjson
结果：com.alibaba:fastjson
5.2 依赖传递性机制

🔗 传递性依赖示例：

项目A 依赖 项目B (1.0)
项目B 依赖 项目C (2.0)
项目B 依赖 项目D (1.5)

结果：项目A 自动获得 项目C (2.0) 和 项目D (1.5)

📊 依赖传递规则：

  1. 最短路径优先

    A → B → C → X (2.0)
A → D → X (1.0)

结果：选择 X (1.0) - 路径更短

  2. 第一声明优先

    <!-- 在pom.xml中的声明顺序 -->
<dependency>
    <groupId>org.example</groupId>
    <artifactId>lib-a</artifactId> <!-- 依赖 X (1.0) -->
</dependency>
<dependency>
    <groupId>org.example</groupId>
    <artifactId>lib-b</artifactId> <!-- 依赖 X (2.0) -->
</dependency>

结果：选择 X (1.0) - 先声明

  3. 覆盖传递依赖

    <!-- 显式声明覆盖传递依赖 -->
<dependency>
    <groupId>org.example</groupId>
    <artifactId>X</artifactId>
    <version>3.0</version> <!-- 覆盖传递的1.0或2.0版本 -->
</dependency>
5.3 依赖冲突解决策略

🔧 查看依赖树：

# 查看完整依赖树
mvn dependency:tree

# 查看特定依赖的冲突
mvn dependency:tree -Dverbose -Dincludes=org.springframework:spring-core

# 分析依赖冲突
mvn dependency:analyze

📋 依赖树输出示例：

[INFO] com.example:my-project:jar:1.0.0
[INFO] +- org.springframework:spring-core:jar:5.3.21:compile
[INFO] |  +- org.springframework:spring-jcl:jar:5.3.21:compile
[INFO] |  \- (commons-logging:commons-logging:jar:1.2:compile - omitted for conflict with 1.1.3)
[INFO] +- commons-logging:commons-logging:jar:1.1.3:compile
[INFO] \- junit:junit:jar:4.13.2:test
[INFO]    \- org.hamcrest:hamcrest-core:jar:1.3:test

🛠️ 解决冲突的方法：

方法1：使用exclusions排除冲突依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.3.21</version>
    <exclusions>
        <!-- 排除冲突的commons-logging -->
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

方法2：显式声明依赖版本

<!-- 显式声明要使用的版本 -->
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

方法3：使用dependencyManagement统一管理

<dependencyManagement>
    <dependencies>
        <!-- 统一版本管理 -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
</dependencyManagement>

📌 第三阶段：Maven 生命周期与插件

🔄 6. Maven 生命周期详解

Maven有三个内置的构建生命周期：Clean、Default和Site。

6.1 Clean 生命周期

🧹 清理项目构建产生的文件

阶段说明
pre-clean执行清理前需要完成的工作
clean清理上一次构建生成的文件
post-clean执行清理后需要完成的工作
# 清理项目
mvn clean

# 清理并编译
mvn clean compile
6.2 Default 生命周期（核心）

🏗️ 项目部署的处理

阶段说明常用命令
validate验证项目是否正确且所有必须信息是可用的-
compile编译项目的源代码mvn compile
test使用合适的单元测试框架测试已编译的源代码mvn test
package接受已编译的代码并打包成可发布的格式mvn package
verify运行任何检查以验证包是否有效且达到质量标准mvn verify
install安装包到本地仓库，以让其它项目依赖mvn install
deploy将最终的包复制到远程仓库mvn deploy

🔍 详细阶段说明：

# 1. 编译主代码
mvn compile
# 编译 src/main/java 下的Java文件到 target/classes

# 2. 编译测试代码
mvn test-compile
# 编译 src/test/java 下的测试文件到 target/test-classes

# 3. 运行测试
mvn test
# 运行单元测试，生成测试报告

# 4. 打包项目
mvn package
# 根据packaging类型打包（jar/war/ear等）

# 5. 安装到本地仓库
mvn install
# 将项目安装到本地Maven仓库

# 6. 部署到远程仓库
mvn deploy
# 将项目部署到远程Maven仓库
6.3 Site 生命周期

📄 创建项目站点文档

阶段说明
pre-site执行生成站点前需要完成的工作
site生成项目的站点文档
post-site执行生成站点后需要完成的工作
site-deploy将生成的站点文档部署到特定的服务器
# 生成项目站点
mvn site

# 生成并部署站点
mvn site-deploy
6.4 生命周期阶段的执行顺序

⚡ 重要特性：

  • 执行某个阶段时，会自动执行该阶段之前的所有阶段
  • 不同生命周期之间相互独立
# 执行package时的完整流程
mvn package

# 实际执行顺序：
# 1. validate
# 2. initialize
# 3. generate-sources
# 4. process-sources
# 5. generate-resources
# 6. process-resources
# 7. compile
# 8. process-classes
# 9. generate-test-sources
# 10. process-test-sources
# 11. generate-test-resources
# 12. process-test-resources
# 13. test-compile
# 14. process-test-classes
# 15. test
# 16. prepare-package
# 17. package

🔌 7. Maven 插件详解

Maven的核心功能都是通过插件实现的。每个生命周期阶段都绑定了特定的插件目标。

7.1 插件的基本概念

🎯 插件目标（Plugin Goal）

  • 插件是由一个或多个目标组成的
  • 目标是插件中的一个功能单元
  • 格式：插件前缀:目标 或 groupId:artifactId:version:goal
# 执行编译插件的compile目标
mvn compiler:compile

# 执行依赖插件的tree目标
mvn dependency:tree
7.2 常用插件详解

🔧 maven-compiler-plugin（编译插件）

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.11.0</version>
    <configuration>
        <!-- Java版本 -->
        <source>11</source>
        <target>11</target>
        <!-- 编码格式 -->
        <encoding>UTF-8</encoding>
        <!-- 编译参数 -->
        <compilerArgs>
            <arg>-parameters</arg>
            <arg>-Xlint:unchecked</arg>
        </compilerArgs>
        <!-- 是否显示详细信息 -->
        <verbose>true</verbose>
        <!-- 是否显示弃用警告 -->
        <showDeprecation>true</showDeprecation>
        <!-- 是否显示警告 -->
        <showWarnings>true</showWarnings>
    </configuration>
</plugin>

🧪 maven-surefire-plugin（测试插件）

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0</version>
    <configuration>
        <!-- 跳过测试 -->
        <skipTests>false</skipTests>
        <!-- 测试失败时是否忽略 -->
        <testFailureIgnore>false</testFailureIgnore>
        <!-- 包含的测试文件 -->
        <includes>
            <include>**/*Test.java</include>
            <include>**/*Tests.java</include>
        </includes>
        <!-- 排除的测试文件 -->
        <excludes>
            <exclude>**/*IntegrationTest.java</exclude>
        </excludes>
        <!-- 并行执行 -->
        <parallel>methods</parallel>
        <threadCount>4</threadCount>
        <!-- 系统属性 -->
        <systemPropertyVariables>
            <spring.profiles.active>test</spring.profiles.active>
        </systemPropertyVariables>
    </configuration>
</plugin>

📦 maven-jar-plugin（JAR打包插件）

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.3.0</version>
    <configuration>
        <!-- 归档配置 -->
        <archive>
            <!-- 清单文件配置 -->
            <manifest>
                <!-- 添加classpath -->
                <addClasspath>true</addClasspath>
                <!-- classpath前缀 -->
                <classpathPrefix>lib/</classpathPrefix>
                <!-- 主类 -->
                <mainClass>com.example.Application</mainClass>
            </manifest>
            <!-- 清单条目 -->
            <manifestEntries>
                <Built-By>Maven</Built-By>
                <Build-Jdk>${java.version}</Build-Jdk>
                <Implementation-Version>${project.version}</Implementation-Version>
            </manifestEntries>
        </archive>
        <!-- 排除文件 -->
        <excludes>
            <exclude>**/*.properties</exclude>
        </excludes>
    </configuration>
</plugin>

🌐 maven-war-plugin（WAR打包插件）

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.3.2</version>
    <configuration>
        <!-- WAR文件名 -->
        <warName>my-web-app</warName>
        <!-- 是否失败在缺少web.xml -->
        <failOnMissingWebXml>false</failOnMissingWebXml>
        <!-- Web资源目录 -->
        <webResources>
            <resource>
                <directory>src/main/webapp</directory>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.html</include>
                    <include>**/*.jsp</include>
                </includes>
            </resource>
        </webResources>
        <!-- 归档配置 -->
        <archive>
            <manifest>
                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
            </manifest>
        </archive>
    </configuration>
</plugin>

🎁 maven-assembly-plugin（自定义打包插件）

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.4.2</version>
    <configuration>
        <!-- 描述符 -->
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <!-- 主类 -->
        <archive>
            <manifest>
                <mainClass>com.example.Application</mainClass>
            </manifest>
        </archive>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>
7.3 插件执行配置

⚙️ executions 执行配置

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <!-- 在compile阶段执行 -->
        <execution>
            <id>compile-phase-execution</id>
            <phase>compile</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <target>
                    <echo message="编译阶段执行自定义任务"/>
                    <mkdir dir="${project.build.directory}/custom"/>
                </target>
            </configuration>
        </execution>

        <!-- 在package阶段执行 -->
        <execution>
            <id>package-phase-execution</id>
            <phase>package</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <target>
                    <echo message="打包阶段执行自定义任务"/>
                    <copy todir="${project.build.directory}/custom">
                        <fileset dir="${project.build.directory}/classes"/>
                    </copy>
                </target>
            </configuration>
        </execution>
    </executions>
</plugin>

📚 上篇总结与下篇预告

🎯 上篇学习成果检验

通过上篇的学习，您应该掌握：

✅ 基础概念

  • Maven的核心作用和设计思想
  • 标准项目结构和目录布局
  • 环境安装和配置优化

✅ POM文件配置

  • GAV坐标系统和命名规范
  • 依赖管理和scope范围
  • 属性配置和构建设置
  • 依赖冲突的识别和解决

✅ 生命周期与插件

  • 三大生命周期的阶段和作用
  • 常用插件的配置和使用
  • 插件执行的绑定和配置

🚀 下篇内容预告

在下篇中，我们将深入探讨：

📌 第四阶段：高级应用

  • 🏗️ 多模块项目管理：父子POM配置、模块依赖、构建策略
  • 🎛️ Profile配置管理：多环境配置、条件激活、属性覆盖
  • 📦 仓库管理：本地/远程仓库、镜像配置、部署策略

📌 第五阶段：实战案例与最佳实践

  • 🎯 Spring Boot项目实战：完整项目配置、Docker集成
  • ⚡ 常用命令大全：依赖管理、插件操作、高级选项
  • 🔧 故障排除指南：常见问题诊断、调试技巧、性能优化
  • 🏆 最佳实践：项目结构规范、版本管理、构建优化

📚 继续学习：建议先通过实际项目练习上篇内容，熟悉Maven的基础操作后，再继续学习下篇的高级应用和实战案例。

💡 学习建议：上篇内容是Maven学习的基础，建议通过创建实际项目来练习POM配置、依赖管理和插件使用，为学习下篇的高级内容做好准备。

2025最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 10万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
Maven全网最细学习手册（下篇）
CodingPhilosophy的博客
08-28 585
探讨Maven高级应用，涵盖多模块项目管理、Profile环境配置、仓库部署策略，通过Spring Boot实战案例、故障排除指南与最佳实践，成为Maven专家
Gradle全网最细学习手册（下篇）
CodingPhilosophy的博客
08-28 918
掌握多项目构建、自定义插件开发、性能优化，通过完整实战案例成为Gradle专家
Gradle全网最细学习手册（上篇）
CodingPhilosophy的博客
08-28 848
掌握Gradle核心概念、DSL语法、任务系统，体验比Maven更快更灵活的构建体验
手把手教你给Maven换装阿里云极速引擎（全网最细配置指南）
pythonqiang9的博客
05-16 760
记得每半年检查一次镜像配置，就像给爱车做保养！遇到诡异问题欢迎评论区留言，看到必回~（别问我为什么这么热心，都是被慢速下载虐过来的 T_T）下次更新预告：《Maven依赖冲突核弹级解决方案——dependencyTree使用秘籍》，关注不迷路！
全网最详细的 Maven 教程！
weixin_45727359的博客
09-02 1971
前言：目前所有的项目都在使用maven，可是一直没有时间去整理学习，这两天正好有时间，好好的整理一下。一、为什么使用Maven这样的构建工具【why】① 一个项目就是一个工程如果项目非常庞...
在GitHub上24小时星标31K+的Java后端学习路线+全网最全面试手册
Java_Pluto的博客
06-01 2884
2021年的互联网行业竞争越来越严峻，面试也是越来越难，一直以来我都想整理一套完美的面试宝典，奈何难抽出时间，这套完整的java后端学习路线以及1000+道的Java面试手册我整理了整整1个月，上传到Git上目前star数达到了30K+ 这套互联网Java工程师面试题包括了：MyBatis、ZK、Dubbo、EL、Redis、MySQL、并发编程、Java面试、Spring、微服务、Linux、Springboot、SpringCloud、MQ、Kafka面试专题（共946页，32W字） 在写这个文章之前，
Java最新面试题（全网最全、最细、附答案）
热门推荐
javaeEEse的博客
06-13 20万+
Java 语言具有多种显著特点，使其成为广泛应用的编程语言。首先，Java 是面向对象的，支持封装、继承和多态三大特性，代码以类和对象为组织单位。其次，Java 具有平台无关性，通过 Java 虚拟机（JVM）实现跨平台运行，编译后的字节码可在不同操作系统上执行。Java 是强类型语言，所有变量必须先声明类型，并在编译时进行严格类型检查。此外，Java 提供自动内存管理，通过垃圾回收（GC）机制减少内存泄漏风险，并内置多线程支持，通过 Thread 类或 Runnable 接口创建线程。
全网最全！B站上网友疯传 ~
03-05 306
利用空闲时间给大家整理了Java面试手册，在原来的基础上新加了13个专题。小编亲自整理，大家支持一下哈～第一版包括:Java基础、Java集合、异常&反射、IO&NIO、J...
灵魂一击！全网最细MyBatis使用手册（收藏起来慢慢啃！）
Java圈全能架构师的博客
11-21 1290
MyBatis MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 越来越多的企业已经将 MyBatis 使用到了正式的生产环境，本文就使用 MyBatis 的几种方式提供简单的示例，以及如何对数据库密码进行
Spring Boot入门(07)：整合 MySQL 和 Druid数据源 | 全网最详细保姆级教学(两万字)
**My Coding Family**
08-16 2万+
在Spring Boot中，整合MySQL和Druid数据源是不可或缺的一步。本文将为您介绍最详细的保姆级教学，从配置pom.xml到创建数据库、数据表，再到编写Java代码，一步一步地带您实现整合MySQL和Druid数据源。文章总字数达到两万字，细致全面，绝不让您失望。来一起学习吧！
【1】kettle的使用（全网最新版）
铁盒薄荷糖的博客
06-17 1180
Kettle 是一款开源的 ETL 工具，纯 java 编写1、Kettle工程存储方式（1）以 XML 形式存储（2）以资源库方式存储 (数据库资源库 和 文件资源库)2、Kettle的两种设计转换 (transformation )：完成对数据的 基础转换。作业 (job) ：控制完成整个工作流。区别：①作业是步骤过程，转换针对数据流。这是最大的区别。②作业的每一个步骤，需要等前面的步骤跑完了才能执行；
springboot之常用注解（全网最详细，保姆教程，一步一步教你操作）
weixin_42242910的博客
12-11 1242
（所以如果只写一个@Controller，不加@ResponseBody的话，访问该网址http://localhost:8080/param/user，就会报错，因为他会去找网址，找不到就报错）（1）在包中（com/example/boot303demo）新建一个entity包，再在entity包下新建一个User类。重新运行主类，输入网址访问：http://localhost:8080/rest/get。重新运行主类，访问网址：http://localhost:8080/param/user。
SpringBoot Maven 项目 pom 中的 plugin 插件用法整理
最新发布
2509_94005785的博客
11-25 333
把 SpringBoot Maven 项目打包成 jar 文件时，我们通常用到 spring-boot-maven-plugin 插件。前面也介绍过，在 spring-boot-starter-parent POM 和 spring-boot-starter POM 中都有插件的管理，现在我们就撸一把构建元素中插件的用法。project 标签指定项目的声明。modelVersion 标签指定 POM 模型的版本。目前使用的是 4.0.0 版本。这是 Maven 项目的根元素，定义了项目模型的版本。
从 0 开始：在 WSL + VSCode 上利用 Maven 构建 Java Spring Boot 工程
charlie114514191的博客
11-22 831
摘要：本文介绍了在WSL+VSCode环境下快速搭建Java Spring Boot项目的完整流程。从安装WSL和OpenJDK 21开始，到配置Maven和VSCode的Java扩展，重点演示了使用VSCode的Spring Initializr插件快速生成Spring Boot项目，并创建简单的REST Controller。文章还提供了Maven常用命令速查表，帮助开发者快速上手Spring Boot开发。通过这种现代化开发方式，开发者可以在Windows系统中获得接近原生Linux的开发体验。
Eclipse配置Maven详细教程[通俗易懂]
qq_43494013的博客
11-22 1118
Eclipse配置Maven详细教程[通俗易懂]
SpringBoot Maven快速上手
2509_94004335的博客
11-25 421
官方对于 Maven 的描述：Maven 官网翻译过来就是：Maven 是一个项目管理工具。基于 POM (Project Object Model，项目对象模型）的概念，Maven 可以通过一小段描述信息来管理项目的构建，报告和文档的项目管理工具软件。POM 简介：每一个 Maven 工程都有一个pom.xml文件，位于根目录中，包含项目构建生命周期的详细信息。通过pom.xml文件，我们可以定义项目的坐标、项目依赖、项目信息、插件信息等等配置。
Maven NUL文件问题 - 解决方案实施报告
u011265143的专栏
11-24 831
在Windows系统下运行Maven测试时，`smart-ai/target/surefire-reports/` 目录下会生成名为 `nul` 的文件，导致： - ❌ Maven clean 命令失败，报错：`Failed to delete D:\...\surefire-reports` - ❌ 无法通过常规方法删除该文件 - ❌ 删除后立即重新生成
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值