简体中文 繁體中文 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
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

轻松运行Maven项目 新手也能快速掌握的实用技巧与常见问题解决方案 从环境配置到项目部署的完整流程

威震华夏关云长

3万

主题

317

科技点

3万

积分

大区版主

木柜子打湿

积分
31893

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

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

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

x
1. Maven简介与重要性

Apache Maven是一个强大的项目管理和构建自动化工具，主要用于Java项目。它基于项目对象模型（POM）的概念，能够管理项目的构建、报告和文档。Maven通过一个统一的构建系统、一致的项目结构和依赖管理机制，大大简化了Java项目的开发过程。

Maven的主要优势包括：

• 标准化项目结构：提供了一套标准的项目目录结构，使开发者能够快速理解任何Maven项目
• 依赖管理：自动下载和管理项目所需的库文件，解决手动管理jar包的繁琐工作
• 构建生命周期：定义了清晰的构建阶段，如编译、测试、打包、安装等
• 插件架构：丰富的插件生态系统，支持各种构建任务
• 多模块支持：方便地管理复杂的多模块项目

对于新手来说，掌握Maven是进入Java开发世界的必备技能，它能让您更专注于代码编写，而非项目配置和管理。

2. 环境配置

2.1 安装JDK

Maven是基于Java的工具，因此在安装Maven之前，需要确保系统已正确安装Java Development Kit (JDK)。

1. 下载JDK：访问Oracle官网或OpenJDK官网，下载适合您操作系统的JDK版本（建议使用JDK 8或更高版本）。
2. 安装JDK：按照安装向导完成安装。
3.
  2. 配置环境变量：Windows系统：
  3. “`bash设置JAVA_HOME环境变量JAVA_HOME=C:\Program Files\Java\jdk-11.0.12# 将%JAVA_HOME%\bin添加到PATH环境变量
  4. PATH=%JAVA_HOME%\bin;%PATH%- Linux/Mac系统：
  5. ```bash
  6. # 编辑~/.bashrc或~/.zshrc文件
  7. export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
  8. export PATH=$JAVA_HOME/bin:$PATH
  10. # 使配置生效
  11. source ~/.bashrc
复制代码
4.
  2. Windows系统：
  3. “`bash设置JAVA_HOME环境变量JAVA_HOME=C:\Program Files\Java\jdk-11.0.12
复制代码
5. 验证JDK安装：java -version
javac -version如果正确显示Java版本信息，说明JDK安装成功。

下载JDK：访问Oracle官网或OpenJDK官网，下载适合您操作系统的JDK版本（建议使用JDK 8或更高版本）。

安装JDK：按照安装向导完成安装。

配置环境变量：

•
  2. Windows系统：
  3. “`bash设置JAVA_HOME环境变量JAVA_HOME=C:\Program Files\Java\jdk-11.0.12
复制代码

Windows系统：
“`bash

JAVA_HOME=C:\Program Files\Java\jdk-11.0.12

# 将%JAVA_HOME%\bin添加到PATH环境变量
PATH=%JAVA_HOME%\bin;%PATH%
  2. - Linux/Mac系统：
  3. ```bash
  4. # 编辑~/.bashrc或~/.zshrc文件
  5. export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
  6. export PATH=$JAVA_HOME/bin:$PATH
  8. # 使配置生效
  9. source ~/.bashrc
复制代码

验证JDK安装：
  2. java -version
  3. javac -version
复制代码

如果正确显示Java版本信息，说明JDK安装成功。

2.2 安装Maven

1. 下载Maven：访问Maven官网，下载最新的二进制zip包（例如apache-maven-3.8.6-bin.zip）。
2. 解压Maven：将下载的zip包解压到您选择的目录，如C:\Program Files\Apache\maven（Windows）或/opt/maven（Linux/Mac）。
3.
  2. 配置环境变量：Windows系统：
  3. “`bash设置MAVEN_HOME环境变量MAVEN_HOME=C:\Program Files\Apache\maven\apache-maven-3.8.6# 将%MAVEN_HOME%\bin添加到PATH环境变量
  4. PATH=%MAVEN_HOME%\bin;%PATH%- Linux/Mac系统：
  5. ```bash
  6. # 编辑~/.bashrc或~/.zshrc文件
  7. export MAVEN_HOME=/opt/maven/apache-maven-3.8.6
  8. export PATH=$MAVEN_HOME/bin:$PATH
  10. # 使配置生效
  11. source ~/.bashrc
复制代码
4.
  2. Windows系统：
  3. “`bash设置MAVEN_HOME环境变量MAVEN_HOME=C:\Program Files\Apache\maven\apache-maven-3.8.6
复制代码
5. 验证Maven安装：mvn -version如果显示Maven版本信息，说明安装成功。

下载Maven：访问Maven官网，下载最新的二进制zip包（例如apache-maven-3.8.6-bin.zip）。

解压Maven：将下载的zip包解压到您选择的目录，如C:\Program Files\Apache\maven（Windows）或/opt/maven（Linux/Mac）。

配置环境变量：

•
  2. Windows系统：
  3. “`bash设置MAVEN_HOME环境变量MAVEN_HOME=C:\Program Files\Apache\maven\apache-maven-3.8.6
复制代码

Windows系统：
“`bash

MAVEN_HOME=C:\Program Files\Apache\maven\apache-maven-3.8.6

# 将%MAVEN_HOME%\bin添加到PATH环境变量
PATH=%MAVEN_HOME%\bin;%PATH%
  2. - Linux/Mac系统：
  3. ```bash
  4. # 编辑~/.bashrc或~/.zshrc文件
  5. export MAVEN_HOME=/opt/maven/apache-maven-3.8.6
  6. export PATH=$MAVEN_HOME/bin:$PATH
  8. # 使配置生效
  9. source ~/.bashrc
复制代码

验证Maven安装：
  2. mvn -version
复制代码

如果显示Maven版本信息，说明安装成功。

2.3 配置Maven settings.xml

Maven的主要配置文件是settings.xml，位于Maven安装目录的conf文件夹下。您可以修改此文件以配置本地仓库位置、远程镜像和代理等。

1. 配置本地仓库：<!-- 在settings.xml文件中添加或修改 -->
<localRepository>/path/to/your/local/repo</localRepository>默认情况下，Maven会将下载的依赖存储在用户主目录下的.m2/repository文件夹中。
2.
  2. 配置镜像（以阿里云镜像为例）：<!-- 在settings.xml文件中的<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>使用镜像可以加速依赖下载，特别是在国内网络环境下。
复制代码

配置本地仓库：
  2. <!-- 在settings.xml文件中添加或修改 -->
  3. <localRepository>/path/to/your/local/repo</localRepository>
复制代码

默认情况下，Maven会将下载的依赖存储在用户主目录下的.m2/repository文件夹中。

配置镜像（以阿里云镜像为例）：
  2. <!-- 在settings.xml文件中的<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>
复制代码

使用镜像可以加速依赖下载，特别是在国内网络环境下。

3. Maven项目结构解析

标准的Maven项目具有以下目录结构：
  2. my-app/
  3. |-- pom.xml                 -- 项目对象模型(POM)文件
  4. |-- src/
  5. |   |-- main/
  6. |   |   |-- java/           -- Java源代码目录
  7. |   |   |   `-- com/
  8. |   |   |       `-- mycompany/
  9. |   |   |           `-- app/
  10. |   |   |               `-- App.java
  11. |   |   |-- resources/      -- 资源文件目录
  12. |   |   |   `-- config.properties
  13. |   |   `-- webapp/         -- Web应用目录（如果是Web项目）
  14. |   |       |-- WEB-INF/
  15. |   |       |   `-- web.xml
  16. |   |       `-- index.jsp
  17. |   `-- test/
  18. |       |-- java/           -- 测试源代码目录
  19. |       |   `-- com/
  20. |       |       `-- mycompany/
  21. |       |           `-- app/
  22. |       |               `-- AppTest.java
  23. |       `-- resources/      -- 测试资源文件目录
  24. `-- target/                 -- 构建输出目录（自动生成）
  25.     |-- classes/            -- 编译后的类文件
  26.     `-- my-app-1.0-SNAPSHOT.jar -- 打包后的文件
复制代码

3.1 POM文件详解

POM（Project Object Model）文件是Maven项目的核心，它是一个XML文件，包含了项目的基本信息、配置细节、依赖关系、构建配置等。

一个基本的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.     <!-- 模型版本，固定为4.0.0 -->
  7.     <modelVersion>4.0.0</modelVersion>
  8.    
  9.     <!-- 项目基本信息 -->
  10.     <groupId>com.mycompany.app</groupId>    <!-- 组织或公司标识 -->
  11.     <artifactId>my-app</artifactId>         <!-- 项目标识 -->
  12.     <version>1.0-SNAPSHOT</version>         <!-- 版本号 -->
  13.     <packaging>jar</packaging>              <!-- 打包类型，如jar, war, pom等 -->
  14.    
  15.     <!-- 项目属性 -->
  16.     <properties>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.         <maven.compiler.source>11</maven.compiler.source>
  19.         <maven.compiler.target>11</maven.compiler.target>
  20.     </properties>
  21.    
  22.     <!-- 依赖管理 -->
  23.     <dependencies>
  24.         <dependency>
  25.             <groupId>junit</groupId>
  26.             <artifactId>junit</artifactId>
  27.             <version>4.13.2</version>
  28.             <scope>test</scope>
  29.         </dependency>
  30.     </dependencies>
  31.    
  32.     <!-- 构建配置 -->
  33.     <build>
  34.         <plugins>
  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>
复制代码

POM文件的主要元素包括：

• groupId, artifactId, version：这三个元素通常称为项目的坐标，唯一标识一个项目。
• packaging：定义项目的打包类型，默认为jar，其他常见值包括war（Web应用）、pom（多模块项目的父POM）等。
• properties：定义项目属性，可以在POM文件的其他部分通过${property.name}引用。
• dependencies：定义项目的依赖关系。
• build：包含构建相关的配置，如插件配置等。

4. 常用Maven命令介绍

Maven提供了一套标准的命令来执行各种构建任务。以下是最常用的Maven命令：

4.1 基本命令

1. mvn clean：清理项目，删除target目录及其中的所有内容。mvn clean
2. mvn compile：编译项目源代码。mvn compile
3. mvn test：运行项目中的单元测试。mvn test
4. mvn package：将编译后的代码打包成可分发的格式，如JAR或WAR。mvn package
5. mvn install：将打包好的文件安装到本地Maven仓库，供其他项目引用。mvn install
6. mvn deploy：将最终构建的包复制到远程仓库，以便与其他开发者和项目共享。mvn deploy

mvn clean：清理项目，删除target目录及其中的所有内容。
  2. mvn clean
复制代码

mvn compile：编译项目源代码。
  2. mvn compile
复制代码

mvn test：运行项目中的单元测试。
  2. mvn test
复制代码

mvn package：将编译后的代码打包成可分发的格式，如JAR或WAR。
  2. mvn package
复制代码

mvn install：将打包好的文件安装到本地Maven仓库，供其他项目引用。
  2. mvn install
复制代码

mvn deploy：将最终构建的包复制到远程仓库，以便与其他开发者和项目共享。
  2. mvn deploy
复制代码

4.2 组合命令

Maven命令可以组合使用，以执行多个构建阶段：

1. mvn clean compile：先清理项目，然后编译源代码。mvn clean compile
2. mvn clean package：先清理项目，然后编译、测试并打包。mvn clean package
3. mvn clean install：先清理项目，然后编译、测试、打包并安装到本地仓库。mvn clean install

mvn clean compile：先清理项目，然后编译源代码。
  2. mvn clean compile
复制代码

mvn clean package：先清理项目，然后编译、测试并打包。
  2. mvn clean package
复制代码

mvn clean install：先清理项目，然后编译、测试、打包并安装到本地仓库。
  2. mvn clean install
复制代码

4.3 其他有用命令

1. mvn dependency:tree：显示项目的依赖树。mvn dependency:tree
2. mvn dependency:resolve：解析并下载所有依赖。mvn dependency:resolve
3. mvn archetype:generate：从模板生成新项目。mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
4. mvn site：生成项目站点文档。mvn site
5. mvn help:effective-pom：显示最终生效的POM配置（包括继承和合并后的配置）。mvn help:effective-pom

mvn dependency:tree：显示项目的依赖树。
  2. mvn dependency:tree
复制代码

mvn dependency:resolve：解析并下载所有依赖。
  2. mvn dependency:resolve
复制代码

mvn archetype:generate：从模板生成新项目。
  2. mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
复制代码

mvn site：生成项目站点文档。
  2. mvn site
复制代码

mvn help:effective-pom：显示最终生效的POM配置（包括继承和合并后的配置）。
  2. mvn help:effective-pom
复制代码

5. 依赖管理

Maven最强大的功能之一是依赖管理，它能够自动下载、管理和更新项目所需的库文件。

5.1 添加依赖

在pom.xml文件中，通过dependencies元素添加依赖：
  2. <dependencies>
  3.     <!-- 添加JUnit测试依赖 -->
  4.     <dependency>
  5.         <groupId>junit</groupId>
  6.         <artifactId>junit</artifactId>
  7.         <version>4.13.2</version>
  8.         <scope>test</scope>
  9.     </dependency>
  10.    
  11.     <!-- 添加Spring框架依赖 -->
  12.     <dependency>
  13.         <groupId>org.springframework</groupId>
  14.         <artifactId>spring-core</artifactId>
  15.         <version>5.3.20</version>
  16.     </dependency>
  17.    
  18.     <!-- 添加MySQL驱动依赖 -->
  19.     <dependency>
  20.         <groupId>mysql</groupId>
  21.         <artifactId>mysql-connector-java</artifactId>
  22.         <version>8.0.28</version>
  23.     </dependency>
  24. </dependencies>
复制代码

每个依赖由groupId、artifactId和version三个基本元素组成，它们共同确定一个唯一的依赖。

5.2 依赖范围（Scope）

依赖范围用于控制依赖在不同构建阶段的可用性。常见的依赖范围包括：

• compile：默认范围，在所有构建阶段都可用。
• provided：在编译和测试阶段可用，但在运行时由容器提供（如Servlet API）。
• runtime：在运行和测试阶段可用，但在编译时不需要（如JDBC驱动）。
• test：仅在测试阶段可用（如JUnit）。
• 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>
复制代码

5.3 依赖排除

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

5.4 依赖管理（Dependency Management）

在多模块项目中，可以使用dependencyManagement元素统一管理依赖版本，确保所有模块使用相同版本的依赖：
  2. <dependencyManagement>
  3.     <dependencies>
  4.         <dependency>
  5.             <groupId>org.springframework</groupId>
  6.             <artifactId>spring-core</artifactId>
  7.             <version>5.3.20</version>
  8.         </dependency>
  9.         <dependency>
  10.             <groupId>org.springframework</groupId>
  11.             <artifactId>spring-context</artifactId>
  12.             <version>5.3.20</version>
  13.         </dependency>
  14.     </dependencies>
  15. </dependencyManagement>
复制代码

在子模块中，引用这些依赖时无需指定版本：
  2. <dependencies>
  3.     <dependency>
  4.         <groupId>org.springframework</groupId>
  5.         <artifactId>spring-core</artifactId>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>org.springframework</groupId>
  9.         <artifactId>spring-context</artifactId>
  10.     </dependency>
  11. </dependencies>
复制代码

6. 构建和运行Maven项目

6.1 创建Maven项目

有两种主要方式创建Maven项目：使用命令行或使用IDE（如Eclipse、IntelliJ IDEA）。
  2. # 使用maven-archetype-quickstart模板创建简单的Java项目
  3. mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
  5. # 使用maven-archetype-webapp模板创建Web应用项目
  6. mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-webapp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
复制代码

以IntelliJ IDEA为例：

1. 选择File > New > Project
2. 在左侧选择Maven
3. 勾选Create from archetype
4. 选择合适的archetype（如maven-archetype-quickstart）
5. 填写GroupId、ArtifactId等信息
6. 点击Next，完成项目创建

6.2 构建项目

构建Maven项目通常包括编译、测试、打包等步骤。可以使用以下命令：
  2. # 编译项目
  3. mvn compile
  5. # 运行测试
  6. mvn test
  8. # 打包项目
  9. mvn package
  11. # 安装到本地仓库
  12. mvn install
复制代码

也可以一次性执行多个阶段：
  2. # 清理、编译、测试、打包
  3. mvn clean package
复制代码

6.3 运行项目

对于打包为JAR的Java应用程序，可以使用java命令运行：
  2. # 运行打包后的JAR文件
  3. java -jar target/my-app-1.0-SNAPSHOT.jar
复制代码

如果JAR文件没有设置主类，需要指定主类：
  2. java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App
复制代码

Maven还提供了exec插件来运行项目：
  2. # 使用exec插件运行主类
  3. mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
复制代码

对于Web应用程序（WAR包），需要将其部署到Servlet容器（如Tomcat）中运行：

1. 将WAR文件复制到Tomcat的webapps目录：cp target/my-webapp-1.0-SNAPSHOT.war /path/to/tomcat/webapps/
2. 启动Tomcat服务器：/path/to/tomcat/bin/startup.sh  # Linux/Mac
/path/to/tomcat/bin/startup.bat # Windows
3. 访问应用程序：http://localhost:8080/my-webapp-1.0-SNAPSHOT/

将WAR文件复制到Tomcat的webapps目录：
  2. cp target/my-webapp-1.0-SNAPSHOT.war /path/to/tomcat/webapps/
复制代码

启动Tomcat服务器：
  2. /path/to/tomcat/bin/startup.sh  # Linux/Mac
  3. /path/to/tomcat/bin/startup.bat # Windows
复制代码

访问应用程序：
  2. http://localhost:8080/my-webapp-1.0-SNAPSHOT/
复制代码

另外，可以使用Maven插件（如Tomcat Maven插件或Jetty Maven插件）在开发过程中直接运行Web应用：
  2. # 使用Tomcat插件运行Web应用
  3. mvn tomcat7:run
  5. # 使用Jetty插件运行Web应用
  6. mvn jetty:run
复制代码

6.4 跳过测试

在某些情况下，您可能希望跳过测试以加快构建速度：
  2. # 跳过测试运行
  3. mvn package -DskipTests
  5. # 跳过测试编译和运行
  6. mvn package -Dmaven.test.skip=true
复制代码

7. 常见问题及解决方案

7.1 依赖下载问题

解决方案：

1.
  2. 配置镜像：在settings.xml中添加国内镜像，如阿里云镜像：<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. 使用离线模式：如果已经下载了所需依赖，可以使用离线模式构建：mvn package -o
3. 手动安装依赖：对于无法从远程仓库下载的依赖，可以手动安装到本地仓库：mvn install:install-file -Dfile=/path/to/your.jar -DgroupId=com.example -DartifactId=example-lib -Dversion=1.0 -Dpackaging=jar

配置镜像：在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. </mirrors>
复制代码

使用离线模式：如果已经下载了所需依赖，可以使用离线模式构建：
  2. mvn package -o
复制代码

手动安装依赖：对于无法从远程仓库下载的依赖，可以手动安装到本地仓库：
  2. mvn install:install-file -Dfile=/path/to/your.jar -DgroupId=com.example -DartifactId=example-lib -Dversion=1.0 -Dpackaging=jar
复制代码

7.2 编译问题

解决方案：

1. 确保安装了正确版本的JDK，并配置了JAVA_HOME环境变量。
2. 在pom.xml中指定Java版本：<properties>
   <maven.compiler.source>11</maven.compiler.source>
   <maven.compiler.target>11</maven.compiler.target>
</properties>
3. 或者配置maven-compiler-plugin：<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>
           </configuration>
       </plugin>
   </plugins>
</build>

确保安装了正确版本的JDK，并配置了JAVA_HOME环境变量。

在pom.xml中指定Java版本：
  2. <properties>
  3.    <maven.compiler.source>11</maven.compiler.source>
  4.    <maven.compiler.target>11</maven.compiler.target>
  5. </properties>
复制代码

或者配置maven-compiler-plugin：
  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>
复制代码

7.3 插件问题

解决方案：

1. 确保插件版本与Maven版本兼容。
2. 明确指定插件版本：<build>
   <plugins>
       <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.1</version>
       </plugin>
   </plugins>
</build>
3. 使用-U选项强制更新插件：mvn clean package -U

确保插件版本与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.        </plugin>
  9.    </plugins>
  10. </build>
复制代码

使用-U选项强制更新插件：
  2. mvn clean package -U
复制代码

7.4 资源文件问题

解决方案：

1. 确保资源文件位于src/main/resources目录下。
2. 如果资源文件位于其他目录，需要在pom.xml中配置资源目录：<build>
   <resources>
       <resource>
           <directory>src/main/resources</directory>
       </resource>
       <resource>
           <directory>src/main/config</directory>
       </resource>
   </resources>
</build>
3. 确保资源文件过滤配置正确：<build>
   <resources>
       <resource>
           <directory>src/main/resources</directory>
           <filtering>true</filtering>
       </resource>
   </resources>
</build>

确保资源文件位于src/main/resources目录下。

如果资源文件位于其他目录，需要在pom.xml中配置资源目录：
  2. <build>
  3.    <resources>
  4.        <resource>
  5.            <directory>src/main/resources</directory>
  6.        </resource>
  7.        <resource>
  8.            <directory>src/main/config</directory>
  9.        </resource>
  10.    </resources>
  11. </build>
复制代码

确保资源文件过滤配置正确：
  2. <build>
  3.    <resources>
  4.        <resource>
  5.            <directory>src/main/resources</directory>
  6.            <filtering>true</filtering>
  7.        </resource>
  8.    </resources>
  9. </build>
复制代码

7.5 多模块项目问题

解决方案：

1. 在父POM中正确配置模块顺序：<modules>
   <module>module-a</module>
   <module>module-b</module>
   <module>module-c</module>
</modules>
2. 确保模块间的依赖关系正确：<!-- 在module-b的pom.xml中 -->
<dependencies>
   <dependency>
       <groupId>com.mycompany.app</groupId>
       <artifactId>module-a</artifactId>
       <version>1.0-SNAPSHOT</version>
   </dependency>
</dependencies>
3. 使用聚合构建：# 在父项目目录下执行
mvn clean install

在父POM中正确配置模块顺序：
  2. <modules>
  3.    <module>module-a</module>
  4.    <module>module-b</module>
  5.    <module>module-c</module>
  6. </modules>
复制代码

确保模块间的依赖关系正确：
  2. <!-- 在module-b的pom.xml中 -->
  3. <dependencies>
  4.    <dependency>
  5.        <groupId>com.mycompany.app</groupId>
  6.        <artifactId>module-a</artifactId>
  7.        <version>1.0-SNAPSHOT</version>
  8.    </dependency>
  9. </dependencies>
复制代码

使用聚合构建：
  2. # 在父项目目录下执行
  3. mvn clean install
复制代码

7.6 内存问题

解决方案：

1.
  2. 增加Maven JVM的内存：
  3. “`bashUnix/Linux/Macexport MAVEN_OPTS=”-Xmx512m -XX:MaxPermSize=128m”
复制代码

增加Maven JVM的内存：
“`bash

export MAVEN_OPTS=”-Xmx512m -XX:MaxPermSize=128m”

# Windows
   set MAVEN_OPTS=-Xmx512m -XX:MaxPermSize=128m
  2. 2. 在surefire插件中增加测试内存：
  3.    ```xml
  4.    <build>
  5.        <plugins>
  6.            <plugin>
  7.                <groupId>org.apache.maven.plugins</groupId>
  8.                <artifactId>maven-surefire-plugin</artifactId>
  9.                <version>2.22.2</version>
  10.                <configuration>
  11.                    <argLine>-Xmx512m -XX:MaxPermSize=128m</argLine>
  12.                </configuration>
  13.            </plugin>
  14.        </plugins>
  15.    </build>
复制代码

8. 项目部署流程

8.1 准备部署

在部署项目之前，需要确保以下几点：

1. 版本控制：确保所有代码已提交到版本控制系统（如Git）。
2. 测试完成：运行所有测试，确保没有失败的测试用例。
3. 版本号更新：更新pom.xml中的版本号，遵循语义化版本规范（如1.0.0）。
4. 构建项目：执行完整的构建流程：mvn clean package
  2. mvn clean package
复制代码

8.2 部署到本地仓库

将项目安装到本地Maven仓库，供本地其他项目引用：
  2. mvn clean install
复制代码

8.3 部署到远程仓库

将项目部署到远程Maven仓库（如Nexus、Artifactory等），供团队其他成员使用：

1. 在settings.xml中配置服务器认证信息：<servers>
<server>
   <id>nexus-releases</id>
   <username>admin</username>
   <password>admin123</password>
</server>
<server>
   <id>nexus-snapshots</id>
   <username>admin</username>
   <password>admin123</password>
</server>
</servers>
2.
  2. 在pom.xml中配置分发管理：<distributionManagement>
  3. <repository>
  4.    <id>nexus-releases</id>
  5.    <name>Nexus Release Repository</name>
  6.    <url>http://nexus.example.com/repository/maven-releases/</url>
  7. </repository>
  8. <snapshotRepository>
  9.    <id>nexus-snapshots</id>
  10.    <name>Nexus Snapshot Repository</name>
  11.    <url>http://nexus.example.com/repository/maven-snapshots/</url>
  12. </snapshotRepository>
  13. </distributionManagement>
复制代码
3. 执行部署命令：mvn clean deploy

在settings.xml中配置服务器认证信息：
  2. <servers>
  3. <server>
  4.    <id>nexus-releases</id>
  5.    <username>admin</username>
  6.    <password>admin123</password>
  7. </server>
  8. <server>
  9.    <id>nexus-snapshots</id>
  10.    <username>admin</username>
  11.    <password>admin123</password>
  12. </server>
  13. </servers>
复制代码

在pom.xml中配置分发管理：
  2. <distributionManagement>
  3. <repository>
  4.    <id>nexus-releases</id>
  5.    <name>Nexus Release Repository</name>
  6.    <url>http://nexus.example.com/repository/maven-releases/</url>
  7. </repository>
  8. <snapshotRepository>
  9.    <id>nexus-snapshots</id>
  10.    <name>Nexus Snapshot Repository</name>
  11.    <url>http://nexus.example.com/repository/maven-snapshots/</url>
  12. </snapshotRepository>
  13. </distributionManagement>
复制代码

执行部署命令：
  2. mvn clean deploy
复制代码

8.4 部署到生产环境

1. 准备服务器：确保目标服务器已安装JDK并配置了环境变量。
2. 传输文件：使用SCP、FTP或其他工具将JAR文件传输到服务器：scp target/my-app-1.0.0.jar user@server:/path/to/deploy/
3. 创建启动脚本：创建一个启动脚本来运行应用程序：
“`bash
#!/bin/bash
JAVA_OPTS=”-Xmx512m”
APP_JAR=“/path/to/deploy/my-app-1.0.0.jar”
PID_FILE=“/path/to/deploy/my-app.pid”

准备服务器：确保目标服务器已安装JDK并配置了环境变量。

传输文件：使用SCP、FTP或其他工具将JAR文件传输到服务器：
  2. scp target/my-app-1.0.0.jar user@server:/path/to/deploy/
复制代码

创建启动脚本：创建一个启动脚本来运行应用程序：
“`bash
#!/bin/bash
JAVA_OPTS=”-Xmx512m”
APP_JAR=“/path/to/deploy/my-app-1.0.0.jar”
PID_FILE=“/path/to/deploy/my-app.pid”

case “$1” in
  2. start)
  3.    echo "Starting my-app..."
  4.    if [ -f $PID_FILE ]; then
  5.      echo "my-app is already running."
  6.      exit 1
  7.    fi
  8.    nohup java $JAVA_OPTS -jar $APP_JAR > /dev/null 2>&1 &
  9.    echo $! > $PID_FILE
  10.    echo "my-app started."
  11.    ;;
  12. stop)
  13.    echo "Stopping my-app..."
  14.    if [ ! -f $PID_FILE ]; then
  15.      echo "my-app is not running."
  16.      exit 1
  17.    fi
  18.    kill $(cat $PID_FILE)
  19.    rm $PID_FILE
  20.    echo "my-app stopped."
  21.    ;;
  22. restart)
  23.    $0 stop
  24.    sleep 2
  25.    $0 start
  26.    ;;
  27. *)
  28.    echo "Usage: $0 {start|stop|restart}"
  29.    exit 1
复制代码

esac
  2. 4. **运行应用程序**：
  3.    ```bash
  4.    # 启动应用程序
  5.    ./my-app.sh start
  6.    
  7.    # 停止应用程序
  8.    ./my-app.sh stop
  9.    
  10.    # 重启应用程序
  11.    ./my-app.sh restart
复制代码

1. 准备应用服务器：确保目标服务器已安装Tomcat、Jetty或其他Servlet容器。
2. 传输WAR文件：使用SCP、FTP或其他工具将WAR文件传输到服务器的webapps目录：scp target/my-webapp-1.0.0.war user@server:/path/to/tomcat/webapps/
3. 配置应用服务器：根据需要配置应用服务器，如设置JVM参数、数据源等。
4. 启动应用服务器：
“`bash启动Tomcat/path/to/tomcat/bin/startup.sh

准备应用服务器：确保目标服务器已安装Tomcat、Jetty或其他Servlet容器。

传输WAR文件：使用SCP、FTP或其他工具将WAR文件传输到服务器的webapps目录：
  2. scp target/my-webapp-1.0.0.war user@server:/path/to/tomcat/webapps/
复制代码

配置应用服务器：根据需要配置应用服务器，如设置JVM参数、数据源等。

启动应用服务器：
“`bash

/path/to/tomcat/bin/startup.sh

# 或者重启Tomcat
   /path/to/tomcat/bin/shutdown.sh
   /path/to/tomcat/bin/startup.sh
  2. 5. **验证部署**：访问应用程序URL，确保部署成功：
复制代码

http://server:port/my-webapp-1.0.0/
  2. ### 8.5 自动化部署
  4. 为了简化部署流程，可以使用自动化工具如Jenkins、GitLab CI/CD或GitHub Actions来实现持续集成和持续部署。
  6. 以下是一个简单的GitHub Actions示例，用于自动构建和部署Maven项目：
  8. ```yaml
  9. name: Build and Deploy
  11. on:
  12.   push:
  13.     branches: [ main ]
  14.   pull_request:
  15.     branches: [ main ]
  17. jobs:
  18.   build:
  19.     runs-on: ubuntu-latest
  20.    
  21.     steps:
  22.     - uses: actions/checkout@v2
  23.    
  24.     - name: Set up JDK 11
  25.       uses: actions/setup-java@v2
  26.       with:
  27.         java-version: '11'
  28.         distribution: 'adopt'
  29.         
  30.     - name: Cache Maven packages
  31.       uses: actions/cache@v2
  32.       with:
  33.         path: ~/.m2
  34.         key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
  35.         restore-keys: ${{ runner.os }}-m2
  36.         
  37.     - name: Build with Maven
  38.       run: mvn -B package --file pom.xml
  39.       
  40.     - name: Upload artifact
  41.       uses: actions/upload-artifact@v2
  42.       with:
  43.         name: package
  44.         path: target/*.jar
  45.         
  46.   deploy:
  47.     needs: build
  48.     runs-on: ubuntu-latest
  49.     if: github.ref == 'refs/heads/main'
  50.    
  51.     steps:
  52.     - name: Download artifact
  53.       uses: actions/download-artifact@v2
  54.       with:
  55.         name: package
  56.         
  57.     - name: Deploy to server
  58.       uses: appleboy/scp-action@master
  59.       with:
  60.         host: ${{ secrets.SERVER_HOST }}
  61.         username: ${{ secrets.SERVER_USER }}
  62.         key: ${{ secrets.SERVER_KEY }}
  63.         source: "*.jar"
  64.         target: "/path/to/deploy/"
  65.         
  66.     - name: Restart application
  67.       uses: appleboy/ssh-action@master
  68.       with:
  69.         host: ${{ secrets.SERVER_HOST }}
  70.         username: ${{ secrets.SERVER_USER }}
  71.         key: ${{ secrets.SERVER_KEY }}
  72.         script: |
  73.           cd /path/to/deploy/
  74.           ./my-app.sh restart
复制代码

这个GitHub Actions配置会在代码推送到main分支时自动构建项目，并将构建产物部署到服务器。

总结

通过本文的介绍，您应该已经掌握了从环境配置到项目部署的完整Maven项目运行流程。Maven作为一个强大的项目管理工具，能够极大地简化Java项目的构建、依赖管理和部署过程。对于新手来说，掌握Maven的基本使用是进入Java开发世界的必备技能。

在实际开发中，您可能会遇到各种问题，但通过本文提供的常见问题解决方案，您应该能够解决大部分问题。随着经验的积累，您还可以探索Maven的高级特性，如多模块项目、自定义插件、 profiles等，以进一步提升项目管理的效率。

希望本文能够帮助您轻松运行Maven项目，并在Java开发的道路上取得成功！
实用技巧
回复

使用道具 举报

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

本版积分规则

友情链接

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

频道订阅

加入社群

加入社群

联系我们|TG频道|RSS

Powered by Pixtech

© 2025 Pixtech Team.