Day63.Maven的安装配置与使用、Lombok、POM、依赖、继承、聚合

1.Maven 1天   项目管理工具和依赖（jar）管理工具，替代了之前的依赖管理方式和项目管理方式，目前最流行的

2.MyBatis 3天封装并替代JDBC

3.Spring 3天   核心技术IoC和AOP，软件开发的春天，解耦，不重复的造轮子，粘合剂，整合其他的技术

4.SpringMVC 6天封装并替代了Servlet  规定了请求--响应的流程   除了核心内容，还包括应用专题，axios restful，上传下载，SSM

5.Linux 2天开源的操作系统，服务器端占有统治地位其他操作系统window unix 后面的很多软件都要安装在Linux上面

6.Redis 2天    NoSQL数据库(MySQL是关系数据库)，采用key-value的方式，最大的优点就是快。秒杀效果

7.美年旅游项目 9天：巩固原有内容+学习新的技术（Dubbo、Zookeeper、Vue、EelementUi、Echarts、百度地图、短信验证码，POI）

Maven

1. Maven 是 Apache 开源组织奉献的一个开源项目。Maven 这个词可以翻译为“知识的积累”，也可以翻译为“专家”或“内行”。

2. Maven是一款自动化构建（build）工具，专注服务于Java平台的项目构建和依赖管理。将项目开发和管理过程抽象成一个项目对象模型（POM）。

架构工具的发展：Make→Ant→Maven→Gradle→其他……

Maven官网地址：Maven – Welcome to Apache Maven

Maven官方仓库：https://mvnrepository.com/

为什么要学习Maven？

『依赖管理』角度解释

1.jar包的存放 2.jar包的来源 3.jar包之间的依赖关系

『项目管理』角度解释

①将项目拆分成多个工程模块并进行管理：Maven中可以建立项目之间的依赖、继承、聚合等关系来实现要求。

Maven中可以建立项目之间的依赖、继承、聚合等关系来实现要求。

②项目的分布式部署

在实际生产环境中，项目规模增加到一定程度后，可能每个模块都需要运行在独立的服务器上，我们称之为分布式部署。Maven也可以实现。

『项目目录结构』角度解释

JavaEE开发领域普遍认同一个观点：约定>配置>编码。

一、项目构建

Java项目开发过程中，构建指的是使用『原材料生产产品』的过程。

原材料：Java源代码、基于HTML的Thymeleaf文件、图片、配置文件…

产品：一个可以在服务器上运行的项目。

构建过程包含的主要的环节：

①清理：删除以前的编译结果，为重新编译做好准备。

②编译：将Java源程序编译为字节码文件。

③测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性。

④报告：在每一次测试后以标准的格式记录和展示测试结果。

⑤打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java工程对应jar包，Web工程对应war包。

⑥安装：在Maven环境下特指将打包的结果——jar包或war包安装到本地仓库中。

⑦部署：将打包的结果部署到远程仓库或将war包部署到服务器上运行。

工作中有大量的重复内容。

能否将这些程式化的工作交给机器自动完成呢？——这就是自动化构建。

Maven又是如何实现自动化构建：Maven可以自动的从构建过程的起点一直执行到终点：

二、安装Maven

1. 仓库 (repository)

在Maven中，所有的依赖、插件以及Maven项目(Project) 构建完的输出都是以构件 (artifact) 的形式存在的。

[1] 第三方框架或工具的jar包 (junit.jar mysqk-xxx.jar thymeleaf.jar...)

[2] Maven的插件 plugin

[3] 我们自己开发的项目的模块 (打包成jar包放入仓库)

※不管是什么样的jar包，在仓库中都是按照坐标生成目录结构，所以可以通过统一的方式查询或依赖。

仓库分类：

一、本地仓库：Maven在本地存储构件的地方，对应一个文件夹。为当前本机电脑上的所有Maven工程服务。

二、远程仓库

(1)中央仓库：Maven官方维护的仓库，最权威的仓库。中央仓库就是一个默认的远程仓库。 https://mvnrepository.com/

(2)镜像仓库：为了减轻中央仓库负担，同时更快的响应用户请求，国内外有能力的组织搭建的仓库, 这个仓库就是将中央仓库中的所有内容复制了一份存起来。比如阿里Maven镜像。

(3)私服：一种特殊的远程仓库，它是架设在局域网内的仓库服务，私服代理广域网上的远程仓库，供局域网内的Maven用户使用。使用私服可以节省外网带宽，提高构建速度，提高稳定性，降低中央仓库的负荷；

仓库访问步骤：

有私服：本地库 → 私服 → (中央仓库或者镜像仓库)
没有私服：本地库 → (中央仓库或者镜像仓库)

如果没有指定远程库，默认访问中央仓库。

2. 安装步骤

一、正确配置环境变量：%JAVA_HOME%；echo %path%； java -version

二、下载

官网下载地址：Maven – Download Apache Maven

三、解压 (路径不要用中文)

bin/mvn.cmd：执行Meven的构建命令，需要加载到path中

conf/settings.xml：配置文件，配置本地库位置、远程库位置等

四、配置环境变量

JDK需要配置什么环境变量：JAVA_HOME PATH

Tomcat需要配置什么环境变量：CATALINA_HOME(不是TOMCAT_HOME) PATH (?)

Maven需要配置什么环境变量：M2_HOME(不推荐MAVEN_HOME) PATH

注：path 尽量不要移动到最上面

五、测试: mvn -version；echo %M2_HOME%

六、指定本地仓库 (可选)

本地仓库默认值：用户家目录/.m2/repository。(有些idea版本必须为它)

conf/settings.xm

<localRepository>d:/repository</localRepository>

七、配置远程库：阿里云提供的镜像仓库(可选)、

默认的远程库是Maven中央仓库，在国外，访问量大，速度慢。可以指定为国内的镜像服务器。此处采用阿里镜像服务器。

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

八、配置Maven工程的基础JDK版本

注意：此处的配置是全局配置，针对当前服务器所有 Meven项目，默认jdk版本为1.5。
如果不配置，需要在每个Maven项目中单独配置JDK8版本和编码,，建议配置。

<!--指定JDK版本 -->
<profile>
    <id>jdk-1.8</id>
    <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>1.8</jdk>
    </activation>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
    </properties>
</profile>

3. Maven目录结构

约定>配置>编码。意思就是能用配置解决的问题就不编码，能基于约定的就不进行配置。而Maven正是因为指定了特定文件保存的目录才能够对我们的Java工程进行自动化构建。

src/main/java：存放项目的java类源文件，即：Xxx.java

src/main/resources：存放项目的资源文件，如.xml、.properties

src/test/java：存放项目的用于测试的java类源文件，即：XxxTest.java

src/test/resources：存放项目的测试相关的资源文件,如.xml、.properties

pom.xml：Maven项目的配置文件，是学习Maven的重点

target：编译之后的结果，比如class、资源文件(自动生成)

三、手动创建Java项目

Maven的项目类型有多种，和我们开发相关的项目类型主要有三种：

Java项目：被打包为jar包。
web项目：打包为war包
pom项目：pom项目中不写Java代码, 用来做父项目，用于进行子项目的管理

其中Java项目是默认项目类型，在pom.xml中通过<packaging>来标记项目类型。这里先创建java项目。

1、创建约定目录结构

2、创建Maven的核心配置文件pom.xml

在HelloMaven文件夹下创建Maven的核心配置文件pom.xml，内容如下：

<?xml version="1.0" ?>
<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.atguigu.maven</groupId>
    <artifactId>Hello</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Hello</name>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

3、编写主代码

在src/main/java/com/atguigu/maven目录下新建文件Hello.java

package com.atguigu.maven;
public class HelloMaven {
    public String sayHello(String name){
        return "Hello "+name+"!";
    }
}

4、编写测试代码

在/src/test/java/com/atguigu/test目录下新建测试文件HelloTest.java

package com.atguigu.test;   
import org.junit.Test;
import com.atguigu.maven.HelloMaven;

public class TestHelloMaven {
    @Test
    public void testHello1(){
        HelloMaven hello = new HelloMaven();
        String results = hello.sayHello("Maven");
        System.out.println(results);
    }
	@Test
    public void testHello2(){
        HelloMaven hello = new HelloMaven();
        String results = hello.sayHello("lucky");
        System.out.println(results);
    }
}

5.使用Maven命令构建项目

一定要切换到D:\HelloMaven目录下（也就是pom.xml所在的目录，也就是项目根目录），地址栏输入命令cmd打开命令窗口。

命令	作用
mvn clean	删除target目录

mvn compile	只编译主代码，放入target目录
mvn test-compile	编译主代码和测试代码，放入target目录（resouces也会拷入target目录）
mvn test	编译主代码和测试代码，放入target目录（resouces也会拷入target目录），并且运行测试用例
mvn package	编译主代码和测试代码，放入target目录（resouces也会拷入target目录），并且运行测试用例，将当前项目打包成一个jar
mvn install	完成mvn package的所有功能，并且将当前jar上传到本地库（其他项目也可以使用）
mvn deploy	在install基础上，将当前的jar上传到远程库（需要更多的条件）

Maven生命周期：compile --> test-compile --> -test --> package --> install --> deploy，会自动执行之前的命令

此时jar包的名称就是pom.xml文件中 <artifactId>Hello</artifactId> 标签内的值

四、Idea中创建Java项目

1、在IDEA中集成Maven (2021.3.2版)

2、在IDEA中创建Maven Java工程

3、进行简单代码开发

① pom.xml中添加JUnit、lombok依赖

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

下载资源

② 创建类User并使用lombok注解

package com.atguigu.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data //getter setter toString()
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer uid;
    private String uname;
    private String password;
    private Integer age;
}

③ 创建XML资源文件(resources内)，测试编译内是否存在

<?xml version="1.0" encoding="UTF-8"?>
<users>
</users>

④ 创建测试类TestUser

package com.atguigu.test;

import com.atguigu.entity.User;
import org.junit.Test;

public class TestUser {
    @Test
    public void test01(){
        User user = new User();
        System.out.println(user);
    }
    @Test
    public void test02(){
        User user = new User(1,"zhangsan","123456",23);
        System.out.println(user);
    }

⑤ 测试

各种错误：

1、依赖导入错误：重新加载Maven，从仓库(repository)下载资源。

2、解决乱码问题：(opm.xml内仅单个项目有效，)

<properties>
<argLine>-Dfile.encoding=UTF-8</argLine>
</properties>

在定义当前项目的JDK版本和编码信息,只对当前项目有效 (pom.xml)，Maven配置文件全局配置对所有项目有效。

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<maven.compiler.source>1.8</maven.compiler.source>

<maven.compiler.target>1.8</maven.compiler.target>

3、site：生成站点报告(了解) ClassNotFoundException：需要在pom.xml中配置如下代码

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-site-plugin</artifactId>
                <version>3.7.1</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>3.0.0</version>
            </plugin>
        </plugins>
    </build>

五、关于Lombok

以前的Java项目中，充斥着太多不友好的代码：POJO的getter/setter/toString；异常处理；I/O流的关闭操作等等，这些样板代码既没有技术含量，又影响着代码的美观，Lombok应运而生。

Lombok 是一种 Java™ 实用工具，可用来帮助开发人员消除 Java 的冗长，尤其是对于简单的 Java 对象（POJO）。它通过注解实现这一目的。

最近IDEA 2020最后一个版本发布了，已经内置了Lombok插件，SpringBoot 2.1.x之后的版本也在Starter中内置了Lombok依赖。

@Data	集成了@Getter和@Setter、@ToString、@EqualsAndHashCode、@RequiredArgsConstructor这几个注解与一身，是一个非常强大的注解，这个注解更可以简化注解的代码量
@NoArgsConstructor	在JavaBean中使用，注解会生成对应的无参构造方法
@AllArgsConstructor	在JavaBean中使用，注解会生成对应的有参构造方法
@getter	在JavaBean中使用，注解会生成对应的getter方法
@setter	在JavaBean中使用，注解会生成对应的setter方法
@ToString	在JavaBean中使用，注解会自动重写对应的toStirng方法
@ToString(exclude={"column1","column2"})	排除多个column列所对应的元素
@ToString(of={"column1","column2"})	只生成包含多个column列所对应的元素
@EqualsAndHashCode	在JavaBean中使用，注解会自动重写对应的equals方法和hashCode方法
@Slf4j	在需要打印日志的类中使用，项目中使用slf4j日志框架
@Log4j	在需要打印日志的类中使用，项目中使用log4j日志框架
@NonNull	可以用在字段上，也可以用在方法的参数上，作用是自动帮你判断是否是null，如果是null，就会报空指针异常

导入依赖：

pom.xml
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>

配置：

六、POM | Maven坐标

POM ( Project Object Model，项目对象模型) 是Maven项目的基本工作单元，是一个XML文件，位于项目根目录，包含了项目基本信息，用于描述项目如何构建，声明项目依赖等。

Maven工程的核心配置。可以说学习Maven就是学习pom.xml文件中的配置。

<properties>
    <!--项目字符编码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--源代码编译时JDK版本 -->
    <maven.compiler.source>11</maven.compiler.source>
    <!--运行时JDK版本 -->
    <maven.compiler.target>11</maven.compiler.target>
</properties>

Maven的坐标

Maven的坐标元素包括groupId(分组名)、artifactId(构建名)、version、packaging、classfier等，

其中groupId、artifactId、version是必须定义的，即可唯一的标记一个坐标(可以在本地仓库中找到)，称为坐标三要素，简称GAV。

[1]group Id(分组名)：公司或组织的域名倒序+当前项目名称

[2]artifact Id(构建名)：当前项目的模块名称

[3]version(版本)：当前模块的版本

[4]packaging：项目类型

<groupId>com.atguigu.maven</groupId>

<artifactId>Hello</artifactId>

<version>0.0.1-SNAPSHOT</version>

<packaging>war</packaging><--不写默认为jar-->

七、创建Web项目

方法二：安装 JBLJavaToWeb 插件

方法一：手动创建

1、pom.xml 指定项目类型：<packaging>war</packaging>

2、添加web支持

4. 指定web.xml的位置

5. 指定web项目的根目录

6. 添加web资源，配置Tomcat，启动测试

使用tomcat7-maven-plugin插件运行Web项目

在pom.xml下配置信息，添加Tomcat插件

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.tomcat.maven</groupId>
      <artifactId>tomcat7-maven-plugin</artifactId>
      <version>2.2</version>
      <configuration>
        <!--配置tomcat启动的端口号-->
        <port>8080</port>
        <!--配置项目的上下文路径-->
        <path>/mvnweb</path>
      </configuration>
    </plugin>
  </plugins>
</build>

八、Maven生命周期

为了让构建过程自动化完成，Maven设定了三个生命周期，生命周期中的每一个环节对应构建过程中的一个操作。Maven生命周期定义了各个构建环节的执行顺序，有了这个清单，Maven就可以自动化的执行构建命令了。在任何一个生命周期内部，执行任何一个具体环节的操作，都是从本周期最初的位置开始执行，直到指定的地方。

Maven有三套相互独立的生命周期，分别是：

①Clean Lifecycle在进行真正的构建之前进行一些清理工作。

②Default Lifecycle 构建的核心部分，编译，测试，打包，安装，部署等等。

③Site Lifecycle生成项目报告，站点，发布站点。

生命周期名称	作用	各个环节
Clean生命周期	清理操作相关	pre-clean 执行一些需要在clean之前完成的工作 clean 移除所有上一次构建生成的文件 post-clean 执行一些需要在clean之后立刻完成的工作
Default生命周期	主要构建过程	validate 编译前验证 generate-sources process-sources generate-resources process-resources 复制并处理资源文件，至目标目录，准备打包。 compile 编译项目的源代码。 process-classes generate-test-sources process-test-sources generate-test-resources process-test-resources 复制并处理资源文件，至目标测试目录。 test-compile 编译测试源代码。 process-test-classes test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。 prepare-package package 接受编译好的代码，打包成可发布的格式，如JAR。 pre-integration-test integration-test post-integration-test verify 打包后验证 install 将包安装至本地仓库，以让其它项目依赖。 deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享或部署到服务器上运行。
Site生命周期	生成站点相关	pre-site 执行一些需要在生成站点文档之前完成的工作 site 生成项目的站点文档 post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备 deploy-site 将生成的站点文档部署到特定的服务器上

九、插件和目标

Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件(plugin)完成的。
每个生命周期中都包含着一系列的阶段(phase)。这些 phase 就相当于 Maven 提供的统一的接口，然后这些 phase 的实现由 Maven 的插件来完成。
每个插件都能实现多个功能，每个功能就是一个插件目标。
我们在输入 mvn 命令的时候比如 mvn clean，clean 对应的就是 Clean 生命周期中的 clean 阶段。clean 的具体操作就是由 maven-clean-plugin 来实现的。
所以说 Maven 生命周期的每一个阶段的具体实现都是由 Maven 插件实现的。Maven 实际上是一个依赖插件执行的框架，每个任务实际上是由插件完成。

maven-clean-plugin、maven-compile-plugin属于Maven官方插件，命名规则为maven-xxx-plugin。
tomcat7-maven-plugin属于第三方插件，命名规则为xxxx-maven-plugin。
Maven插件列表的官网页面：Maven – Available Plugins
Maven插件的下载位置：本地仓库\org\apache\maven\plugins。

十、依赖及其范围

当A jar包需要用到B jar包中的类时，我们就说A对B有直接依赖。
如果A依赖B，B依赖C，那么A→B和B→C都是直接依赖，而A→C是间接依赖。

依赖范围参数：<scope>provided</scope>，默认都可以用。

依赖范围	编译(main)	测试(test)	运行	示例
compile	√	√	√	log4j
provided	√	√	×	servlet-api lombok(服务端里包含)
test	×	√	×	junit
了解↓
runtime	×	√	√	JDBC驱动类(运行时是接口)
system	√	√	×	需要systemPath显示指定依赖文件路径
import	×	×	×	springBoot XML导入另一个XML

1.依赖传递

两个项目之间有依赖关系，间接依赖的jar包引入时的依赖范围——只有依赖范围为 compile 时可以访问。如果想都使用，请使用继承。

自己创建的项目也是可以相互依赖的。项目b依赖项目a↓，可以使用a中的compile范围的jar包。

项目a :
项目b：

2.依赖冲突

moduleA 中是使用moduleB中的log4j-1.2.14.jar，还是moduleC中的log4j-1.2.17，
1、路径最短者优先原则，使用的是moduleB中的log4j-1.2.14.jar。

2、路径相同时先声明者优先。这里“声明”的先后顺序指的是dependency(依赖)标签配置的先后顺序。

3.依赖的排除

有的时候为了确保程序正确可以将有可能重复的间接依赖排除。排除掉后也可以自行依赖其他版本。依赖排除是针对直接排除的。

<dependency>
    <groupId>com.atguigu.maven</groupId>
    <artifactId>pro04_maven_moduleB</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- 依赖排除 -->
    <exclusions>
        <exclusion>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
        </exclusion>
    </exclusions>
</dependency>

4.统一管理依赖的版本

在升级时，如果想将jar包的版本统一升级为5.2.6，是不是要手动一个个修改？可以进行统一配置的方式：(类似于Thmeleaf ${key})

统一配置
<properties>
    <spring.version>5.2.5.RELEASE</spring.version>
</properties>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>    //版本号修改为，引用？
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>

十一、继承

依赖只有范围为 compile 时才可以访问，而继承父项目，所有的依赖子项目都可以使用。继承关系是一个单向关系，子项目需要指定父项目，父项目不用指定子项目。

使用继承机制就可以将这样的依赖信息统一提取到父工程模块中进行统一管理。

① 定义父项目 <parent>

创建父工程和创建一般的Java工程操作一致，只需要修改或添加<packaging>pom</packaging>。

父项目定义的类和资源，子项目不可以使用。父项目是一个pom项目，是来共享pom.xml中的依赖，编译时，父项目自己定义的类不会参与。所以pom项目的src目录可以删除。

② 定义子项目

子项目中需要手动的指定父项目 <parten>

<!--当前项目，如果groupId、version和父项目相同，可以省略 -->
<artifactId>maven2-child1</artifactId>
<!-- 指定父项目-->
<parent>
    <groupId>com.atguigu.maven</groupId>
    <artifactId>maven2-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>

注意问题：

1、父项目需要打包上传到本地库，否则报错。如果父项目没有打包上传到本地库，则额外需要通过relativePath指定父项目的pom.xml文件的位置(不建议)

<parent>
    <groupId>com.atguigu.maven</groupId>
    <artifactId>pro05_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pro05_parent/pom.xml</relativePath>//指定父类位置，不建议使用
</parent>

2、父项目必须是pom类型，不能是jar、war等其他类型。

3、父项目、子项目需要分别构建。

依赖管理标签 <dependencyManagement>

父项目的所有资源都会被继承，如果只想继承一部分，怎么办？

父项目pom.xml

<!--dependencyManagement :只声明依赖，不拥有依赖，进行依赖管理 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>
</dependencyManagement>

子项目pom.xml

<dependencies>
    <dependency>   
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <!-- 版本可以省略，父项目统一管理 -->
    </dependency>
    <dependency>

十二、聚合

继承的缺点：父项目，子项目需要分别构建。聚合：对父项目继续构建，会自动的对所有的子项目进行相同的构建操作。聚合的目的是能够快速的构建项目，继承的目的是为了减少重复的配置。

聚合首先是一种继承关系。也可以在父项目中通过dependencyManagement来管理依赖。

聚合关系是双向关系，父项目和子项目需要相互指定。

聚合Maven项目间的继承是pom资源间的继承，不是项目功能代码的继承（src可以删除）

1、选择父项目右键，创建maven项目

2、或在创建Maven项目时指定父项目

  父项目pom.xml
 <modelVersion>4.0.0</modelVersion>  
  <groupId>org.example</groupId>  
  <artifactId>day01MavenWeb2</artifactId>  
  <version>1.0-SNAPSHOT</version>
  <!--聚合关系也是继承关系、类型必须为pom-->
  <packaging>pom</packaging>
  <!-- 父项目指明子项目 -->
  <modules>
    <module>son</module>
  </modules>

 子项目pom.xml
    <!-- 子项目 指定父亲是谁-->
    <parent>
        <artifactId>day01MavenWeb2</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>