Maven
Maven
基础配置
下载
官网下载，解压
安装
Maven是由java编写的，在使用maven时要确保java变量配置正确
<localRepository>D:\maven-repository</localRepository>
配置
配置本地仓库
配置maven的 bin目录(指令目录)到系统变量path中，以便在任何地方都可执行maven指令
在maven目录下创建仓库文件夹，并在配置文件(conf/setting.xml)中在<localRepository>标签下填入本地仓库地址
配置私服仓库
在setting.xml文件下加入以下标签内容
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf> <!-- 这里是替代范围， *代表作用全部 ， 加个 , 可以作用多个， !+ID名可以排除 -->
</mirror>
配置项目构建版本
在setting.xml中，在 <profiles> </profiles>中增加如下配置:
也可以直接在maven项目的pom.xml文件中直接配置对应属性
<profile>
<id>jdk-17</id>
<activation>
<activeByDefault>true</activeByDefault>
<jdk>17</jdk>
</activation>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<maven.compiler.compilerVersion>17</maven.compiler.compilerVersion>
</properties>
</profile>
如果没有在 pom.xml 中显式配置 maven-compiler-plugin，Maven 会使用默认的 Java 版本进行编译
Maven 3.5.0 及以上版本：默认使用 Java 1.6（即 source 和 target 均为 1.6）
Maven 3.3.9 及以下版本：默认使用 Java 1.5
IDEA集成
基础配置
配置全局参数
进入IDEA的欢迎页面， 选择 IDEA中 File => close project => Customize => All settings
打开 All settings , 选择 Build,Execution,Deployment => Build Tools => Maven
Maven home path处配置Maven的安装目录
User setting file 处配置Maven的setting.xml路径
Local repository 处配置Maven的仓库路径
配置工程的编译版本为对应java版本
项目创建
maven项目结构
Maven工程相对之前的项目，多出一组gavp属性，gav需要我们在创建项目的时候指定，p有默认值
Maven 中的 GAVP 是指 GroupId、ArtifactId、Version、Packaging 等四个属性的缩写，其中前三个是必要的，而 Packaging 属性为可选项
GroupID 格式：com.{公司/BU }.业务线.[子业务线]，最多 4 级。 //一般是域名反写
ArtifactID 格式：产品线名-模块名 //一般是模块名
Version版本号格式推荐：主版本号.次版本号.修订号
release为稳定版本号，也就是默认版本号
SNAPSHOT 为快照版本号，在版本后面加上-SNAPSHOT 及为 ，例: 1.0.0-SNAPSHOT
Packaging: 分为 jar(默认) ,war , pom
内部结构：
|-- pom.xml # Maven 项目管理文件
|-- src
|-- main # 项目主要代码
| |-- java # Java 源代码目录
| | `-- com/example/myapp # 开发者代码主目录
| | |-- controller # 存放 Controller 层代码的目录
| | |-- service # 存放 Service 层代码的目录
| | |-- dao # 存放 DAO 层代码的目录
| | `-- model # 存放数据模型的目录
| |-- resources # 资源目录，存放配置文件、静态资源等
| | |-- log4j.properties # 日志配置文件
| | |-- spring-mybatis.xml # Spring Mybatis 配置文件
| | `-- static # 存放静态资源的目录
| | |-- css # 存放 CSS 文件的目录
| | |-- js # 存放 JavaScript 文件的目录
| | `-- images # 存放图片资源的目录
| `-- webapp # 存放 WEB 相关配置和资源
| |-- WEB-INF # 存放 WEB 应用配置文件
| | |-- web.xml # Web 应用的部署描述文件
| | `-- classes # 存放编译后的 class 文件
| `-- index.html # Web 应用入口页面
`-- test # 项目测试代码
|-- java # 单元测试目录
`-- resources # 测试资源目录
命令方式项目构建
使用maven命令需要再pom.xml文件目录下使用
| 命令 | 描述 |
|---|---|
| mvn compile | 编译项目，生成target文件 |
| mvn package | 打包项目，生成jar或war文件 |
| mvn clean | 清理编译或打包后的项目结构 |
| mvn install | 打包后上传到maven本地仓库 |
| mvn deploy | 只打包，上传到maven私服仓库 |
| mvn site | 生成站点 |
| mvn test | 执行测试源码 |
install作用：
可以把自己编写的模块打包然后安装到本地仓库中，在引入自己写入模块然后打包时，可以成功打包
IDEA可视化构建
在idea可以可视化的点击式执行各个命令
maven项目导入
方式一：
File -> Project Structure -> Modules -> Import Module -> 选择maven项目的pom.xml。
方式二：
Maven面板 -> +（Add Maven Projects） -> 选择maven项目的pom.xml。
如果没有Maven面板，选择 View => Appearance => Tool Window Bars
依赖管理
依赖配置
在pom.xml文件内配置
注：
在idea同一个项目中，每个模块不用安装到仓库就可以相互之间进行依赖
<!-- 模型版本 -->
<modelVersion>4.0.0</modelVersion>
<!-- 公司或者组织的唯一标志，并且配置时生成的路径也是由此生成， 如com.companyname.project-group，maven会将该项目打成的jar包放本地路径：/com/companyname/project-group -->
<groupId>com.companyname.project-group</groupId>
<!-- 项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
<artifactId>project</artifactId>
<!-- 版本号 -->
<version>1.0.0</version>
<!--打包方式
默认：jar
jar指的是普通的java项目打包方式！ 项目打成jar包！
war指的是web项目打包方式！项目打成war包！
jar包和war包的打包一般需要使用插件打包
若jar包只是打成小包(作为API)，不用使用插件
pom不会讲项目打包！这个项目作为父工程，被其他工程聚合或者继承！后面会讲解两个概念
-->
<packaging>jar/pom/war</packaging>
<!--
通过编写依赖jar包的gav必要属性，引入第三方依赖！
scope属性是可选的，可以指定依赖生效范围！
依赖信息查询方式：
1. maven仓库信息官网 https://mvnrepository.com/
2. mavensearch插件搜索
-->
<dependencies>
<!-- 引入具体的依赖包 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
<!-- 依赖范围 -->
<scope>runtime</scope>
</dependency>
</dependencies>
依赖版本提取：
<!--声明版本-->
<properties>
<!--命名随便,内部制定版本号即可！-->
<junit.version>4.12</junit.version>
<!-- 也可以通过 maven规定的固定的key，配置maven的参数！如下配置编码格式！-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<!--引用properties声明版本 -->
<version>${junit.version}</version>
</dependency>
</dependencies>
引入本地依赖：
<dependency>
<groupId>com.example</groupId> <!-- 这里填写你的组织ID -->
<artifactId>example</artifactId> <!-- 这里填写你的项目ID -->
<version>1.0.0</version> <!-- 这里填写你的项目版本 -->
<scope>system</scope> <!-- scope设置为system -->
<systemPath>${basedir}/path/to/your/lib/example.jar</systemPath> <!-- 本地依赖的路径 -->
</dependency>
${basedir}是Maven内置变量，表示项目根目录的路径。groupId,artifactId,version需要你根据实际情况填写，它们构成了依赖的唯一标识。systemPath是本地依赖的绝对路径或者相对于项目根目录的路径。
依赖范围
通过设置坐标的依赖范围(scope)，可以设置 对应jar包的作用范围：编译环境、测试环境、运行环境(打包后)
| 依赖范围 | 描述 |
|---|---|
| compile | 编译依赖范围，scope 元素的缺省值。使用此依赖范围的 Maven 依赖，对于三种 classpath 均有效，即该 Maven 依赖在上述三种 classpath 均会被引入。例如，log4j 在编译、测试、运行过程都是必须的。 |
| test | 测试依赖范围。使用此依赖范围的 Maven 依赖，只对测试 classpath 有效。例如，Junit 依赖只有在测试阶段才需要。 |
| provided | 已提供依赖范围。使用此依赖范围的 Maven 依赖，只对编译 classpath 和测试 classpath 有效。例如，servlet-api 依赖对于编译、测试阶段而言是需要的，但是运行阶段，由于外部容器已经提供，故不需要 Maven 重复引入该依赖。 |
| runtime | 运行时依赖范围。使用此依赖范围的 Maven 依赖，只对测试 classpath、运行 classpath 有效。例如，JDBC 驱动实现依赖，其在编译时只需 JDK 提供的 JDBC 接口即可，只有测试、运行阶段才需要实现了 JDBC 接口的驱动。 |
| system | 系统依赖范围，其效果与 provided 的依赖范围一致。其用于添加非 Maven 仓库的本地依赖，通过依赖元素 dependency 中的 systemPath 元素指定本地依赖的路径。鉴于使用其会导致项目的可移植性降低，一般不推荐使用。 |
| import | 导入依赖范围，该依赖范围只能与 dependencyManagement 元素配合使用，其功能是将目标 pom.xml 文件中 dependencyManagement 的配置导入合并到当前 pom.xml 的 dependencyManagement 中。 |
compile的依赖可以供main内的所有类使用，并且编译后依赖任提供，也就是依赖也包含在打包队列内
provide供main使用但编译后不存在，也就是依赖包含在打包队列
依赖传递
概念：
假如有Maven项目A，项目B依赖A，项目C依赖B。那么我们可以说 C依赖A。
也就是说，依赖的关系为：C—>B—>A， 那么我们执行项目C时，会自动把B、A都下载导入到C项目的jar包文件夹中，这就是依赖的传递性。
传递规则：
在 A 依赖 B，B 依赖 C 的前提下，C 是否能够传递到 A，取决于 B 依赖 C 时使用的依赖范围以及配置
只能传递依赖范围为 complie 的依赖
若不想传递该依赖，可设置
依赖传递终止：
非compile范围进行依赖传递
使用optional配置终止传递
依赖冲突（传递的依赖已经存在）
依赖冲突
发生：
当直接引用或者间接引用出现了相同的jar包
Maven自动解决方式：
自动选择原则
短路优先原则（第一原则）
A—>B—>C—>D—>E—>X(version 0.0.1)
A—>F—>X(version 0.0.2)
则A依赖于X(version 0.0.2)。
依赖路径长度相同情况下，则“先声明优先”（第二原则）
A—>E—>X(version 0.0.1)
A—>F—>X(version 0.0.2)
在<depencies></depencies>中，先声明的，路径相同，会优先选择！
手动排除：
定义<exclusion> </exclusion>标签
<dependency>
<groupId>com.atguigu.maven</groupId>
<artifactId>pro01-maven-java</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>compile</scope>
<!-- 使用excludes标签配置依赖的排除 -->
<exclusions>
<!-- 在exclude标签中配置一个具体的排除 -->
<exclusion>
<!-- 指定要排除的依赖的坐标（不需要写version） -->
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
依赖下载问题
在使用 Maven 构建项目时，可能会发生依赖项下载错误的情况，主要原因有以下几种：
下载依赖时出现网络故障或仓库服务器宕机等原因，导致无法连接至 Maven 仓库，从而无法下载依赖。
依赖项的版本号或配置文件中的版本号错误，或者依赖项没有正确定义，导致 Maven 下载的依赖项与实际需要的不一致，从而引发错误。
本地 Maven 仓库或缓存被污染或损坏，导致 Maven 无法正确地使用现有的依赖项。
解决方案：
确保依赖项的版本号与项目对应的版本号匹配，并检查 POM 文件中的依赖项是否正确
清除本地 Maven 仓库缓存（lastUpdated 文件），因为只要存在lastupdated缓存文件，刷新也不会重新下载。
本地仓库中，根据依赖的gav属性依次向下查找文件夹，最终删除内部的文件，刷新重新下载
项目构建
Build构建配置
默认情况下，构建不需要额外配置，都有对应的缺省配置。们也可以在pom.xml定制一些配置，来修改默认构建的行为和产物
如：
指定构建打包文件的名称，非默认名称
制定构建打包时，指定包含文件格式和排除文件
打包插件版本过低，配置更高版本插件
构建配置是在pom.xml / build标签中指定
指定打包命名
<!-- 默认的打包名称：artifactid+verson.打包方式 -->
<build>
<finalName>定义打包名称</finalName>
</build>
指定打包文件
https://blog.csdn.net/w727655308/article/details/121586559 resource教程
如果在java文件夹中添加java类，会自动打包编译到classes文件夹下！
但是在java文件夹中添加xml文件，默认不会被打包！
默认情况下，按照maven工程结构放置的文件会默认被编译和打包！
在resource下的都会被打包到classes更目录，也就是jar包根目录
除此之外、我们可以使用resources标签，指定要打包资源的文件夹要把哪些静态资源打包到 classes根目录下！
应用场景：mybatis中有时会将用于编写SQL语句的映射文件和mapper接口都写在src/main/java下的某个包中，此时映射文件就不会被打包，如何解决
<build>
<!--设置要打包的资源位置-->
<resources>
<resource>
<!--设置资源所在目录-->
<directory>src/main/java</directory>
<includes>
<!--设置包含的资源类型-->
<include>**/*.xml</include>
</includes>
</resource>
</resources>
</build>
配置依赖插件
在build/plugins/plugin标签引入插件
常用的插件：修改jdk版本、tomcat插件、mybatis分页插件、mybatis逆向工程插件等等
<build>
<plugins>
<!-- java编译插件，配jdk的编译版本 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<!-- tomcat插件 -->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<port>8090</port>
<path>/</path>
<uriEncoding>UTF-8</uriEncoding>
<server>tomcat7</server>
</configuration>
</plugin>
</plugins>
</build>
打包
默认方式
不使用maven-plugin插件普通方式打包
一般的maven项目的打包命令，不会把依赖的jar包也打包进去的，只是会放在jar包的同目录下，能够引用就可以了
使用插件打包
Maven可以使用mvn package指令对项目进行打包，如果使用java -jar xxx.jar执行运行jar文件，
会出现"no main manifest attribute, in xxx.jar"（没有设置Main-Class）、ClassNotFoundException（找不到依赖包）等错误。
要想jar包能直接通过java -jar xxx.jar运行，需要满足：
在jar包中的META-INF/MANIFEST.MF中指定Main-Class，这样才能确定程序的入口在哪里
要能加载到依赖包
可以使用插件生成能直接运行的jar包
插件标签
<!--使用的插件列表 。 -->
<plugins>
<!--plugin元素包含描述插件所需要的信息。 -->
<plugin>
<!--插件在仓库里的group ID -->
<groupId />
<!--插件在仓库里的artifact ID -->
<artifactId />
<!--被使用的插件的版本（或版本范围） -->
<version />
<!--是否从该插件下载Maven扩展（例如打包和类型处理器），由于性能原因，只有在真需要下载时，该元素才被设置成enabled。 -->
<extensions />
<!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。 -->
<executions>
<!--execution元素包含了插件执行需要的信息 -->
<execution>
<!--执行目标的标识符，用于标识构建过程中的目标，或者匹配继承过程中需要合并的执行目标 -->
<id />
<!--绑定了目标的构建生命周期阶段，如果省略，目标会被绑定到源数据里配置的默认阶段 -->
<phase />
<!--配置的执行目标 -->
<goals />
<!--配置是否被传播到子POM -->
<inherited />
<!--作为DOM对象的配置 -->
<configuration />
</execution>
</executions>
<!--项目引入插件所需要的额外依赖 -->
<dependencies>
<!--参见dependencies/dependency元素 -->
<dependency>
......
</dependency>
</dependencies>
<!--任何配置是否被传播到子项目 -->
<inherited />
<!--作为DOM对象的配置 -->
<configuration />
</plugin>
</plugins>
最小化打包
使用maven-jar-plugin和maven-dependency-plugin插件打包
maven-jar-plugin用于生成META-INF/MANIFEST.MF文件的部分内容
只是生成MANIFEST.MF文件还不够，maven-dependency-plugin插件用于将依赖包拷贝到
配置完成后，通过mvn package指令打包，会在target目录下生成jar包，并将依赖包拷贝到target/lib目录下
这种方式生成jar包有个缺点，就是生成的jar包太多不便于管理，下面两种方式只生成一个jar文件，包含项目本身的代码、资源以及所有的依赖包
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.6</version>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<classpathPrefix>lib/</classpathPrefix>
<mainClass>com.xxg.Main</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.10</version>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/lib</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
maven-assembly-plugin
mvn package assembly:single
打包后会在target目录下生成一个xxx-jar-with-dependencies.jar文件，这个文件不但包含了自己项目中的代码和资源，
还包含了所有依赖包的内容。所以可以直接通过java -jar来运行
此外还可以直接通过mvn package来打包，无需assembly:single，不过需要加上一些配置
其中
不过，如果项目中用到spring Framework，用这种方式打出来的包运行时会出错
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.5.5</version>
<configuration>
<archive>
<manifest>
<mainClass>com.xxg.Main</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</plugin>
</plugins>
</build>
无需assembly:single
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.5.5</version>
<configuration>
<archive>
<manifest>
<mainClass>com.xxg.Main</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
-------------------------------------
<build>
<plugins>
<!-- 配置 maven-compiler-plugin -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<source>11</source> <!-- Java 版本 -->
<target>11</target>
</configuration>
</plugin>
<!-- 配置 maven-assembly-plugin -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.5.0</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef> <!-- 文件名后缀 -->
</descriptorRefs>
<archive>
<manifest>
<mainClass>com.example.Main</mainClass> <!-- 指定主类 -->
</manifest>
</archive>
</configuration>
<executions>
<execution>
<phase>package</phase> <!-- 绑定到 package 阶段 -->
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
maven-shade-plugin
https://blog.csdn.net/Ares5kong/article/details/128832989
<build>
<plugins>
<!-- 配置 maven-compiler-plugin -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<source>11</source> <!-- Java 版本 -->
<target>11</target>
</configuration>
</plugin>
<!-- 配置 maven-shade-plugin -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.4.1</version>
<executions>
<execution>
<phase>package</phase> <!-- 绑定到 package 阶段 -->
<goals>
<goal>shade</goal>
</goals>
<configuration>
<filters>
<filter>
<artifact>*:*</artifact> <!-- 匹配所有依赖（任何 groupId 和 artifactId） -->
<excludes>
<exclude>META-INF/*.SF</exclude> <!-- 排除签名文件 -->
<exclude>META-INF/*.DSA</exclude> <!-- 排除 DSA 算法签名文件 -->
<exclude>META-INF/*.RSA</exclude> <!-- 排除 RSA 算法签名文件 -->
</excludes>
</filter>
</filters>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.example.Main</mainClass> <!-- 指定主类 -->
</transformer>
</transformers>
<!-- 显式包含 system 作用域依赖 -->
<artifactSet>
<includes>
<include>com.example:local-lib</include>
</includes>
</artifactSet>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
java结构
无论是 IDEA 还是 Maven 构建的 JAR 包，其基本结构是类似的，通常包括以下内容：
my-app.jar
│
├── META-INF/
│ └── MANIFEST.MF # 描述文件，包含主类等信息
│
├── com/ # 编译后的 class 文件
│ └── example/
│ └── MyClass.class
│
├── resources/ # 资源文件（如配置文件）
│ ├── application.properties
│ └── log4j2.xml
│
└── lib/ # 依赖的第三方库（仅限 fat jar）
├── dependency1.jar
└── dependency2.jar
父子工程
工程继承
概念
Maven 继承是指在 Maven 的项目中，让一个项目从另一个项目中继承配置信息的机制。
继承可以让我们在多个项目中共享同一配置信息，简化项目的管理和维护工作。
作用
在父工程中统一管理项目中的依赖信息
对一个比较大型的项目进行了模块拆分
一个 project 下面，创建了很多个 module
每一个 module 都需要配置自己的依赖信息
继承语法
父工程
<groupId>com.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 当前工程作为父工程，它要去管理子工程，所以打包方式必须是 pom -->
<packaging>pom</packaging>
子工程
<!-- 使用parent标签指定当前工程的父工程 -->
<parent>
<!-- 父工程的坐标 -->
<groupId>com.atguigu.maven</groupId>
<artifactId>pro03-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<!-- 子工程的坐标 -->
<!-- 如果子工程坐标中的groupId和version与父工程一致，那么可以省略 -->
<!-- <groupId>com.atguigu.maven</groupId> -->
<artifactId>pro04-maven-module</artifactId>
<!-- <version>1.0-SNAPSHOT</version> -->
依赖管理
子工程会继承父工程的所有信息
可以声明
<!-- 使用dependencyManagement标签配置对依赖的管理 -->
<!-- 被管理的依赖并没有真正被引入到工程 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>6.0.10</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>6.0.10</version>
</dependency>
</dependencies>
</dependencyManagement>
<!-- 子工程引用父工程中的依赖信息时，可以把版本号去掉。 -->
<!-- 把版本号去掉就表示子工程中这个依赖的版本由父工程决定。 -->
<!-- 具体来说是由父工程的dependencyManagement来决定。 -->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</dependency>
</dependencies>
注：
子工程虽然继承了父工程，但在打包或安装到仓库后，子工程可以作为一个独立的工程
子工程内的pom文件在打包后会将子工程和父工程的pom文件合并，但任会保留一份对父工程的引用
父工程是作为一个配置管理文件存在
工程聚合
概念
Maven 聚合是指将多个项目组织到一个父级项目中，以便一起构建和管理的机制。
聚合可以帮助我们更好地管理一组相关的子项目，同时简化它们的构建和部署过程。
作用
管理多个子项目：通过聚合，可以将多个子项目组织在一起，方便管理和维护。
构建和发布一组相关的项目：通过聚合，可以在一个命令中构建和发布多个相关的项目，简化了部署和维护工作。
优化构建顺序：通过聚合，可以对多个项目进行顺序控制，避免出现构建依赖混乱导致构建失败的情况
统一管理依赖项：通过聚合，可以在父项目中管理公共依赖项和插件，避免重复定义
语法
<project>
<groupId>com.example</groupId>
<artifactId>parent-project</artifactId>
<packaging>pom</packaging>
<version>1.0.0</version>
<modules>
<module>child-project1</module>
<module>child-project2</module>
</modules>
</project>
注：
父子工程不同于依赖的管理，
依赖的管理是针对于仓库的
工程的聚合是针对各个工程(文件)，上述父工程module指向该工程(模块)路径下的文件
工程的继承也是针对仓库(使用的是仓库坐标引用)
聚合：
在父工程指定聚合后，在父工程内进行的操作会同步到子工程
并且会根据modules内声明的顺序对子工程进行操作
聚合与继承是完全不同的，聚合是对各个模块的统一，使指令的执行更方便有序
浙公网安备 33010602011771号