IntelliJ IDEA运行Maven项目实战教程从环境配置到项目部署解决开发过程中可能遇到的各种问题助你成为高效Java开发者

引言

IntelliJ IDEA作为目前最流行的Java集成开发环境(IDE)之一，与Maven项目构建工具的结合使用，已成为Java开发者的标准配置。Maven通过其强大的依赖管理和项目构建能力，极大地简化了Java项目的开发流程。本文将详细介绍从环境配置到项目部署的全过程，帮助开发者解决在实际开发中可能遇到的各种问题，提高开发效率。

环境配置

JDK安装与配置

Java开发工具包(JDK)是Java开发的基础，确保安装正确版本的JDK至关重要。

下载JDK：访问Oracle官网或OpenJDK官网，下载适合你操作系统的JDK版本。推荐使用JDK 8或以上版本，以获得更好的性能和新特性支持。
安装JDK：按照安装向导完成安装过程。Windows系统下，记住安装路径；macOS和Linux系统通常会将JDK安装到标准目录。

配置环境变量：

Windows系统： “`bash
新建系统变量JAVA_HOME
JAVA_HOME=C:Program FilesJavajdk-11.0.12

# 编辑Path变量，添加以下内容 %JAVA_HOME%bin

 - macOS/Linux系统： ```bash # 编辑~/.bash_profile或~/.zshrc文件（根据使用的shell） export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-11.0.12.jdk/Contents/Home export PATH=$JAVA_HOME/bin:$PATH # 使配置生效 source ~/.bash_profile # 或 source ~/.zshrc

验证安装：
```
java -version javac -version 
```
如果正确显示Java版本，说明JDK安装成功。

IntelliJ IDEA安装与配置

下载IntelliJ IDEA：访问JetBrains官网，下载IntelliJ IDEA。有两种版本可供选择：Ultimate版（付费，功能全面）和Community版（免费，适合Java SE开发）。
安装IntelliJ IDEA：按照安装向导完成安装过程。
首次配置：
- 选择主题和编辑器颜色方案
- 配置默认插件
- 导入已有配置（如果有）
JVM配置（可选）：如果需要调整IntelliJ IDEA的内存使用，可以修改idea64.exe.vmoptions（Windows）或idea.vmoptions（macOS/Linux）文件：
```
-Xms1024m -Xmx4096m -XX:ReservedCodeCacheSize=512m 
```

Maven安装与配置

虽然IntelliJ IDEA内置了Maven，但独立安装Maven可以确保版本一致性和更好的控制。

下载Maven：访问Maven官网，下载最新的稳定版本。
安装Maven：解压下载的压缩包到指定目录，如C:Program FilesApachemaven（Windows）或/opt/maven（Linux）。

配置环境变量：

Windows系统： “`bash
新建系统变量MAVEN_HOME
MAVEN_HOME=C:Program FilesApachemaven

# 编辑Path变量，添加以下内容 %MAVEN_HOME%bin

 - macOS/Linux系统： ```bash # 编辑~/.bash_profile或~/.zshrc文件 export MAVEN_HOME=/opt/maven export PATH=$MAVEN_HOME/bin:$PATH # 使配置生效 source ~/.bash_profile # 或 source ~/.zshrc

验证安装：
```
mvn -version 
```
如果正确显示Maven版本，说明安装成功。
配置Maven设置文件（settings.xml）：通常位于$MAVEN_HOME/conf/settings.xml，可以配置本地仓库位置、镜像服务器等： “`xml /path/to/your/local/repo

 <mirror> <id>aliyun</id> <mirrorOf>central</mirrorOf> <name>Aliyun Maven Central</name> <url>https://maven.aliyun.com/repository/central</url> </mirror>

 ### 在IntelliJ IDEA中配置Maven 1. 打开IntelliJ IDEA，进入`File > Settings`（Windows/Linux）或`IntelliJ IDEA > Preferences`（macOS）。 2. 导航到`Build, Execution, Deployment > Build Tools > Maven`。 3. 配置Maven home path：选择你安装的Maven目录，而不是使用IDE捆绑的版本。 4. 配置User settings file：指向你的自定义settings.xml文件。 5. 配置Local repository：通常会自动根据settings.xml文件中的配置填充。 6. 在`Maven > Importing`设置中，可以配置： - Automatically download：Sources和Documentation - VM options for importer：可以增加内存设置，如`-Xmx1024m` - Use Maven3 to import project：确保勾选 7. 在`Maven > Running`设置中，可以配置： - VM Options：可以增加内存设置，如`-Xmx1024m -XX:MaxPermSize=512m` - Environment variables：可以添加必要的环境变量 ## 创建Maven项目 ### 使用IntelliJ IDEA创建Maven项目 1. 打开IntelliJ IDEA，选择`File > New > Project`。 2. 在左侧选择`Maven`。 3. 配置项目SDK：选择已安装的JDK版本。 4. 选择Create from archetype（如果需要使用特定模板）： - 常用archetype包括： - `maven-archetype-quickstart`：简单的Java项目 - `maven-archetype-webapp`：Java Web项目 - `org.apache.maven.archetypes:maven-archetype-quickstart`：标准的Java项目 5. 点击Next，填写项目信息： - GroupId：通常是公司或组织域名的倒序，如`com.example` - ArtifactId：项目名称，如`my-app` - Version：项目版本，默认为`1.0-SNAPSHOT` 6. 点击Next，确认Maven设置和项目名称、位置。 7. 点击Finish，IntelliJ IDEA将创建项目结构并下载必要的依赖。 ### Maven项目结构解析 标准的Maven项目结构如下：

my-app/ ├── src/ │ ├── main/ │ │ ├── java/ # Java源代码 │ │ │ └── com/ │ │ │ └── example/ │ │ │ └── App.java │ │ ├── resources/ # 资源文件 │ │ │ └── application.properties │ │ └── webapp/ # Web应用资源（如果是Web项目） │ │ ├── WEB-INF/ │ │ │ └── web.xml │ │ └── index.jsp │ └── test/ │ ├── java/ # 测试源代码 │ │ └── com/ │ │ └── example/ │ │ └── AppTest.java │ └── resources/ # 测试资源文件 ├── target/ # 构建输出目录 ├── pom.xml # Maven项目配置文件 └── my-app.iml # IntelliJ IDEA模块文件

 ### pom.xml文件详解 pom.xml是Maven项目的核心配置文件，定义了项目的基本信息、依赖、构建配置等。 一个基本的pom.xml文件结构如下： ```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-app</artifactId> <version>1.0-SNAPSHOT</version> <packaging>jar</packaging> <!-- 打包类型，可以是jar, war, pom等 --> <name>My Application</name> <description>A sample Maven project</description> <!-- 属性定义 --> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>11</maven.compiler.source> <maven.compiler.target>11</maven.compiler.target> <junit.version>5.8.2</junit.version> </properties> <!-- 依赖管理 --> <dependencies> <!-- JUnit 5 依赖 --> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-engine</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> <!-- 其他依赖示例 --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.12.0</version> </dependency> </dependencies> <!-- 构建配置 --> <build> <plugins> <!-- Maven编译插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>11</source> <target>11</target> </configuration> </plugin> <!-- Maven Surefire插件，用于运行单元测试 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>3.0.0-M5</version> </plugin> </plugins> </build> </project>

依赖管理

添加依赖

在Maven项目中，添加依赖非常简单，只需在pom.xml文件的<dependencies>部分添加相应的依赖声明即可。

例如，添加Spring Boot Starter Web依赖：

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.6.3</version> </dependency>

在IntelliJ IDEA中，更简单的方法是：

打开pom.xml文件
在代码编辑器中右键，选择Generate > Dependency
在弹出的对话框中搜索所需的依赖
选择依赖版本并点击添加

IntelliJ IDEA还提供了Maven工具窗口，可以通过该窗口快速添加依赖：

打开右侧的Maven工具窗口
展开项目，选择Dependencies
右键点击，选择Add Dependency
在弹出的对话框中搜索并添加依赖

依赖范围

Maven提供了多种依赖范围（scope），用于控制依赖在不同阶段（编译、测试、运行）的可见性。

常见的依赖范围包括：

compile（默认范围）：在所有阶段都可用，会传递到依赖项目中。

<dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.3.15</version> <scope>compile</scope> <!-- 可以省略，因为这是默认值 --> </dependency>

provided：在编译和测试阶段可用，但在运行时由容器提供（如Servlet API）。

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

runtime：在运行和测试阶段可用，但在编译时不需要（如JDBC驱动）。

<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> <scope>runtime</scope> </dependency>

test：仅在测试阶段可用，不会传递到依赖项目中。

<dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.8.2</version> <scope>test</scope> </dependency>

system：类似于provided，但需要显式提供JAR文件。不推荐使用。

<dependency> <groupId>com.example</groupId> <artifactId>custom-library</artifactId> <version>1.0</version> <scope>system</scope> <systemPath>${project.basedir}/lib/custom-library-1.0.jar</systemPath> </dependency>

import：仅用于<dependencyManagement>部分，用于导入依赖管理信息。

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

依赖冲突解决

当项目中的多个依赖依赖于同一个库的不同版本时，就会发生依赖冲突。Maven使用”最近定义策略”来解决依赖冲突，即使用依赖树中离项目最近的版本。

解决依赖冲突的几种方法：

使用mvn dependency:tree命令查看依赖树：
```
mvn dependency:tree 
```
在IntelliJ IDEA中，可以打开Maven工具窗口，点击Show Dependencies按钮查看依赖图。

使用<exclusions>排除不需要的依赖：

<dependency> <groupId>com.example</groupId> <artifactId>example-library</artifactId> <version>1.0.0</version> <exclusions> <exclusion> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> </exclusion> </exclusions> </dependency>

在<dependencyManagement>中明确指定依赖版本：

<dependencyManagement> <dependencies> <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>1.2</version> </dependency> </dependencies> </dependencyManagement>

使用Maven Helper插件（IntelliJ IDEA插件）：
- 安装Maven Helper插件
- 打开pom.xml文件，切换到Dependency Analyzer选项卡
- 查看冲突并快速排除

构建和运行Maven项目

使用Maven命令构建项目

Maven提供了一系列命令用于构建项目，常用的命令包括：

mvn clean：清理项目，删除target目录
mvn compile：编译项目源代码
mvn test：运行单元测试
mvn package：打包项目，生成JAR或WAR文件
mvn install：将打包好的文件安装到本地仓库
mvn deploy：将项目部署到远程仓库

这些命令可以组合使用，例如：

mvn clean package # 清理并打包项目 mvn clean install # 清理、编译、测试、打包并安装到本地仓库

在IntelliJ IDEA中，可以通过以下方式执行Maven命令：

打开Maven工具窗口
展开项目生命周期
双击要执行的生命周期阶段

或者，使用IntelliJ IDEA的终端执行Maven命令。

在IntelliJ IDEA中运行Maven项目

在IntelliJ IDEA中运行Maven项目有多种方式，具体取决于项目类型。

运行Java应用程序

创建运行配置：
- 点击右上角的运行配置下拉菜单
- 选择Edit Configurations...
- 点击+号，选择Application
- 配置Main class（主类）
- 设置程序参数和VM选项（如果需要）
- 点击OK保存配置
运行应用程序：
- 点击工具栏上的运行按钮（绿色三角形）
- 或使用快捷键Shift+F10（运行）/ Shift+F9（调试）

运行Web应用程序

配置应用服务器：
- 打开File > Settings > Build, Execution, Deployment > Application Servers
- 点击+号，选择服务器类型（如Tomcat）
- 配置服务器名称和路径
- 点击OK
创建运行配置：
- 点击右上角的运行配置下拉菜单
- 选择Edit Configurations...
- 点击+号，选择Tomcat Server > Local
- 配置服务器名称和端口
- 切换到Deployment选项卡
- 点击+号，选择Artifact，选择要部署的WAR或EAR文件
- 点击OK保存配置
运行Web应用程序：
- 点击工具栏上的运行按钮
- 或使用快捷键Shift+F10（运行）/ Shift+F9（调试）

运行Spring Boot应用程序

创建运行配置：
- 点击右上角的运行配置下拉菜单
- 选择Edit Configurations...
- 点击+号，选择Spring Boot
- 选择主类
- 设置程序参数和VM选项（如果需要）
- 点击OK保存配置
运行Spring Boot应用程序：
- 点击工具栏上的运行按钮
- 或使用快捷键Shift+F10（运行）/ Shift+F9（调试）

调试Maven项目

IntelliJ IDEA提供了强大的调试功能，可以帮助开发者快速定位和解决问题。

设置断点

在代码行号旁边单击，设置断点（红色圆点）
可以设置条件断点：右键点击断点，设置条件
可以设置日志断点：右键点击断点，取消”Suspend”选项，勾选”Evaluate and log”

启动调试会话

点击工具栏上的调试按钮（带虫子的图标）
或使用快捷键Shift+F9

调试工具窗口

调试工具窗口提供了以下功能：

变量查看：查看当前作用域的变量值
表达式求值：计算表达式的值
帧管理：查看调用栈
线程管理：查看和切换线程
控制执行：
- F8：Step Over（单步跳过）
- F7：Step Into（单步进入）
- Shift+F8：Step Out（单步退出）
- F9：Resume Program（恢复程序）

远程调试

对于部署在远程服务器上的应用程序，可以使用远程调试：

启动远程应用程序时添加调试参数：

java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -jar my-app.jar

在IntelliJ IDEA中创建远程调试配置：
- 点击右上角的运行配置下拉菜单
- 选择Edit Configurations...
- 点击+号，选择Remote
- 配置名称和端口（与远程应用程序的端口一致）
- 点击OK保存配置
启动远程调试会话：
- 选择远程调试配置
- 点击调试按钮

常见问题及解决方案

依赖下载问题

问题描述

在构建Maven项目时，依赖下载失败或速度缓慢。

解决方案

检查网络连接和Maven镜像配置：

<mirrors> <mirror> <id>aliyun</id> <mirrorOf>central</mirrorOf> <name>Aliyun Maven Central</name> <url>https://maven.aliyun.com/repository/central</url> </mirror> </mirrors>

清理Maven本地仓库并重新下载：
```
mvn clean install -U 
```

手动下载并安装缺失的依赖：

mvn install:install-file -Dfile=path/to/your.jar -DgroupId=com.example -DartifactId=example-library -Dversion=1.0 -Dpackaging=jar

使用离线模式（如果依赖已存在于本地仓库）：
```
mvn -o clean install 
```
在IntelliJ IDEA中，可以尝试以下操作：
- 打开Maven工具窗口
- 点击”刷新”按钮
- 或右键点击项目，选择”Maven > Reimport”

编译问题

问题描述

项目编译失败，出现各种编译错误。

解决方案

检查JDK版本兼容性：

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

检查Maven编译插件配置：

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>11</source> <target>11</target> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </build>

增加编译内存：

export MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=512m"

在IntelliJ IDEA中：
- 检查项目SDK设置
- 检查模块的Language Level设置
- 尝试使用File > Invalidate Caches / Restart清除缓存并重启IDE

处理注解处理器问题：

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <annotationProcessorPaths> <path> <groupId>org.mapstruct</groupId> <artifactId>mapstruct-processor</artifactId> <version>1.4.2.Final</version> </path> </annotationProcessorPaths> </configuration> </plugin> </plugins> </build>

运行问题

问题描述

项目编译成功，但运行时出现错误。

解决方案

检查主类配置：

<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>2.6.3</version> <configuration> <mainClass>com.example.Application</mainClass> </configuration> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build>

检查运行时依赖：
```
mvn dependency:tree 
```

增加JVM内存：

export MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=512m"

在IntelliJ IDEA中：
- 检查运行配置
- 增加VM选项：-Xmx1024m -XX:MaxPermSize=512m
- 检查环境变量和工作目录设置

处理类加载问题：

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>3.0.0-M5</version> <configuration> <useSystemClassLoader>false</useSystemClassLoader> </configuration> </plugin> </plugins> </build>

插件问题

问题描述

Maven插件执行失败或版本不兼容。

解决方案

更新插件版本：

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

在插件管理中统一插件版本：

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

跳过插件执行（临时解决方案）：

mvn clean install -DskipTests mvn clean install -Dmaven.test.skip=true

在IntelliJ IDEA中：
- 检查Maven设置
- 尝试使用File > Invalidate Caches / Restart清除缓存并重启IDE
- 检查项目Maven配置

项目部署

打包应用

Maven提供了多种打包方式，具体取决于项目类型。

打包为JAR文件

对于Java应用程序，通常打包为JAR文件：

配置打包类型：
```
<packaging>jar</packaging> 
```

使用Maven JAR插件：

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <version>3.2.0</version> <configuration> <archive> <manifest> <addClasspath>true</addClasspath> <mainClass>com.example.Application</mainClass> </manifest> </archive> </configuration> </plugin> </plugins> </build>

创建可执行JAR（包含所有依赖）：

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-assembly-plugin</artifactId> <version>3.3.0</version> <configuration> <descriptorRefs> <descriptorRef>jar-with-dependencies</descriptorRef> </descriptorRefs> <archive> <manifest> <mainClass>com.example.Application</mainClass> </manifest> </archive> </configuration> <executions> <execution> <phase>package</phase> <goals> <goal>single</goal> </goals> </execution> </executions> </plugin> </plugins> </build>

使用Spring Boot Maven插件（对于Spring Boot应用）：

<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>2.6.3</version> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build>

执行打包命令：
```
mvn clean package 
```

打包为WAR文件

对于Web应用程序，通常打包为WAR文件：

配置打包类型：
```
<packaging>war</packaging> 
```

配置WAR插件：

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-war-plugin</artifactId> <version>3.3.2</version> <configuration> <warSourceDirectory>src/main/webapp</warSourceDirectory> <failOnMissingWebXml>false</failOnMissingWebXml> </configuration> </plugin> </plugins> </build>

对于Spring Boot应用，还需要：

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <scope>provided</scope> </dependency> </dependencies>

执行打包命令：
```
mvn clean package 
```

部署到Tomcat

使用IntelliJ IDEA部署到本地Tomcat

配置Tomcat服务器：
- 打开File > Settings > Build, Execution, Deployment > Application Servers
- 点击+号，选择Tomcat Server
- 配置Tomcat名称和路径
- 点击OK
创建运行配置：
- 点击右上角的运行配置下拉菜单
- 选择Edit Configurations...
- 点击+号，选择Tomcat Server > Local
- 配置服务器名称和端口
- 切换到Deployment选项卡
- 点击+号，选择Artifact，选择要部署的WAR文件
- 点击OK保存配置
部署并运行：
- 点击工具栏上的运行按钮
- Tomcat将启动并部署应用程序

手动部署到Tomcat

将WAR文件复制到Tomcat的webapps目录：

cp target/my-app.war /path/to/tomcat/webapps/

启动Tomcat：

/path/to/tomcat/bin/startup.sh # Linux/macOS /path/to/tomcat/bin/startup.bat # Windows

访问应用程序：
```
http://localhost:8080/my-app/ 
```

使用Maven Tomcat插件部署

配置Tomcat插件：

<build> <plugins> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> <configuration> <url>http://localhost:8080/manager/text</url> <server>TomcatServer</server> <path>/my-app</path> </configuration> </plugin> </plugins> </build>

在Maven的settings.xml中配置Tomcat服务器凭据：

<servers> <server> <id>TomcatServer</id> <username>admin</username> <password>password</password> </server> </servers>

部署到Tomcat：
```
mvn tomcat7:deploy 
```
重新部署：
```
mvn tomcat7:redeploy 
```
取消部署：
```
mvn tomcat7:undeploy 
```

部署到其他服务器

部署到JBoss/WildFly

配置JBoss插件：

<build> <plugins> <plugin> <groupId>org.wildfly.plugins</groupId> <artifactId>wildfly-maven-plugin</artifactId> <version>2.0.2.Final</version> <configuration> <hostname>localhost</hostname> <port>9990</port> <username>admin</username> <password>password</password> </configuration> </plugin> </plugins> </build>

部署到JBoss/WildFly：
```
mvn wildfly:deploy 
```

部署到Docker

使用Docker Maven插件：

<build> <plugins> <plugin> <groupId>com.spotify</groupId> <artifactId>docker-maven-plugin</artifactId> <version>1.2.2</version> <configuration> <imageName>my-app</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <targetPath>/</targetPath> <directory>${project.build.directory}</directory> <include>${project.build.finalName}.jar</include> </resource> </resources> </configuration> </plugin> </plugins> </build>

创建Dockerfile：

FROM openjdk:11 VOLUME /tmp ADD my-app.jar app.jar ENTRYPOINT ["java","-jar","/app.jar"]

构建Docker镜像：
```
mvn clean package docker:build 
```
运行Docker容器：
```
docker run -p 8080:8080 -t my-app 
```

高级技巧

使用Maven Profile

Maven Profile允许根据不同环境（开发、测试、生产等）使用不同的配置。

定义Profile：

<profiles> <profile> <id>dev</id> <activation> <activeByDefault>true</activeByDefault> </activation> <properties> <environment>dev</environment> <database.url>jdbc:mysql://localhost:3306/dev_db</database.url> </properties> </profile> <profile> <id>test</id> <properties> <environment>test</environment> <database.url>jdbc:mysql://test-server:3306/test_db</database.url> </properties> </profile> <profile> <id>prod</id> <properties> <environment>prod</environment> <database.url>jdbc:mysql://prod-server:3306/prod_db</database.url> </properties> </profile> </profiles>

使用Profile：
```
mvn clean package -Pprod 
```
在IntelliJ IDEA中激活Profile：
- 打开Maven工具窗口
- 点击”Profiles”按钮
- 选择要激活的Profile

基于条件的Profile激活：

<profile> <id>jdk11</id> <activation> <jdk>11</jdk> </activation> <properties> <java.version>11</java.version> </properties> </profile>

多模块项目开发

Maven支持多模块项目，便于管理大型复杂项目。

创建父项目POM：

<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-SNAPSHOT</version> <packaging>pom</packaging> <modules> <module>module-a</module> <module>module-b</module> <module>web-app</module> </modules> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>11</maven.compiler.source> <maven.compiler.target>11</maven.compiler.target> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>2.6.3</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <build> <pluginManagement> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>2.6.3</version> </plugin> </plugins> </pluginManagement> </build> </project>

创建子模块：

<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>my-project</artifactId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>module-a</artifactId> <packaging>jar</packaging> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> </dependencies> </project>

模块间依赖：

<dependencies> <dependency> <groupId>com.example</groupId> <artifactId>module-a</artifactId> <version>${project.version}</version> </dependency> </dependencies>

构建多模块项目：
```
mvn clean install 
```
在IntelliJ IDEA中：
- 导入多模块项目
- 使用Maven工具窗口管理模块
- 可以单独构建特定模块或整个项目

自定义Maven插件

Maven允许开发自定义插件，以满足特定需求。

创建Maven插件项目：

mvn archetype:generate -DgroupId=com.example.plugins -DartifactId=my-maven-plugin -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-mojo

编写Mojo（Maven普通Java对象）： “`java package com.example.plugins;

import org.apache.maven.plugin.AbstractMojo; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugins.annotations.Mojo; import org.apache.maven.plugins.annotations.Parameter;

/**

* Says "Hi" to the user. */

@Mojo(name = “sayhi”) public class GreetingMojo extends AbstractMojo {

 /** * The greeting to display. */ @Parameter(property = "greeting", defaultValue = "Hello World!") private String greeting; public void execute() throws MojoExecutionException { getLog().info(greeting); }

}

 3. 构建插件： ```bash mvn clean install

在其他项目中使用自定义插件：

<build> <plugins> <plugin> <groupId>com.example.plugins</groupId> <artifactId>my-maven-plugin</artifactId> <version>1.0-SNAPSHOT</version> <executions> <execution> <phase>compile</phase> <goals> <goal>sayhi</goal> </goals> <configuration> <greeting>Hi from custom plugin!</greeting> </configuration> </execution> </executions> </plugin> </plugins> </build>