Java开发者必学如何创建Maven项目从环境搭建到项目构建再到依赖管理的完整教程与实战案例分析

威震华夏关云长 · 发表于 2025-8-25 00:30:01

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

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

x

引言

Apache Maven是Java开发中最流行的项目管理和构建工具之一。它通过一个中央信息管理的方式管理项目的构建、报告和文档，极大地简化了Java项目的构建过程。Maven不仅可以帮助开发者管理项目依赖，还可以自动化构建过程，标准化项目结构，从而提高开发效率。本教程将带领Java开发者从零开始，全面掌握Maven的使用，包括环境搭建、项目创建、依赖管理和构建过程，并通过实战案例加深理解。

1. Maven环境搭建

1.1 JDK安装与配置

在安装Maven之前，首先需要确保你的系统上已经安装了Java开发工具包（JDK）。Maven 3.3+版本要求JDK 1.7或更高版本。

检查JDK安装情况：

java -version

复制代码

如果已安装，你会看到类似以下的输出：

java version "1.8.0_291"
Java(TM) SE Runtime Environment (build 1.8.0_291-b10)
Java HotSpot(TM) 64-Bit Server VM (build 25.291-b10, mixed mode)

复制代码

如果未安装，请前往Oracle官网或OpenJDK官网下载并安装适合你操作系统的JDK版本。

1.2 Maven下载与安装

1. 访问Maven官方网站下载最新的Maven二进制压缩包（例如：apache-maven-3.8.6-bin.zip）。
2. 解压下载的压缩包到你选择的目录，例如：Windows:C:\Program Files\Apache\mavenLinux/Mac:/usr/local/apache-maven
3. Windows:C:\Program Files\Apache\maven
4. Linux/Mac:/usr/local/apache-maven

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

解压下载的压缩包到你选择的目录，例如：

• Windows:C:\Program Files\Apache\maven
• Linux/Mac:/usr/local/apache-maven

1.3 环境变量配置

Windows系统：

1. 右键点击”此电脑” → “属性” → “高级系统设置” → “环境变量”
2. 在”系统变量”中点击”新建”，创建变量名为MAVEN_HOME，变量值为你的Maven安装路径（例如：C:\Program Files\Apache\maven）
3. 找到Path变量，点击”编辑”，然后点击”新建”，添加%MAVEN_HOME%\bin

Linux/Mac系统：

编辑~/.bashrc或~/.zshrc文件（取决于你使用的shell），添加以下内容：

export MAVEN_HOME=/usr/local/apache-maven
export PATH=$MAVEN_HOME/bin:$PATH

复制代码

然后执行以下命令使配置生效：

source ~/.bashrc
# 或
source ~/.zshrc

复制代码

1.4 验证Maven安装

打开命令行工具，执行以下命令：

mvn -version

复制代码

如果安装成功，你会看到类似以下的输出：

Apache Maven 3.8.6 (84538c9988a25aec085021c365c560670ad80f63)
Maven home: /usr/local/apache-maven
Java version: 1.8.0_291, vendor: Oracle Corporation, runtime: /Library/Java/JavaVirtualMachines/jdk1.8.0_291.jdk/Contents/Home/jre
Default locale: en_CN, platform encoding: UTF-8
OS name: "mac os x", version: "10.15.7", arch: x86_64, family: "mac"

复制代码

1.5 配置Maven设置文件

Maven的全局配置文件是settings.xml，位于Maven安装目录的conf文件夹下。你可以根据需要修改此文件，例如：

1. 配置本地仓库位置：默认情况下，Maven将依赖下载到用户主目录下的.m2/repository文件夹。你可以通过修改settings.xml来更改这个位置：

<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
| The path to the local repository maven will use to store artifacts.
|
| Default: ${user.home}/.m2/repository
-->
<localRepository>/path/to/your/local/repo</localRepository>
</settings>

复制代码

1. 配置镜像：为了加速依赖下载，可以配置使用国内镜像，例如阿里云镜像：

<mirrors>
<mirror>
<id>aliyunmaven</id>
<mirrorOf>*</mirrorOf>
<name>阿里云公共仓库</name>
<url>https://maven.aliyun.com/repository/public</url>
</mirror>
</mirrors>

复制代码

2. 创建Maven项目

2.1 使用命令行创建Maven项目

Maven提供了多种原型（archetype）来快速创建项目。最常用的是maven-archetype-quickstart，用于创建简单的Java项目。

mvn archetype:generate -DgroupId=com.example -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

复制代码

命令参数说明：

• groupId: 项目组ID，通常是公司或组织域名的倒序
• artifactId: 项目ID，通常是项目名称
• archetypeArtifactId: 原型ID，指定使用哪种原型创建项目
• interactiveMode: 是否使用交互模式，false表示使用非交互模式

执行上述命令后，Maven会在当前目录下创建一个名为my-app的文件夹，其中包含标准的Maven项目结构。

2.2 使用IDE创建Maven项目

1. 打开IntelliJ IDEA，选择”File” → “New” → “Project”
2. 在左侧选择”Maven”
3. 勾选”Create from archetype”
4. 从列表中选择maven-archetype-quickstart
5. 点击”Next”
6. 输入GroupId（例如：com.example）
7. 输入ArtifactId（例如：my-app）
8. 点击”Next”，然后点击”Finish”

1. 打开Eclipse，选择”File” → “New” → “Other”
2. 在对话框中展开”Maven”文件夹，选择”Maven Project”
3. 点击”Next”
4. 勾选”Create a simple project (skip archetype selection)“，或者不勾选以选择原型
5. 点击”Next”
6. 输入GroupId（例如：com.example）
7. 输入ArtifactId（例如：my-app）
8. 点击”Finish”

2.3 Maven Web项目创建

如果你需要创建一个Java Web项目，可以使用maven-archetype-webapp原型：

mvn archetype:generate -DgroupId=com.example -DartifactId=my-webapp -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

复制代码

或者在IDE中选择相应的原型进行创建。

3. Maven项目结构

创建的Maven项目通常具有以下标准目录结构：

my-app
├── pom.xml # 项目对象模型配置文件
├── src
│ ├── main
│ │ ├── java # Java源代码目录
│ │ │ └── com
│ │ │ └── example
│ │ │ └── App.java
│ │ ├── resources # 资源文件目录
│ │ └── webapp # Web应用目录（如果是Web项目）
│ │ ├── WEB-INF
│ │ │ └── web.xml # Web应用配置文件
│ │ └── index.jsp # JSP页面
│ └── test
│ ├── java # 测试Java源代码目录
│ │ └── com
│ │ └── example
│ │ └── AppTest.java
│ └── resources # 测试资源文件目录
└── target # 构建输出目录（由Maven自动生成）

复制代码

3.1 pom.xml文件解析

pom.xml（Project Object Model）是Maven项目的核心配置文件，它包含了项目的基本信息、构建配置、依赖关系等。

以下是一个基本的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-app</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

复制代码

pom.xml文件的主要元素说明：

• modelVersion: 指定POM模型的版本，当前版本为4.0.0
• groupId: 项目组ID，通常是公司或组织域名的倒序
• artifactId: 项目ID，通常是项目名称
• version: 项目版本
• packaging: 项目打包类型，可以是jar、war、pom等
• properties: 项目属性，可以定义一些变量，在POM文件的其他地方引用
• dependencies: 项目依赖列表
• build: 构建配置，包括插件配置等

4. Maven依赖管理

4.1 添加依赖

在pom.xml文件中，可以通过dependencies元素添加项目依赖。每个依赖通过dependency元素定义，包含groupId、artifactId和version三个基本元素。

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

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

复制代码

4.2 依赖范围（Scope）

依赖范围用于控制依赖在不同阶段（编译、测试、运行）的可见性。常见的依赖范围有：

• compile: 默认范围，在编译、测试、运行阶段都可见
• provided: 在编译、测试阶段可见，但在运行阶段由容器提供（例如Servlet API）
• runtime: 在测试、运行阶段可见，但在编译阶段不可见（例如JDBC驱动）
• test: 只在测试阶段可见（例如JUnit）
• system: 类似于provided，但需要显式提供JAR文件，不推荐使用

示例：

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

复制代码

4.3 依赖排除（Exclusions）

有时候，我们可能需要排除某个依赖传递引入的其他依赖。这可以通过exclusions元素实现。

示例：

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

复制代码

4.4 依赖冲突解决

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

要查看依赖树，可以使用以下命令：

mvn dependency:tree

复制代码

输出示例：

[INFO] com.example:my-app:jar:1.0-SNAPSHOT
[INFO] +- junit:junit:jar:4.13.2:test
[INFO] \- org.springframework.boot:spring-boot-starter-web:jar:2.7.5:compile
[INFO] +- org.springframework.boot:spring-boot-starter:jar:2.7.5:compile
[INFO] | +- org.springframework.boot:spring-boot:jar:2.7.5:compile
[INFO] | +- org.springframework.boot:spring-boot-autoconfigure:jar:2.7.5:compile
[INFO] | +- org.springframework.boot:spring-boot-starter-logging:jar:2.7.5:compile
[INFO] | | +- ch.qos.logback:logback-classic:jar:1.2.11:compile
[INFO] | | | \- ch.qos.logback:logback-core:jar:1.2.11:compile
[INFO] | | +- org.apache.logging.log4j:log4j-to-slf4j:jar:2.17.2:compile
[INFO] | | | \- org.apache.logging.log4j:log4j-api:jar:2.17.2:compile
[INFO] | | \- org.slf4j:jul-to-slf4j:jar:1.7.36:compile
[INFO] | +- jakarta.annotation:jakarta.annotation-api:jar:1.3.5:compile
[INFO] | \- org.yaml:snakeyaml:jar:1.30:compile
[INFO] +- org.springframework.boot:spring-boot-starter-json:jar:2.7.5:compile
[INFO] | +- com.fasterxml.jackson.core:jackson-databind:jar:2.13.4.2:compile
[INFO] | | +- com.fasterxml.jackson.core:jackson-annotations:jar:2.13.4:compile
[INFO] | | \- com.fasterxml.jackson.core:jackson-core:jar:2.13.4:compile
[INFO] | +- com.fasterxml.jackson.datatype:jackson-datatype-jsr310:jar:2.13.4:compile
[INFO] | +- com.fasterxml.jackson.module:jackson-module-parameter-names:jar:2.13.4:compile
[INFO] | \- com.fasterxml.jackson.datatype:jackson-datatype-jdk8:jar:2.13.4:compile
[INFO] +- org.springframework.boot:spring-boot-starter-tomcat:jar:2.7.5:compile
[INFO] | +- org.apache.tomcat.embed:tomcat-embed-core:jar:9.0.65:compile
[INFO] | +- org.apache.tomcat.embed:tomcat-embed-el:jar:9.0.65:compile
[INFO] | \- org.apache.tomcat.embed:tomcat-embed-websocket:jar:9.0.65:compile
[INFO] +- org.springframework:spring-webmvc:jar:5.3.23:compile
[INFO] | +- org.springframework:spring-aop:jar:5.3.23:compile
[INFO] | +- org.springframework:spring-beans:jar:5.3.23:compile
[INFO] | +- org.springframework:spring-context:jar:5.3.23:compile
[INFO] | +- org.springframework:spring-core:jar:5.3.23:compile
[INFO] | | \- org.springframework:spring-jcl:jar:5.3.23:compile
[INFO] | +- org.springframework:spring-expression:jar:5.3.23:compile
[INFO] | \- org.springframework:spring-web:jar:5.3.23:compile
[INFO] \- org.springframework:spring-web:jar:5.3.23:compile

复制代码

如果需要手动解决依赖冲突，可以在pom.xml中显式指定要使用的版本：

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.4.2</version>
</dependency>

复制代码

4.5 依赖管理（Dependency Management）

在多模块项目中，为了统一管理依赖版本，可以使用dependencyManagement元素。它不会实际引入依赖，只是定义依赖的版本，子模块需要显式声明依赖但不指定版本。

示例：

<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.7.5</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
</dependency>
</dependencies>
</dependencyManagement>

复制代码

然后在子模块中，可以不指定版本引入依赖：

<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>

复制代码

5. Maven构建生命周期

Maven的构建生命周期是一系列阶段的集合，用于定义项目的构建过程。Maven有三个内置的生命周期：clean、default和site。

5.1 Clean生命周期

Clean生命周期用于清理项目，包含三个阶段：

1. pre-clean: 执行清理前需要完成的工作
2. clean: 移除上一次构建生成的所有文件
3. post-clean: 执行清理后需要完成的工作

最常用的Clean生命周期命令是：

mvn clean

复制代码

5.2 Default生命周期

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

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: 将编译后的代码打包成可发布的格式，如JAR
18. pre-integration-test: 在集成测试前需要完成的准备工作
19. integration-test: 处理并部署必要的包到集成测试环境中
20. post-integration-test: 执行集成测试后需要完成的工作
21. verify: 运行任何检查以验证包是否有效且符合质量标准
22. install: 将包安装到本地仓库，供本地其他项目使用
23. deploy: 将最终包复制到远程仓库，供其他开发者和项目共享

常用的Default生命周期命令有：

mvn compile # 编译项目
mvn test # 运行测试
mvn package # 打包项目
mvn install # 安装到本地仓库
mvn deploy # 部署到远程仓库

复制代码

5.3 Site生命周期

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

1. pre-site: 在生成站点前需要完成的工作
2. site: 生成项目的站点文档
3. post-site: 在生成站点后需要完成的工作
4. site-deploy: 将生成的站点部署到服务器

常用的Site生命周期命令是：

mvn site # 生成项目站点

复制代码

5.4 生命周期阶段与插件目标的关系

Maven的生命周期阶段与插件目标是相关联的。每个生命周期阶段的执行实际上是调用绑定到该阶段的插件目标。例如，compile阶段绑定了maven-compiler-plugin的compile目标，package阶段绑定了maven-jar-plugin的jar目标。

可以通过在pom.xml中配置插件来自定义绑定：

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.8</version>
<executions>
<execution>
<id>validate</id>
<phase>validate</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>Validating project...</echo>
</tasks>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>

复制代码

6. 常用Maven插件

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

maven-compiler-plugin用于编译Java源代码，是Maven的核心插件之一。

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
<compilerArgs>
<arg>-Xlint:all</arg>
</compilerArgs>
</configuration>
</plugin>

复制代码

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

maven-surefire-plugin用于运行单元测试，是Maven的默认测试插件。

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M5</version>
<configuration>
<includes>
<include>**/*Test.java</include>
</includes>
<excludes>
<exclude>**/*IT.java</exclude>
</excludes>
<skipTests>false</skipTests>
<testFailureIgnore>true</testFailureIgnore>
</configuration>
</plugin>

复制代码

6.3 打包插件（maven-jar-plugin）

maven-jar-plugin用于将编译后的代码打包成JAR文件。

<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.App</mainClass>
</manifest>
</archive>
</configuration>
</plugin>

复制代码

6.4 源码插件（maven-source-plugin）

maven-source-plugin用于创建项目的源码JAR包。

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.2.1</version>
<executions>
<execution>
<id>attach-sources</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>

复制代码

6.5 文档插件（maven-javadoc-plugin）

maven-javadoc-plugin用于生成项目的JavaDoc文档。

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>3.3.1</version>
<executions>
<execution>
<id>attach-javadocs</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
<configuration>
<doclint>none</doclint>
</configuration>
</plugin>

复制代码

6.6 Spring Boot插件（spring-boot-maven-plugin）

如果你使用Spring Boot，spring-boot-maven-plugin是必不可少的，它用于创建可执行的JAR包。

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

复制代码

6.7 Tomcat插件（tomcat7-maven-plugin）

tomcat7-maven-plugin用于在开发过程中快速部署和运行Web应用。

<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<port>8080</port>
<path>/</path>
<uriEncoding>UTF-8</uriEncoding>
</configuration>
</plugin>

复制代码

使用此插件运行Web应用的命令：

mvn tomcat7:run

复制代码

7. 实战案例分析

7.1 创建一个Spring Boot Web项目

让我们通过一个完整的实战案例来学习如何使用Maven创建和管理一个Spring Boot Web项目。

首先，使用命令行创建一个新的Maven项目：

mvn archetype:generate -DgroupId=com.example -DartifactId=springboot-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

复制代码

进入项目目录，修改pom.xml文件，添加Spring Boot相关依赖和插件：

<?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>springboot-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>springboot-demo</name>
<description>Spring Boot Demo Project</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.5</version>
<relativePath/>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>

复制代码

在src/main/java目录下创建以下包结构：

com.example.springbootdemo
├── controller # 控制器层
├── service # 服务层
├── repository # 数据访问层
├── model # 实体类
└── SpringbootDemoApplication.java # 应用程序入口类

复制代码

在model包中创建User实体类：

package com.example.springbootdemo.model;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Data
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String email;
}

复制代码

在repository包中创建UserRepository接口：

package com.example.springbootdemo.repository;
import com.example.springbootdemo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

复制代码

在service包中创建UserService接口和实现类：

package com.example.springbootdemo.service;
import com.example.springbootdemo.model.User;
import java.util.List;
public interface UserService {
User saveUser(User user);
User getUserById(Long id);
List<User> getAllUsers();
void deleteUser(Long id);
}

复制代码

package com.example.springbootdemo.service;
import com.example.springbootdemo.model.User;
import com.example.springbootdemo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserRepository userRepository;
@Override
public User saveUser(User user) {
return userRepository.save(user);
}
@Override
public User getUserById(Long id) {
return userRepository.findById(id).orElse(null);
}
@Override
public List<User> getAllUsers() {
return userRepository.findAll();
}
@Override
public void deleteUser(Long id) {
userRepository.deleteById(id);
}
}

复制代码

在controller包中创建UserController类：

package com.example.springbootdemo.controller;
import com.example.springbootdemo.model.User;
import com.example.springbootdemo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
@PostMapping
public User createUser(@RequestBody User user) {
return userService.saveUser(user);
}
@GetMapping("/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
User user = userService.getUserById(id);
if (user == null) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(user);
}
@GetMapping
public List<User> getAllUsers() {
return userService.getAllUsers();
}
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
userService.deleteUser(id);
return ResponseEntity.noContent().build();
}
}

复制代码

在根包中创建SpringbootDemoApplication类：

package com.example.springbootdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringbootDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoApplication.class, args);
}
}

复制代码

在src/main/resources目录下创建application.properties文件：

# 服务器端口配置
server.port=8080
# H2数据库配置
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
# JPA配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

复制代码

使用Maven命令运行应用程序：

mvn spring-boot:run

复制代码

或者先构建再运行：

mvn clean package
java -jar target/springboot-demo-1.0-SNAPSHOT.jar

复制代码

应用程序启动后，可以使用Postman或curl工具测试API：

1. 创建用户：

curl -X POST http://localhost:8080/api/users \
-H "Content-Type: application/json" \
-d '{"name": "John Doe", "email": "john@example.com"}'

复制代码

1. 获取所有用户：

curl http://localhost:8080/api/users

复制代码

1. 根据ID获取用户：

curl http://localhost:8080/api/users/1

复制代码

1. 删除用户：

curl -X DELETE http://localhost:8080/api/users/1

复制代码

1. 访问H2控制台：

打开浏览器，访问http://localhost:8080/h2-console

JDBC URL:jdbc:h2:mem:testdbUser Name:saPassword: 留空

7.2 多模块项目示例

在企业级开发中，通常会将一个复杂的项目拆分为多个模块。下面我们创建一个包含三个模块的多模块项目：common（公共模块）、service（服务模块）和web（Web模块）。

首先，创建父项目：

mvn archetype:generate -DgroupId=com.example -DartifactId=maven-multimodule-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

复制代码

修改父项目的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>maven-multimodule-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>maven-multimodule-demo</name>
<description>Maven Multi-Module Demo Project</description>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<spring.boot.version>2.7.5</spring.boot.version>
</properties>
<modules>
<module>common</module>
<module>service</module>
<module>web</module>
</modules>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring.boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>com.example</groupId>
<artifactId>common</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.example</groupId>
<artifactId>service</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

复制代码

在父项目目录下创建common模块：

cd maven-multimodule-demo
mvn archetype:generate -DgroupId=com.example -DartifactId=common -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

复制代码

修改common模块的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">
<parent>
<artifactId>maven-multimodule-demo</artifactId>
<groupId>com.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>common</artifactId>
<name>common</name>
<description>Common Module</description>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
</project>

复制代码

在common模块中创建一个工具类：

package com.example.common.utils;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class StringUtils {
public static boolean isEmpty(String str) {
return str == null || str.trim().length() == 0;
}
public static boolean isNotEmpty(String str) {
return !isEmpty(str);
}
public static String reverse(String str) {
if (isEmpty(str)) {
return str;
}
return new StringBuilder(str).reverse().toString();
}
}

复制代码

在父项目目录下创建service模块：

mvn archetype:generate -DgroupId=com.example -DartifactId=service -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

复制代码

修改service模块的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">
<parent>
<artifactId>maven-multimodule-demo</artifactId>
<groupId>com.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>service</artifactId>
<name>service</name>
<description>Service Module</description>
<dependencies>
<dependency>
<groupId>com.example</groupId>
<artifactId>common</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
</project>

复制代码

在service模块中创建实体类、仓库接口和服务类：

// 实体类
package com.example.service.model;
import com.example.common.utils.StringUtils;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Data
@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String description;
private Double price;
public String getDisplayName() {
return StringUtils.isEmpty(description) ? name : name + " - " + description;
}
}

复制代码

// 仓库接口
package com.example.service.repository;
import com.example.service.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
}

复制代码

// 服务接口
package com.example.service;
import com.example.service.model.Product;
import java.util.List;
public interface ProductService {
Product saveProduct(Product product);
Product getProductById(Long id);
List<Product> getAllProducts();
void deleteProduct(Long id);
}

复制代码

// 服务实现类
package com.example.service;
import com.example.service.model.Product;
import com.example.service.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ProductServiceImpl implements ProductService {
@Autowired
private ProductRepository productRepository;
@Override
public Product saveProduct(Product product) {
return productRepository.save(product);
}
@Override
public Product getProductById(Long id) {
return productRepository.findById(id).orElse(null);
}
@Override
public List<Product> getAllProducts() {
return productRepository.findAll();
}
@Override
public void deleteProduct(Long id) {
productRepository.deleteById(id);
}
}

复制代码

在父项目目录下创建web模块：

mvn archetype:generate -DgroupId=com.example -DartifactId=web -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

复制代码

修改web模块的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">
<parent>
<artifactId>maven-multimodule-demo</artifactId>
<groupId>com.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>web</artifactId>
<packaging>war</packaging>
<name>web</name>
<description>Web Module</description>
<dependencies>
<dependency>
<groupId>com.example</groupId>
<artifactId>common</artifactId>
</dependency>
<dependency>
<groupId>com.example</groupId>
<artifactId>service</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

复制代码

在web模块中创建应用程序入口类和控制器：

// 应用程序入口类
package com.example.web;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
public class WebApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(WebApplication.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(WebApplication.class);
}
}

复制代码

// 控制器
package com.example.web.controller;
import com.example.service.model.Product;
import com.example.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/products")
public class ProductController {
@Autowired
private ProductService productService;
@PostMapping
public Product createProduct(@RequestBody Product product) {
return productService.saveProduct(product);
}
@GetMapping("/{id}")
public ResponseEntity<Product> getProductById(@PathVariable Long id) {
Product product = productService.getProductById(id);
if (product == null) {
return ResponseEntity.notFound().build();
}
return ResponseEntity.ok(product);
}
@GetMapping
public List<Product> getAllProducts() {
return productService.getAllProducts();
}
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
productService.deleteProduct(id);
return ResponseEntity.noContent().build();
}
}

复制代码

在src/main/resources目录下创建application.properties文件：

# 服务器端口配置
server.port=8080
# H2数据库配置
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
# JPA配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

复制代码

在父项目目录下执行以下命令构建整个项目：

mvn clean package

复制代码

运行Web模块：

cd web
mvn spring-boot:run

复制代码

或者使用Java命令运行：

java -jar web/target/web-1.0-SNAPSHOT.war

复制代码

应用程序启动后，可以使用Postman或curl工具测试API：

1. 创建产品：

curl -X POST http://localhost:8080/api/products \
-H "Content-Type: application/json" \
-d '{"name": "Laptop", "description": "High performance laptop", "price": 999.99}'

复制代码

1. 获取所有产品：

curl http://localhost:8080/api/products

复制代码

1. 根据ID获取产品：

curl http://localhost:8080/api/products/1

复制代码

1. 删除产品：

curl -X DELETE http://localhost:8080/api/products/1

复制代码

8. 最佳实践与常见问题解决

8.1 Maven最佳实践

Maven强调”约定优于配置”的原则，尽量遵循Maven的默认目录结构和命名约定，这样可以减少配置，提高项目的可维护性。

在pom.xml中使用properties元素定义依赖版本号，这样可以集中管理版本，便于升级和维护。

<properties>
<spring.boot.version>2.7.5</spring.boot.version>
<mysql.connector.version>8.0.30</mysql.connector.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>${spring.boot.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.connector.version}</version>
</dependency>
</dependencies>

复制代码

在多模块项目中，使用dependencyManagement元素统一管理依赖版本，确保各模块使用一致的依赖版本。

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

复制代码

根据依赖的用途，合理设置依赖范围（scope），避免不必要的依赖被打包到最终产品中。

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

复制代码

与依赖管理类似，使用pluginManagement元素统一管理插件版本。

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

复制代码

在pom.xml中配置资源过滤，可以在构建过程中动态替换资源文件中的变量。

<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
</build>

复制代码

然后在资源文件中使用${variable}语法引用变量：

# application.properties
app.name=${project.name}
app.version=${project.version}

复制代码

使用Maven Profiles可以针对不同环境（开发、测试、生产等）使用不同的配置。

<profiles>
<profile>
<id>dev</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<environment>dev</environment>
</properties>
</profile>
<profile>
<id>prod</id>
<properties>
<environment>prod</environment>
</properties>
</profile>
</profiles>

复制代码

使用特定Profile构建项目：

mvn clean package -Pprod

复制代码

8.2 常见问题解决

问题：Maven无法从中央仓库下载依赖。

解决方案：

1. 检查网络连接和代理设置。
2. 配置国内镜像，例如阿里云镜像：

<mirrors>
<mirror>
<id>aliyunmaven</id>
<mirrorOf>*</mirrorOf>
<name>阿里云公共仓库</name>
<url>https://maven.aliyun.com/repository/public</url>
</mirror>
</mirrors>

复制代码

1. 清理本地仓库并重新下载：

mvn clean install -U

复制代码

问题：项目中存在多个版本的同一依赖，导致运行时错误。

解决方案：

1. 使用依赖树命令查看依赖关系：

mvn dependency:tree

复制代码

1. 使用dependencyManagement统一管理依赖版本。
2. 使用exclusions排除不需要的依赖：

<dependency>
<groupId>com.example</groupId>
<artifactId>example-library</artifactId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</exclusion>
</exclusions>
</dependency>

复制代码

问题：Maven编译Java代码时出现错误。

解决方案：

1. 检查Java版本是否一致，确保maven.compiler.source和maven.compiler.target与项目使用的Java版本一致。
2. 检查代码中是否有语法错误。
3. 增加编译器的详细输出：

mvn clean compile -X

复制代码

问题：Maven运行测试时失败。

解决方案：

1. 查看测试失败的具体原因。
2. 运行特定的测试类：

mvn test -Dtest=MyTestClass

复制代码

1. 跳过测试：

mvn package -DskipTests

复制代码

问题：Maven构建项目速度很慢。

解决方案：

1. 配置国内镜像加速依赖下载。
2. 使用并行构建：

mvn -T 4 clean package

复制代码

1. 使用Maven构建缓存：

mvn clean package -Dmaven.repo.local=$HOME/.m2/repository

复制代码

1. 增加Maven内存：

export MAVEN_OPTS="-Xmx2g -XX:MaxPermSize=512m"
mvn clean package

复制代码

问题：Maven插件执行失败。

解决方案：

1. 检查插件版本是否兼容。
2. 查看插件执行的详细日志：

mvn clean package -X

复制代码

1. 跳过特定插件的执行：

mvn clean package -Dmaven.javadoc.skip=true

复制代码

9. 总结与进阶学习资源

9.1 总结

本教程全面介绍了Maven的使用，从环境搭建到项目创建，再到依赖管理和构建过程，并通过两个实战案例（单模块Spring Boot项目和多模块企业项目）展示了Maven在实际开发中的应用。

通过本教程，你应该已经掌握了：

1. Maven环境的搭建与配置
2. Maven项目的创建与标准目录结构
3. Maven依赖管理，包括依赖声明、范围、冲突解决等
4. Maven构建生命周期与常用插件
5. 使用Maven构建Spring Boot项目
6. 使用Maven构建多模块企业项目
7. Maven最佳实践与常见问题解决

Maven作为Java项目管理的标准工具，掌握其使用对于Java开发者来说至关重要。通过合理使用Maven，可以大大提高项目构建和管理的效率，减少人为错误，使项目更加规范和易于维护。

9.2 进阶学习资源

如果你想进一步学习Maven，以下资源可能会有所帮助：

1. 官方文档：Maven官方网站Maven官方文档
2. Maven官方网站
3. Maven官方文档
4. 书籍：《Maven实战》《Java构建工具：Maven权威指南》
5. 《Maven实战》
6. 《Java构建工具：Maven权威指南》
7. 在线教程：Baeldung Maven教程W3Schools Maven教程
8. Baeldung Maven教程
9. W3Schools Maven教程
10. 视频教程：YouTube Maven教程B站Maven教程
11. YouTube Maven教程
12. B站Maven教程
13. 高级主题：Maven插件开发Maven Archetype开发Maven与CI/CD集成（如Jenkins、GitHub Actions等）Maven与Docker集成
14. Maven插件开发
15. Maven Archetype开发
16. Maven与CI/CD集成（如Jenkins、GitHub Actions等）
17. Maven与Docker集成

官方文档：

• Maven官方网站
• Maven官方文档

书籍：

• 《Maven实战》
• 《Java构建工具：Maven权威指南》

在线教程：

• Baeldung Maven教程
• W3Schools Maven教程

视频教程：

• YouTube Maven教程
• B站Maven教程

高级主题：

• Maven插件开发
• Maven Archetype开发
• Maven与CI/CD集成（如Jenkins、GitHub Actions等）
• Maven与Docker集成

通过不断学习和实践，你将能够更加熟练地使用Maven，为你的Java开发工作带来更高的效率和更好的体验。

版权声明

1、转载或引用本网站内容(Java开发者必学如何创建Maven项目从环境搭建到项目构建再到依赖管理的完整教程与实战案例分析)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://www.pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://www.pixtech.cc/thread-31454-1-1.html

	通知：是的！我们正在计划一个大动作！	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

活动公告

Java开发者必学如何创建Maven项目从环境搭建到项目构建再到依赖管理的完整教程与实战案例分析

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

版权声明

浏览过的版块

财Doro

三倍冰淇淋

无人之境【一阶】

立华奏

小樱（小丑装）

⑨的冰沙

以外的星空【二阶】

友情链接

频道订阅

加入社群