简体中文 繁體中文 English 日本語 Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：是的！我们正在计划一个大动作！
11-02 12:46
通知：Telegram 推送频道https://t.me/+2tB3a7aKXlw2YjA1 及时接收第一手论坛帖子信息～
10-23 09:32
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
通知：加入QQ社群吧 https://qm.qq.com/q/QZibQd1hiq
10-23 09:28
通知：签到时间调整为每日4:00（东八区）
10-23 09:26
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

IntelliJ IDEA搭建Maven项目实战教程解决开发环境配置中的常见问题

威震华夏关云长

3万

主题

317

科技点

3万

积分

大区版主

木柜子打湿

积分
31893

财Doro三倍冰淇淋无人之境【一阶】立华奏小樱（小丑装）⑨的冰沙以外的星空【二阶】
发表于 2025-8-24 20:00:01 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

IntelliJ IDEA是Java开发中最受欢迎的集成开发环境(IDE)之一，而Maven是项目管理和构建自动化工具，被广泛用于Java项目的依赖管理和构建过程。本教程将详细介绍如何在IntelliJ IDEA中搭建Maven项目，并解决开发环境配置中的常见问题，帮助开发者快速上手并提高开发效率。

环境准备

JDK安装与配置

在开始之前，确保你的系统已经安装了Java Development Kit (JDK)。IntelliJ IDEA和Maven都需要JDK来运行和构建Java项目。

1. 下载JDK：可以从Oracle官网或OpenJDK官网下载适合你操作系统的JDK版本。推荐使用JDK 8或更高版本。
2. 安装JDK：按照安装向导完成安装。
3.
  2. 配置环境变量：Windows系统：JAVA_HOME=C:\Program Files\Java\jdk-11.0.10
  3. PATH=%JAVA_HOME%\bin;%PATH%Linux/macOS系统：export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
  4. export PATH=$JAVA_HOME/bin:$PATH
复制代码
4.
  2. Windows系统：JAVA_HOME=C:\Program Files\Java\jdk-11.0.10
  3. PATH=%JAVA_HOME%\bin;%PATH%
复制代码
5.
  2. Linux/macOS系统：export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
  3. export PATH=$JAVA_HOME/bin:$PATH
复制代码
6. 验证安装：打开命令行工具，输入以下命令验证JDK是否安装成功：java -version
javac -version

•
  2. Windows系统：JAVA_HOME=C:\Program Files\Java\jdk-11.0.10
  3. PATH=%JAVA_HOME%\bin;%PATH%
复制代码
•
  2. Linux/macOS系统：export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
  3. export PATH=$JAVA_HOME/bin:$PATH
复制代码
  2. JAVA_HOME=C:\Program Files\Java\jdk-11.0.10
  3. PATH=%JAVA_HOME%\bin;%PATH%
复制代码
  2. export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
  3. export PATH=$JAVA_HOME/bin:$PATH
复制代码
  2. java -version
  3. javac -version
复制代码

IntelliJ IDEA安装

1. 下载IntelliJ IDEA：从JetBrains官网(https://www.jetbrains.com/idea/)下载IntelliJIDEA。有两个版本可供选择：Ultimate版(付费，功能全面)和Community版(免费，适合Java开发)。
2. 安装IntelliJ IDEA：按照安装向导完成安装。
3. 首次启动配置：首次启动IntelliJ IDEA时，会提示进行一些基本配置，如主题选择、插件安装等。可以根据个人喜好进行配置。

Maven配置

IntelliJ IDEA内置了Maven，但也可以配置使用自定义的Maven安装。

1. 下载Maven：从Apache Maven官网(https://maven.apache.org/download.cgi)下载Maven。
2. 解压Maven：将下载的Maven压缩包解压到指定目录。
3.
  2. 配置环境变量：Windows系统：MAVEN_HOME=C:\Program Files\apache-maven-3.8.1
  3. PATH=%MAVEN_HOME%\bin;%PATH%Linux/macOS系统：export MAVEN_HOME=/opt/apache-maven-3.8.1
  4. export PATH=$MAVEN_HOME/bin:$PATH
复制代码
4.
  2. Windows系统：MAVEN_HOME=C:\Program Files\apache-maven-3.8.1
  3. PATH=%MAVEN_HOME%\bin;%PATH%
复制代码
5.
  2. Linux/macOS系统：export MAVEN_HOME=/opt/apache-maven-3.8.1
  3. export PATH=$MAVEN_HOME/bin:$PATH
复制代码
6. 验证安装：打开命令行工具，输入以下命令验证Maven是否安装成功：mvn -version
7.
  2. 配置Maven设置文件(settings.xml)：
  3. Maven的配置文件通常位于Maven安装目录的conf文件夹下。常用的配置包括：本地仓库位置：默认在用户目录下的.m2/repository文件夹中，可以通过修改settings.xml文件更改：<settings>
  4. <localRepository>/path/to/your/local/repo</localRepository>
  5. </settings>镜像配置：为了提高依赖下载速度，可以配置国内镜像：<mirrors>
  6. <mirror>
  7. <id>aliyun</id>
  8. <mirrorOf>central</mirrorOf>
  9. <name>Aliyun Maven Central</name>
  10. <url>https://maven.aliyun.com/repository/central</url>
  11. </mirror>
  12. </mirrors>
复制代码
8. 本地仓库位置：默认在用户目录下的.m2/repository文件夹中，可以通过修改settings.xml文件更改：<settings>
<localRepository>/path/to/your/local/repo</localRepository>
</settings>
9.
  2. 镜像配置：为了提高依赖下载速度，可以配置国内镜像：<mirrors>
  3. <mirror>
  4. <id>aliyun</id>
  5. <mirrorOf>central</mirrorOf>
  6. <name>Aliyun Maven Central</name>
  7. <url>https://maven.aliyun.com/repository/central</url>
  8. </mirror>
  9. </mirrors>
复制代码

•
  2. Windows系统：MAVEN_HOME=C:\Program Files\apache-maven-3.8.1
  3. PATH=%MAVEN_HOME%\bin;%PATH%
复制代码
•
  2. Linux/macOS系统：export MAVEN_HOME=/opt/apache-maven-3.8.1
  3. export PATH=$MAVEN_HOME/bin:$PATH
复制代码
  2. MAVEN_HOME=C:\Program Files\apache-maven-3.8.1
  3. PATH=%MAVEN_HOME%\bin;%PATH%
复制代码
  2. export MAVEN_HOME=/opt/apache-maven-3.8.1
  3. export PATH=$MAVEN_HOME/bin:$PATH
复制代码
  2. mvn -version
复制代码

• 本地仓库位置：默认在用户目录下的.m2/repository文件夹中，可以通过修改settings.xml文件更改：<settings>
<localRepository>/path/to/your/local/repo</localRepository>
</settings>
•
  2. 镜像配置：为了提高依赖下载速度，可以配置国内镜像：<mirrors>
  3. <mirror>
  4. <id>aliyun</id>
  5. <mirrorOf>central</mirrorOf>
  6. <name>Aliyun Maven Central</name>
  7. <url>https://maven.aliyun.com/repository/central</url>
  8. </mirror>
  9. </mirrors>
复制代码
  2. <settings>
  3. <localRepository>/path/to/your/local/repo</localRepository>
  4. </settings>
复制代码
  2. <mirrors>
  3. <mirror>
  4. <id>aliyun</id>
  5. <mirrorOf>central</mirrorOf>
  6. <name>Aliyun Maven Central</name>
  7. <url>https://maven.aliyun.com/repository/central</url>
  8. </mirror>
  9. </mirrors>
复制代码

创建Maven项目

使用IntelliJ IDEA创建Maven项目

1. 打开IntelliJ IDEA，选择”Create New Project”。
2. 在左侧选择”Maven”，然后确保右侧选择了正确的Project SDK（即之前安装的JDK）。
3. 勾选”Create from archetype”，然后从列表中选择一个archetype。对于简单的Java项目，可以选择”maven-archetype-quickstart”。
4. 点击”Next”。
5. 填写项目信息：GroupId：通常是组织或公司的反向域名，例如com.example。ArtifactId：项目的唯一标识符，例如my-project。Version：项目的版本，默认为1.0-SNAPSHOT。
6. GroupId：通常是组织或公司的反向域名，例如com.example。
7. ArtifactId：项目的唯一标识符，例如my-project。
8. Version：项目的版本，默认为1.0-SNAPSHOT。
9. 点击”Next”。
10. 配置Maven设置：Maven home path：选择Maven安装路径或使用IDEA内置的Maven。User settings file：选择Maven的settings.xml文件路径。Local repository：显示本地仓库路径。
11. Maven home path：选择Maven安装路径或使用IDEA内置的Maven。
12. User settings file：选择Maven的settings.xml文件路径。
13. Local repository：显示本地仓库路径。
14. 点击”Next”，然后填写项目名称和项目位置。
15. 点击”Finish”，IntelliJ IDEA将创建并加载Maven项目。

• GroupId：通常是组织或公司的反向域名，例如com.example。
• ArtifactId：项目的唯一标识符，例如my-project。
• Version：项目的版本，默认为1.0-SNAPSHOT。

• Maven home path：选择Maven安装路径或使用IDEA内置的Maven。
• User settings file：选择Maven的settings.xml文件路径。
• Local repository：显示本地仓库路径。

项目创建后的初始结构

创建完成后，项目结构如下：
  2. my-project
  3. ├── src
  4. │   ├── main
  5. │   │   ├── java
  6. │   │   └── resources
  7. │   └── test
  8. │       ├── java
  9. │       └── resources
  10. ├── target
  11. ├── pom.xml
  12. └── my-project.iml
复制代码

• src/main/java：存放主要的Java源代码。
• src/main/resources：存放主要的资源文件。
• src/test/java：存放测试用的Java源代码。
• src/test/resources：存放测试用的资源文件。
• target：Maven构建生成的文件存放目录。
• pom.xml：Maven项目的核心配置文件。

Maven项目结构解析

pom.xml文件解析

pom.xml是Maven项目的核心配置文件，定义了项目的基本信息、依赖、构建配置等。一个典型的pom.xml文件结构如下：
  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0"
  4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  6.     <modelVersion>4.0.0</modelVersion>
  8.     <!-- 项目基本信息 -->
  9.     <groupId>com.example</groupId>
  10.     <artifactId>my-project</artifactId>
  11.     <version>1.0-SNAPSHOT</version>
  13.     <!-- 项目属性 -->
  14.     <properties>
  15.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  16.         <maven.compiler.source>11</maven.compiler.source>
  17.         <maven.compiler.target>11</maven.compiler.target>
  18.     </properties>
  20.     <!-- 依赖管理 -->
  21.     <dependencies>
  22.         <!-- JUnit 5 依赖 -->
  23.         <dependency>
  24.             <groupId>org.junit.jupiter</groupId>
  25.             <artifactId>junit-jupiter-api</artifactId>
  26.             <version>5.7.0</version>
  27.             <scope>test</scope>
  28.         </dependency>
  29.     </dependencies>
  31.     <!-- 构建配置 -->
  32.     <build>
  33.         <plugins>
  34.             <!-- Maven Compiler Plugin -->
  35.             <plugin>
  36.                 <groupId>org.apache.maven.plugins</groupId>
  37.                 <artifactId>maven-compiler-plugin</artifactId>
  38.                 <version>3.8.1</version>
  39.                 <configuration>
  40.                     <source>11</source>
  41.                     <target>11</target>
  42.                 </configuration>
  43.             </plugin>
  44.         </plugins>
  45.     </build>
  46. </project>
复制代码

• modelVersion：指定POM模型的版本，当前为4.0.0。
• groupId、artifactId、version：项目的唯一标识，通常称为GAV。
• properties：定义项目属性，可以在整个POM文件中引用。
• dependencies：定义项目依赖的库。
• build：定义构建配置，包括插件等。

Maven依赖管理

Maven的依赖管理是其核心功能之一。通过在pom.xml文件中声明依赖，Maven会自动下载并管理这些依赖。

在pom.xml文件中，可以通过以下方式添加依赖：
  2. <dependencies>
  3.     <!-- 添加Spring Boot Starter Web依赖 -->
  4.     <dependency>
  5.         <groupId>org.springframework.boot</groupId>
  6.         <artifactId>spring-boot-starter-web</artifactId>
  7.         <version>2.5.0</version>
  8.     </dependency>
  9.    
  10.     <!-- 添加MyBatis依赖 -->
  11.     <dependency>
  12.         <groupId>org.mybatis</groupId>
  13.         <artifactId>mybatis</artifactId>
  14.         <version>3.5.7</version>
  15.     </dependency>
  16.    
  17.     <!-- 添加MySQL驱动依赖 -->
  18.     <dependency>
  19.         <groupId>mysql</groupId>
  20.         <artifactId>mysql-connector-java</artifactId>
  21.         <version>8.0.25</version>
  22.     </dependency>
  23. </dependencies>
复制代码

Maven依赖可以通过scope元素指定其范围，常见的范围有：

• compile：默认范围，表示该依赖在编译、测试和运行时都需要。
• provided：表示该依赖在编译和测试时需要，但在运行时由JDK或容器提供。
• runtime：表示该依赖在测试和运行时需要，但在编译时不需要。
• test：表示该依赖仅在测试时需要。
• system：类似于provided，但需要显式提供包含依赖的JAR。

例如：
  2. <dependency>
  3.     <groupId>javax.servlet</groupId>
  4.     <artifactId>javax.servlet-api</artifactId>
  5.     <version>4.0.1</version>
  6.     <scope>provided</scope>
  7. </dependency>
复制代码

有时候，一个依赖可能会传递性地引入不需要的依赖，这时可以使用exclusions元素排除这些依赖：
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-web</artifactId>
  5.     <version>2.5.0</version>
  6.     <exclusions>
  7.         <exclusion>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-tomcat</artifactId>
  10.         </exclusion>
  11.     </exclusions>
  12. </dependency>
复制代码

Maven生命周期

Maven定义了三个内置的生命周期：clean、default和site。每个生命周期由一系列阶段(phase)组成。

clean生命周期用于清理项目，包含以下阶段：

• pre-clean：执行清理前需要完成的工作。
• clean：清理上一次构建生成的文件。
• post-clean：执行清理后需要完成的工作。

default生命周期是Maven的主要生命周期，用于构建项目，包含以下主要阶段：

• validate：验证项目是否正确，所有必要的信息是否可用。
• initialize：初始化构建状态，例如设置属性。
• generate-sources：生成编译需要的源代码。
• process-sources：处理源代码，例如过滤一些值。
• generate-resources：生成项目主资源。
• process-resources：处理主资源，并将其复制到主类目目录。
• compile：编译项目的源代码。
• process-classes：处理编译生成的文件，例如对Java类进行字节码增强。
• generate-test-sources：生成测试源代码。
• process-test-sources：处理测试源代码。
• generate-test-resources：生成测试资源。
• process-test-resources：处理测试资源，并将其复制到测试类目目录。
• test-compile：编译测试源代码。
• process-test-classes：处理测试编译生成的文件。
• test：使用单元测试框架运行测试。
• prepare-package：在打包之前执行必要的操作。
• package：将编译后的代码打包成可分发的格式，如JAR、WAR或EAR。
• pre-integration-test：在集成测试之前执行必要的操作。
• integration-test：处理和部署包，以便在集成测试环境中运行。
• post-integration-test：在集成测试之后执行必要的操作。
• verify：运行检查以验证包是否有效且符合质量标准。
• install：将包安装到本地仓库，以便作为本地其他项目的依赖。
• deploy：将最终包复制到远程仓库，以便与其他开发人员和项目共享。

site生命周期用于生成项目文档和站点，包含以下阶段：

• pre-site：在生成站点之前执行必要的操作。
• site：生成项目的站点文档。
• post-site：在生成站点之后执行必要的操作，并为站点部署做准备。
• site-deploy：将生成的站点文档部署到指定的服务器。

在IntelliJ IDEA中，可以通过Maven工具窗口执行这些生命周期阶段。打开Maven工具窗口（通常在右侧），展开项目节点，可以看到Lifecycle节点，双击其中的阶段即可执行。

常见问题及解决方案

依赖下载问题

现象：在构建Maven项目时，依赖下载速度非常慢，或者下载失败，导致构建不成功。

原因：

• 默认使用的Maven中央仓库在国外，网络连接不稳定。
• 本地网络环境限制。
• Maven配置问题。

解决方案：

1. 配置国内镜像：在Maven的settings.xml文件中配置国内镜像，如阿里云镜像：
  2. <mirrors>
  3.     <mirror>
  4.         <id>aliyun</id>
  5.         <mirrorOf>central</mirrorOf>
  6.         <name>Aliyun Maven Central</name>
  7.         <url>https://maven.aliyun.com/repository/central</url>
  8.     </mirror>
  9.     <mirror>
  10.         <id>aliyun-public</id>
  11.         <mirrorOf>public</mirrorOf>
  12.         <name>Aliyun Maven Public</name>
  13.         <url>https://maven.aliyun.com/repository/public</url>
  14.     </mirror>
  15. </mirrors>
复制代码

1. 使用代理：如果网络环境需要使用代理，可以在settings.xml文件中配置代理：
  2. <proxies>
  3.     <proxy>
  4.         <id>my-proxy</id>
  5.         <active>true</active>
  6.         <protocol>http</protocol>
  7.         <host>proxy.example.com</host>
  8.         <port>8080</port>
  9.         <username>proxyuser</username>
  10.         <password>proxypass</password>
  11.         <nonProxyHosts>localhost|127.0.0.1</nonProxyHosts>
  12.     </proxy>
  13. </proxies>
复制代码

1. 手动下载依赖：对于某些难以下载的依赖，可以手动下载并安装到本地仓库：
  2. mvn install:install-file -DgroupId=com.example -DartifactId=my-library -Dversion=1.0.0 -Dpackaging=jar -Dfile=/path/to/my-library-1.0.0.jar
复制代码

1. 检查网络连接：确保网络连接正常，尝试使用浏览器访问Maven中央仓库。

现象：项目中引入的多个依赖可能依赖于同一个库的不同版本，导致版本冲突。

原因：

• 传递性依赖引入了不同版本的同一个库。
• 直接依赖了同一个库的不同版本。

解决方案：

1. 使用Maven Dependency Tree：通过Maven依赖树查看依赖关系，找出冲突：
  2. mvn dependency:tree
复制代码

在IntelliJ IDEA中，可以打开Maven工具窗口，右键点击项目，选择”Show Dependencies”，查看依赖图。

1. 使用dependencyManagement管理版本：在pom.xml文件中使用dependencyManagement元素统一管理依赖版本：
  2. <dependencyManagement>
  3.     <dependencies>
  4.         <dependency>
  5.             <groupId>org.springframework</groupId>
  6.             <artifactId>spring-core</artifactId>
  7.             <version>5.3.8</version>
  8.         </dependency>
  9.     </dependencies>
  10. </dependencyManagement>
复制代码

1. 使用exclusions排除依赖：在引入依赖时，排除不需要的传递性依赖：
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-web</artifactId>
  5.     <version>2.5.0</version>
  6.     <exclusions>
  7.         <exclusion>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-tomcat</artifactId>
  10.         </exclusion>
  11.     </exclusions>
  12. </dependency>
复制代码

1. 强制使用特定版本：在pom.xml文件中直接声明需要使用的版本，Maven会选择离项目最近的版本：
  2. <dependencies>
  3.     <dependency>
  4.         <groupId>org.springframework</groupId>
  5.         <artifactId>spring-core</artifactId>
  6.         <version>5.3.8</version>
  7.     </dependency>
  8. </dependencies>
复制代码

编译问题

现象：项目编译时出现”不支持的发行版本”或”无效的目标发行版”等错误。

原因：

• 项目使用的Java版本与JDK版本不匹配。
• Maven编译器插件配置的版本与JDK版本不匹配。

解决方案：

1. 检查JDK版本：确保系统安装了正确版本的JDK，并且在IntelliJ IDEA中配置了正确的JDK。
2. 配置Maven编译器插件：在pom.xml文件中配置Maven编译器插件，指定正确的Java版本：

检查JDK版本：确保系统安装了正确版本的JDK，并且在IntelliJ IDEA中配置了正确的JDK。

配置Maven编译器插件：在pom.xml文件中配置Maven编译器插件，指定正确的Java版本：
  2. <build>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-compiler-plugin</artifactId>
  7.             <version>3.8.1</version>
  8.             <configuration>
  9.                 <source>11</source>
  10.                 <target>11</target>
  11.             </configuration>
  12.         </plugin>
  13.     </plugins>
  14. </build>
复制代码

1. 配置项目属性：在pom.xml文件中配置项目属性，指定Java版本：
  2. <properties>
  3.     <maven.compiler.source>11</maven.compiler.source>
  4.     <maven.compiler.target>11</maven.compiler.target>
  5. </properties>
复制代码

1. 在IntelliJ IDEA中设置项目SDK：打开File -> Project Structure。在Project Settings中选择Project，确保Project SDK设置正确。在Modules中选择对应的模块，确保Module SDK设置正确。
2. 打开File -> Project Structure。
3. 在Project Settings中选择Project，确保Project SDK设置正确。
4. 在Modules中选择对应的模块，确保Module SDK设置正确。

• 打开File -> Project Structure。
• 在Project Settings中选择Project，确保Project SDK设置正确。
• 在Modules中选择对应的模块，确保Module SDK设置正确。

现象：编译时出现”编码GBK的不可映射字符”等错误。

原因：

• 项目使用的编码与系统默认编码不一致。
• Maven编译器插件没有指定正确的编码。

解决方案：

1. 配置项目编码：在pom.xml文件中配置项目编码：
  2. <properties>
  3.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  4.     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  5. </properties>
复制代码

1. 配置Maven编译器插件：在pom.xml文件中配置Maven编译器插件，指定编码：
  2. <build>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-compiler-plugin</artifactId>
  7.             <version>3.8.1</version>
  8.             <configuration>
  9.                 <encoding>UTF-8</encoding>
  10.             </configuration>
  11.         </plugin>
  12.     </plugins>
  13. </build>
复制代码

1. 在IntelliJ IDEA中设置文件编码：打开File -> Settings。在Editor -> File Encodings中，将Global Encoding、Project Encoding和Default encoding for properties files都设置为UTF-8。
2. 打开File -> Settings。
3. 在Editor -> File Encodings中，将Global Encoding、Project Encoding和Default encoding for properties files都设置为UTF-8。

• 打开File -> Settings。
• 在Editor -> File Encodings中，将Global Encoding、Project Encoding和Default encoding for properties files都设置为UTF-8。

现象：项目编译失败，但控制台没有显示明确的错误信息。

原因：

• Maven日志级别设置过高，隐藏了错误信息。
• 编译过程中的错误被过滤。

解决方案：

1. 增加Maven日志级别：在运行Maven命令时，增加-e参数显示错误信息：
  2. mvn clean compile -e
复制代码

1. 在IntelliJ IDEA中配置Maven运行选项：打开Run -> Edit Configurations。在Maven配置中，在Command line字段添加-e参数。
2. 打开Run -> Edit Configurations。
3. 在Maven配置中，在Command line字段添加-e参数。
4. 检查编译器输出：在IntelliJ IDEA中，打开View -> Tool Windows -> Build，查看详细的编译输出。
5. 检查本地仓库：有时候，本地仓库中的依赖可能损坏，可以尝试删除本地仓库中的相关依赖，重新下载：

在IntelliJ IDEA中配置Maven运行选项：

• 打开Run -> Edit Configurations。
• 在Maven配置中，在Command line字段添加-e参数。

检查编译器输出：在IntelliJ IDEA中，打开View -> Tool Windows -> Build，查看详细的编译输出。

检查本地仓库：有时候，本地仓库中的依赖可能损坏，可以尝试删除本地仓库中的相关依赖，重新下载：
  2. # 删除本地仓库中的特定依赖
  3. rm -rf ~/.m2/repository/com/example/my-library
  5. # 重新构建项目
  6. mvn clean compile
复制代码

运行问题

现象：运行项目时出现”找不到或无法加载主类”错误。

原因：

• 主类路径配置不正确。
• 编译后的类文件不在正确的位置。
• MANIFEST.MF文件中没有正确指定主类。

解决方案：

1. 检查主类路径：确保在运行配置中正确指定了主类的全限定名。
2. 重新编译项目：在IntelliJ IDEA中，执行Build -> Rebuild Project，确保所有类都被正确编译。
3. 配置Maven JAR插件：如果打包为JAR文件，确保在pom.xml文件中正确配置Maven JAR插件，指定主类：

检查主类路径：确保在运行配置中正确指定了主类的全限定名。

重新编译项目：在IntelliJ IDEA中，执行Build -> Rebuild Project，确保所有类都被正确编译。

配置Maven JAR插件：如果打包为JAR文件，确保在pom.xml文件中正确配置Maven JAR插件，指定主类：
  2. <build>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-jar-plugin</artifactId>
  7.             <version>3.2.0</version>
  8.             <configuration>
  9.                 <archive>
  10.                     <manifest>
  11.                         <addClasspath>true</addClasspath>
  12.                         <mainClass>com.example.MainClass</mainClass>
  13.                     </manifest>
  14.                 </archive>
  15.             </configuration>
  16.         </plugin>
  17.     </plugins>
  18. </build>
复制代码

1. 使用Maven Shade插件：如果项目有依赖，可以使用Maven Shade插件创建一个包含所有依赖的可执行JAR：
  2. <build>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-shade-plugin</artifactId>
  7.             <version>3.2.4</version>
  8.             <executions>
  9.                 <execution>
  10.                     <phase>package</phase>
  11.                     <goals>
  12.                         <goal>shade</goal>
  13.                     </goals>
  14.                     <configuration>
  15.                         <transformers>
  16.                             <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
  17.                                 <mainClass>com.example.MainClass</mainClass>
  18.                             </transformer>
  19.                         </transformers>
  20.                     </configuration>
  21.                 </execution>
  22.             </executions>
  23.         </plugin>
  24.     </plugins>
  25. </build>
复制代码

现象：程序运行时出现”ClassNotFoundException”或”NoClassDefFoundError”错误。

原因：

• 运行时类路径中缺少必要的依赖。
• 依赖范围配置不正确。

解决方案：

1. 检查依赖范围：确保运行时需要的依赖的范围不是test或provided：
  2. <dependency>
  3.     <groupId>com.example</groupId>
  4.     <artifactId>my-library</artifactId>
  5.     <version>1.0.0</version>
  6.     <scope>compile</scope> <!-- 确保不是test或provided -->
  7. </dependency>
复制代码

1. 使用Maven Assembly插件：创建一个包含所有依赖的可分发包：
  2. <build>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-assembly-plugin</artifactId>
  7.             <version>3.3.0</version>
  8.             <configuration>
  9.                 <descriptorRefs>
  10.                     <descriptorRef>jar-with-dependencies</descriptorRef>
  11.                 </descriptorRefs>
  12.                 <archive>
  13.                     <manifest>
  14.                         <mainClass>com.example.MainClass</mainClass>
  15.                     </manifest>
  16.                 </archive>
  17.             </configuration>
  18.             <executions>
  19.                 <execution>
  20.                     <phase>package</phase>
  21.                     <goals>
  22.                         <goal>single</goal>
  23.                     </goals>
  24.                 </execution>
  25.             </executions>
  26.         </plugin>
  27.     </plugins>
  28. </build>
复制代码

1. 在IntelliJ IDEA中检查运行配置：打开Run -> Edit Configurations。确保在Application配置中，Use classpath of module选择了正确的模块。检查Before launch配置，确保Build或Make Artifact被选中。
2. 打开Run -> Edit Configurations。
3. 确保在Application配置中，Use classpath of module选择了正确的模块。
4. 检查Before launch配置，确保Build或Make Artifact被选中。
5. 检查依赖传递性：使用Maven Dependency Tree检查依赖关系，确保所有必要的依赖都被正确引入：

在IntelliJ IDEA中检查运行配置：

• 打开Run -> Edit Configurations。
• 确保在Application配置中，Use classpath of module选择了正确的模块。
• 检查Before launch配置，确保Build或Make Artifact被选中。

检查依赖传递性：使用Maven Dependency Tree检查依赖关系，确保所有必要的依赖都被正确引入：
  2. mvn dependency:tree
复制代码

插件配置问题

现象：构建过程中出现插件版本不兼容的错误。

原因：

• 使用的插件版本与Maven版本不兼容。
• 插件版本与项目使用的Java版本不兼容。

解决方案：

1. 更新插件版本：在pom.xml文件中指定兼容的插件版本：
  2. <build>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-compiler-plugin</artifactId>
  7.             <version>3.8.1</version> <!-- 使用兼容的版本 -->
  8.         </plugin>
  9.     </plugins>
  10. </build>
复制代码

1. 查看插件文档：访问插件的官方文档，了解其兼容性要求。
2. 使用Maven版本属性：在pom.xml文件中使用Maven版本属性，确保插件版本与Maven版本兼容：

查看插件文档：访问插件的官方文档，了解其兼容性要求。

使用Maven版本属性：在pom.xml文件中使用Maven版本属性，确保插件版本与Maven版本兼容：
  2. <properties>
  3.     <maven.compiler.plugin.version>3.8.1</maven.compiler.plugin.version>
  4. </properties>
  6. <build>
  7.     <plugins>
  8.         <plugin>
  9.             <groupId>org.apache.maven.plugins</groupId>
  10.             <artifactId>maven-compiler-plugin</artifactId>
  11.             <version>${maven.compiler.plugin.version}</version>
  12.         </plugin>
  13.     </plugins>
  14. </build>
复制代码

现象：构建过程中插件执行失败，导致构建中断。

原因：

• 插件配置不正确。
• 插件依赖的资源不可用。
• 环境问题，如缺少必要的工具或库。

解决方案：

1. 查看详细错误信息：使用-e参数运行Maven，查看详细的错误信息：
  2. mvn clean package -e
复制代码

1. 检查插件配置：确保插件的配置正确，例如：
  2. <plugin>
  3.     <groupId>org.apache.maven.plugins</groupId>
  4.     <artifactId>maven-surefire-plugin</artifactId>
  5.     <version>3.0.0-M5</version>
  6.     <configuration>
  7.         <includes>
  8.             <include>**/*Test.java</include>
  9.         </includes>
  10.         <skipTests>false</skipTests>
  11.     </configuration>
  12. </plugin>
复制代码

1. 检查环境：确保环境中安装了插件需要的工具和库。
2. 跳过插件执行：如果暂时不需要执行某个插件，可以配置跳过：

检查环境：确保环境中安装了插件需要的工具和库。

跳过插件执行：如果暂时不需要执行某个插件，可以配置跳过：
  2. <plugin>
  3.     <groupId>org.apache.maven.plugins</groupId>
  4.     <artifactId>maven-surefire-plugin</artifactId>
  5.     <version>3.0.0-M5</version>
  6.     <configuration>
  7.         <skipTests>true</skipTests> <!-- 跳过测试 -->
  8.     </configuration>
  9. </plugin>
复制代码

或者在命令行中使用参数跳过：
  2. mvn clean package -DskipTests
复制代码

最佳实践

使用多模块项目

对于大型项目，可以使用Maven的多模块结构来组织代码。多模块项目由一个父POM和一个或多个子模块组成。

1. 创建父项目：在IntelliJ IDEA中，选择”Create New Project”。选择”Maven”，不选择”Create from archetype”。填写Group Id和Artifact Id，例如com.example和multi-module-project。点击”Finish”。
2. 在IntelliJ IDEA中，选择”Create New Project”。
3. 选择”Maven”，不选择”Create from archetype”。
4. 填写Group Id和Artifact Id，例如com.example和multi-module-project。
5. 点击”Finish”。
6. 创建子模块：右键点击父项目，选择”New” -> “Module”。选择”Maven”，可以选择archetype或创建简单的模块。填写Artifact Id，例如module-a。点击”Finish”。重复上述步骤，创建其他子模块。
7. 右键点击父项目，选择”New” -> “Module”。
8. 选择”Maven”，可以选择archetype或创建简单的模块。
9. 填写Artifact Id，例如module-a。
10. 点击”Finish”。
11. 重复上述步骤，创建其他子模块。
12.
  2. 配置父POM：
  3. 父POM文件(pom.xml)应该包含packaging类型为pom，以及modules列表：
复制代码

创建父项目：

• 在IntelliJ IDEA中，选择”Create New Project”。
• 选择”Maven”，不选择”Create from archetype”。
• 填写Group Id和Artifact Id，例如com.example和multi-module-project。
• 点击”Finish”。

创建子模块：

• 右键点击父项目，选择”New” -> “Module”。
• 选择”Maven”，可以选择archetype或创建简单的模块。
• 填写Artifact Id，例如module-a。
• 点击”Finish”。
• 重复上述步骤，创建其他子模块。

配置父POM：
父POM文件(pom.xml)应该包含packaging类型为pom，以及modules列表：
  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0"
  4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  6.     <modelVersion>4.0.0</modelVersion>
  8.     <groupId>com.example</groupId>
  9.     <artifactId>multi-module-project</artifactId>
  10.     <version>1.0-SNAPSHOT</version>
  11.     <packaging>pom</packaging>
  13.     <modules>
  14.         <module>module-a</module>
  15.         <module>module-b</module>
  16.     </modules>
  18.     <properties>
  19.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  20.         <maven.compiler.source>11</maven.compiler.source>
  21.         <maven.compiler.target>11</maven.compiler.target>
  22.     </properties>
  24.     <dependencyManagement>
  25.         <dependencies>
  26.             <!-- 统一管理依赖版本 -->
  27.             <dependency>
  28.                 <groupId>org.springframework</groupId>
  29.                 <artifactId>spring-core</artifactId>
  30.                 <version>5.3.8</version>
  31.             </dependency>
  32.         </dependencies>
  33.     </dependencyManagement>
  35.     <build>
  36.         <pluginManagement>
  37.             <plugins>
  38.                 <!-- 统一管理插件版本 -->
  39.                 <plugin>
  40.                     <groupId>org.apache.maven.plugins</groupId>
  41.                     <artifactId>maven-compiler-plugin</artifactId>
  42.                     <version>3.8.1</version>
  43.                     <configuration>
  44.                         <source>11</source>
  45.                         <target>11</target>
  46.                     </configuration>
  47.                 </plugin>
  48.             </plugins>
  49.         </pluginManagement>
  50.     </build>
  51. </project>
复制代码

1. 配置子模块POM：
子模块的POM文件应该引用父POM，并可以继承父POM中的配置：
  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0"
  4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  6.     <modelVersion>4.0.0</modelVersion>
  8.     <parent>
  9.         <groupId>com.example</groupId>
  10.         <artifactId>multi-module-project</artifactId>
  11.         <version>1.0-SNAPSHOT</version>
  12.     </parent>
  14.     <artifactId>module-a</artifactId>
  16.     <dependencies>
  17.         <!-- 继承父POM中的版本管理 -->
  18.         <dependency>
  19.             <groupId>org.springframework</groupId>
  20.             <artifactId>spring-core</artifactId>
  21.         </dependency>
  22.     </dependencies>
  23. </project>
复制代码

• 代码组织：可以将大型项目分解为多个逻辑模块，每个模块负责特定的功能。
• 依赖管理：可以在父POM中统一管理依赖版本，避免版本冲突。
• 构建管理：可以一次性构建所有模块，也可以单独构建特定模块。
• 复用性：模块可以被其他项目复用。

使用Profile

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

在pom.xml文件中定义Profile：
  2. <profiles>
  3.     <!-- 开发环境 -->
  4.     <profile>
  5.         <id>dev</id>
  6.         <activation>
  7.             <activeByDefault>true</activeByDefault>
  8.         </activation>
  9.         <properties>
  10.             <environment>dev</environment>
  11.             <database.url>jdbc:mysql://localhost:3306/dev_db</database.url>
  12.             <database.username>dev_user</database.username>
  13.             <database.password>dev_password</database.password>
  14.         </properties>
  15.     </profile>
  17.     <!-- 测试环境 -->
  18.     <profile>
  19.         <id>test</id>
  20.         <properties>
  21.             <environment>test</environment>
  22.             <database.url>jdbc:mysql://test.example.com:3306/test_db</database.url>
  23.             <database.username>test_user</database.username>
  24.             <database.password>test_password</database.password>
  25.         </properties>
  26.     </profile>
  28.     <!-- 生产环境 -->
  29.     <profile>
  30.         <id>prod</id>
  31.         <properties>
  32.             <environment>prod</environment>
  33.             <database.url>jdbc:mysql://prod.example.com:3306/prod_db</database.url>
  34.             <database.username>prod_user</database.username>
  35.             <database.password>prod_password</database.password>
  36.         </properties>
  37.     </profile>
  38. </profiles>
复制代码

在构建时指定Profile：
  2. mvn clean package -Ptest
复制代码

在IntelliJ IDEA中，可以在Maven工具窗口中选择要激活的Profile。

• 环境配置：根据不同环境使用不同的配置文件。
• 功能开关：根据需要启用或禁用某些功能。
• 平台适配：根据不同平台使用不同的依赖或配置。

使用Maven Wrapper

Maven Wrapper是一个脚本，允许在没有安装Maven的系统上构建项目。

在项目根目录下执行以下命令：
  2. mvn -N io.takari:maven:wrapper
复制代码

或者使用特定版本：
  2. mvn -N io.takari:maven:wrapper -Dmaven=3.8.1
复制代码

添加Maven Wrapper后，项目中会包含以下文件：

• mvnw：Unix/Linux下的脚本
• mvnw.cmd：Windows下的脚本
• .mvn/wrapper/maven-wrapper.jar：Maven Wrapper的JAR文件
• .mvn/wrapper/maven-wrapper.properties：配置文件

使用Maven Wrapper构建项目：
  2. # Unix/Linux
  3. ./mvnw clean package
  5. # Windows
  6. mvnw.cmd clean package
复制代码

• 一致性：确保所有开发者使用相同版本的Maven构建项目。
• 便捷性：新加入项目的开发者无需安装Maven即可构建项目。
• CI/CD友好：在持续集成/持续部署环境中，无需预先安装Maven。

使用版本控制的最佳实践

在使用版本控制系统（如Git）管理Maven项目时，应该提交以下文件：

• 源代码（src目录）
• pom.xml文件
• .gitignore文件
• README.md等文档文件
• Maven Wrapper相关文件（mvnw、mvnw.cmd、.mvn目录）

应该忽略以下文件，不提交到版本控制系统：

• target目录（构建输出）
• .idea目录（IntelliJ IDEA配置文件）
• *.iml文件（IntelliJ IDEA模块文件）
• .settings目录（Eclipse配置文件）
• .project文件（Eclipse项目文件）
• .classpath文件（Eclipse类路径文件）
• node_modules目录（如果使用Node.js）
• .DS_Store文件（macOS系统文件）
  2. # Maven
  3. target/
  4. pom.xml.tag
  5. pom.xml.releaseBackup
  6. pom.xml.versionsBackup
  7. pom.xml.next
  8. release.properties
  9. dependency-reduced-pom.xml
  10. buildNumber.properties
  11. .mvn/timing.properties
  13. # IntelliJ IDEA
  14. .idea/
  15. *.iml
  16. *.iws
  17. *.ipr
  18. out/
  20. # Eclipse
  21. .settings/
  22. .classpath
  23. .project
  25. # macOS
  26. .DS_Store
  28. # Windows
  29. Thumbs.db
  30. ehthumbs.db
  31. Desktop.ini
  33. # Node.js
  34. node_modules/
  35. npm-debug.log*
  36. yarn-debug.log*
  37. yarn-error.log*
复制代码

总结

本教程详细介绍了如何在IntelliJ IDEA中搭建Maven项目，并解决开发环境配置中的常见问题。我们首先介绍了环境准备工作，包括JDK安装、IntelliJ IDEA安装和Maven配置。然后详细讲解了如何创建Maven项目，并解析了Maven项目的结构和pom.xml文件。接着，我们讨论了Maven依赖管理和生命周期，这些都是Maven的核心概念。

在常见问题及解决方案部分，我们针对依赖下载问题、编译问题、运行问题和插件配置问题提供了详细的解决方案，帮助开发者快速解决开发过程中遇到的问题。最后，我们介绍了一些最佳实践，包括使用多模块项目、使用Profile、使用Maven Wrapper以及版本控制的最佳实践，这些实践可以帮助开发者更高效地使用Maven管理项目。

通过本教程，开发者应该能够熟练地在IntelliJ IDEA中搭建Maven项目，并能够解决开发环境配置中的常见问题，提高开发效率。Maven是一个强大的项目管理工具，掌握它的使用对于Java开发者来说是非常重要的。希望本教程能够帮助开发者更好地使用Maven，提高开发效率和项目质量。
教程, 搭建, 实战
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
次元宅社
次元宅社
开放、共创，CHANGE SEKAI！
频道订阅

频道订阅

加入社群

加入社群

联系我们|TG频道|RSS

Powered by Pixtech

© 2025 Pixtech Team.