JavaWeb-Maven项目结构

2026-05-23

什么是Maven

Maven翻译过来是“专家“，是一个纯java开源项目。通过Maven，可以帮助我们做：

项目的自动构建，包括代码的编译、测试、打包、安装、部署等操作。
依赖管理，项目使用到哪些依赖，可以快速完成导入。
把项目打包成jar或者从外部导入jar库包，就像我们之前学习一样，Jar包越来越多。所以我们需要一个更好的管理方式来导入这些Jar包。

Maven也需要环境，不过Idea自带。
我们如果创建好Maven项目后，会发现有如下不同：

Maven项目

我们先创建一个Maven项目，里面长这样。
示意图

java包：我们的代码一般写在java文件包当中。
resources：Jar包
test：里面东西不会打包，只会用于测试。
pom.xml：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>org.example</groupId>  
    <artifactId>MavenTest</artifactId>  
    <version>1.0-SNAPSHOT</version>  
  
    <properties>        <maven.compiler.source>23</maven.compiler.source>  
        <maven.compiler.target>23</maven.compiler.target>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    </properties>  
</project>

modelVersion：依赖版本，一般不用管。

下面这三个可以被称为坐标：用于唯一区别每个项目，别人如果需要将我们编写的代码作为依赖，那么就必须通过这三个元素来定位我们的项目。我们可以直接在Maven下导入三个坐标，这样就不用下载Jar包，而可以通过Maven自动下载。

groupId 一般用于指定组名称，命名规则一般和包名一致，比如我们这里使用的是org.example，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version 代表项目版本，随着我们项目的开发和改进，版本号也会不断更新，我们可以手动指定当前项目的版本号，其他人使用我们的项目作为依赖时，也可以根本版本号进行选择（这里的SNAPSHOT代表快照，一般表示这是一个处于开发中的项目，正式发布项目一般只带版本号）
properties中一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为1.8，无需进行修改。

Maven依赖导入

我们可以创建一个dependencies节点来管理依赖：

1
2
3

<dependencies>
    //里面填写的就是所有的依赖
</dependencies>

这里面写的就是我们说的坐标，那么这些坐标是从哪里找呢？我们这里有一个网站点开直达坐标。我们直接搜索lombok即可，打开后可以看到已经给我们写出了依赖的坐标：

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.46</version>
    <scope>compile</scope>
</dependency>

我们来导入：示意图
然后就能用了。

你下载后的依赖会保存在本地的一个叫做.m2的文件夹中，可以删除和移动位置，不过需要去Idea设置里面找。在下次导入依赖时，如果Maven发现本地仓库中就已经存在某个依赖，那么就不会再去远程仓库下载了。

而我们还有一个问题，就是有时候下载会很慢，那么这个时候就需要找到Idea安装根目录/plugins/maven/lib/maven3/conf文件夹，找到settings.xml文件，打开编辑：

<mirror>
      <id>nexus-aliyun</id>
      <mirrorOf>*</mirrorOf>
      <name>Nexus aliyun</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

这样，我们就将默认的远程仓库地址（国外），配置为国内的阿里云仓库地址了。

依赖作用域

依赖常用标签简单解释

type：依赖包类型，默认就是 jar，一般不用写
scope：核心！控制依赖在编译、运行、测试哪个阶段生效
optional：可选依赖，别人引用你的项目时，可以不带上这个依赖
exclusions：排除自动带进来的依赖，比如不想别人继承你的 lombok 依赖

scope 四种作用域通俗讲解

compile：从头到尾都用，打包也会打包到项目里
provided：编译用，运行丢。编译后把代码都给我们写好了，自然依赖就不用了。编译必须有这个包。
runtime：编译不用，运行要，运行时必须得有这个包。
test：只给测试用，比如JUnit的情况。
同样的，我们可以在网站上搜索Junit的依赖，我们这里导入最新的JUnit5作为依赖：

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

这个依赖只会在test中起作用，其他文件夹不会。我们再自行去网站把Mybatis和Mysql装一下吧。

resource

Maven还给我们提供了一个resource文件夹，我们可以将一些静态资源，比如配置文件，放入到这个文件夹中，项目在打包时会将资源文件夹中文件一起打包的Jar中，比如我们在这里编写一个Mybatis的配置文件后，创建一个测试用例：

public class MainTest {

    //因为配置文件位于内部，我们需要使用Resources类的getResourceAsStream来获取内部的资源文件
    private static SqlSessionFactory factory;

    //在JUnit5中@Before被废弃，它被细分了：
    @BeforeAll // 一次性开启所有测试案例只会执行一次 (方法必须是static)
    // @BeforeEach 一次性开启所有测试案例每个案例开始之前都会执行一次
    @SneakyThrows
    public static void before(){
        factory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream("mybatis.xml"));
    }


    @DisplayName("Mybatis数据库测试")  //自定义测试名称
    @RepeatedTest(3)  //自动执行多次测试
    public void test(){
        try (SqlSession sqlSession = factory.openSession(true)){
            TestMapper testMapper = sqlSession.getMapper(TestMapper.class);
            System.out.println(testMapper.getStudentBySid(1));
        }
    }
}

我们运行后是长这样的：
示意图

System内部Jar包

我们不从网络仓库下载，从本地导入该怎么弄呢？

<dependency>
     <groupId>javax.jntm</groupId>
     <artifactId>lbwnb</artifactId>
     <version>2.0</version>
     <scope>system</scope>
     <systemPath>C://学习资料/4K高清无码/test.jar</systemPath>
</dependency>

使用这个system并且加上systemPath标签，里面写上路径。

Maven可选依赖

我们可以给项目依赖加上optional标签来表示是否要导入依赖：

1	<optional>true</optional>

比如Mybatis的POM文件中，就存在大量的可选依赖：

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.30</version>
  <optional>true</optional>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.7.30</version>
  <optional>true</optional>
</dependency>
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
  <optional>true</optional>
</dependency>
 ...

也就是说依赖是环环相扣的，Mybatis可能还会导入一些其他依赖。MyBatis 加了optional=true，不强制你导日志包。但它自己有兜底方案，找不到日志就用自己的，所以你不用导也能跑。

Maven排除依赖

我们可以删除可选依赖项目：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.8.1</version>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>

这样就排除掉了：

1 2	<groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-engine</artifactId>

如果我们需要更改版本，那么直接这样排除掉后，再在我们的pom.xml文件中添加新的依赖标签就好了。

Maven继承关系

我们可以基于Maven项目创建子项目：
示意图|697
我们可以看到这子项目的配置文件为：

<?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>  
    <parent>        <groupId>org.example</groupId>  
        <artifactId>MavenTest</artifactId>  
        <version>1.0-SNAPSHOT</version>  
    </parent>  
    <artifactId>ChildMaven</artifactId>  
  
    <properties>        <maven.compiler.source>23</maven.compiler.source>  
        <maven.compiler.target>23</maven.compiler.target>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    </properties>  
</project>

parent标签里面是我们父项目坐标
而我们主项目的配置文件也变了：

<?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>org.example</groupId>  
    <artifactId>MavenTest</artifactId>  
    <version>1.0-SNAPSHOT</version>  
    <packaging>pom</packaging>  
    <modules>        <module>ChildMaven</module>  
    </modules>  
    <properties>        <maven.compiler.source>23</maven.compiler.source>  
        <maven.compiler.target>23</maven.compiler.target>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    </properties>    <dependencies>        <dependency>            <groupId>org.projectlombok</groupId>  
            <artifactId>lombok</artifactId>  
            <version>1.18.46</version>  
            <scope>compile</scope>  
        </dependency>        <dependency>            <groupId>org.junit.jupiter</groupId>  
            <artifactId>junit-jupiter-api</artifactId>  
            <version>6.1.0</version>  
            <scope>test</scope>  
        </dependency>        <dependency>            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>8.0.33</version>  
            <scope>compile</scope>  
        </dependency>        <!-- Source: https://mvnrepository.com/artifact/org.mybatis/mybatis -->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis</artifactId>  
            <version>3.5.19</version>  
            <scope>compile</scope>  
        </dependency>    </dependencies>  
  
</project>

我们可以看到多了：

packaging
modules：模块，我们的子项目。
我们还可以让父Maven项目统一管理所有的依赖，包括版本号等，子项目可以选取需要的作为依赖，而版本全由父项目管理，我们可以将dependencies全部放入dependencyManagement节点，这样父项目就完全作为依赖统一管理：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
    </dependencies>
</dependencyManagement>

我们发现，子项目的依赖失效了，因为现在父项目没有依赖，而是将所有的依赖进行集中管理，子项目需要什么再拿什么即可，同时子项目无需指定版本，所有的版本全部由父项目决定，子项目只需要使用即可：

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

当然，父项目如果还存在dependencies节点的话，里面的内依赖依然是直接继承：

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.8.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
      ...

同样的，如果我们有两个子项目，我们甚至可以让子项目之间进行依赖，我们拿Child2举例：

<dependencies>
    <dependency>
        <groupId>org.example</groupId>
        <artifactId>Child1</artifactId>
    </dependency>
</dependencies>

命令-测试-打包

命令

我们可以看到在IDEA右上角Maven板块中，每个Maven项目都有一个生命周期，实际上这些是Maven的一些插件，每个插件都有各自的功能，比如：

clean命令，执行后会清理整个target文件夹，在之后编写Springboot项目时可以解决一些缓存没更新的问题。
validate命令可以验证项目的可用性。
compile命令可以将项目编译为.class文件。
install命令可以将当前项目安装到本地仓库，以供其他项目导入作为依赖使用
verify命令可以按顺序执行每个默认生命周期阶段（validate，compile，package等）

测试

通过使用test命令，可以一键测试所有位于test目录下的测试案例，请注意有以下要求：

测试类的名称必须是以Test结尾，比如MainTest
测试方法上必须标注@Test注解，实测@RepeatedTest无效

打包

我们的项目在编写完成之后，要么作为Jar依赖，供其他模型使用，要么就作为一个可以执行的程序，在控制台运行，我们只需要直接执行package命令就可以直接对项目的代码进行打包，生成jar文件。

普通 Jar（依赖用）：只打你自己写的代码，很小。
可执行 Jar（能直接运行）：把你写的代码 + 所有依赖框架（Spring、MyBatis 等）全部打包到一起，变成一个独立可运行的大包。
当然，以上方式仅适用于作为Jar依赖的情况，如果我们需要打包一个可执行文件，那么我不仅需要将自己编写的类打包到Jar中，同时还需要将依赖也一并打包到Jar中，因为我们使用了别人为我们通过的框架，自然也需要运行别人的代码，我们需要使用另一个插件来实现一起打包：

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.1.0</version>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <mainClass>com.test.Main</mainClass>
            </manifest>
        </archive>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

在打包之前也会执行一次test命令，来保证项目能够正常运行，当测试出现问题时，打包将无法完成。

当然我们也可以把我们打好的包发布到中心仓库或者私人仓库，不过具体怎么弄就不讲了。

我们之前还讲解了多模块项目，那么多模块下父项目存在一个packing打包类型标签，所有的父级项目的packing都为pom，packing默认是jar类型，如果不作配置，maven会将该项目打成jar包。作为父级项目，还有一个重要的属性，那就是modules，通过modules标签将项目的所有子项目引用进来，在build父级项目时，会根据子模块的相互依赖关系整理一个build顺序，然后依次build。

父项目的 <packing>pom</packing> 到底啥意思？

Maven 项目默认打包类型是 jar（能运行的程序包）。但父项目根本不是程序，它：

不写业务代码
没有启动类
不能运行
只是用来统一管理版本、依赖、配置
所以必须告诉 Maven：

这不是一个普通项目，是一个 “父配置项目”，只打配置文件包，格式叫 pom。