1.背景
Maven的聚合特性能够把项目的各个模块聚合在一起构建，而Maven的继承特性则能帮助抽取各个模块相同的依赖和插件等配置。在简化POM的同时，还能促进各个模块配置的一致性。
一般来说，一个项目的子模块都应该使用同样的groupId，如果它们一起开发和发布，还应该使用同样的version，此外，它们的atrifactId还应该使用一致的前缀，以方便区分其他项目。
项目主代码：src/main/java
项目资源文件：src/main/resources
测试代码：src/test/java
测试资源文件：src/test/resources
2.聚合
一次构建两个项目，而不是到两个模块的目录下分别执行mvn命令，为了能一条命令就构建两个模块，需要创建一个额外的模块，然后通过该模块构建整个项目的所有模块。
<?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.gqshao.myapp</groupId>
<artifactId>aggregator</artifactId>
<version>1.0.0-SNAPSHOT</version>
<name>Project Aggregator</name>
<packaging>pom</packaging>
<modules>
<module>project-a</module>
<module>project-b</module>
</modules>
</project>
(1)上述POM中groupId、version与其他项目相同，artifactId不同；
(2)packaging：必须采用特殊的pom，而不是不进行声明，采用默认的jar。对于聚合模块来说，其打包方式packaging的值必须为pom，否则无法构建；
(3)modules：是实现聚合的最核心配置，这里每个module的值都是一个当前POM的相对目录，推荐模块所处目录名称应当与其artifactId一致；
(4)为了方便用户构建项目，通常将聚合模块放在项目目录的最顶层，其他模块则作为聚合模块的子目录存在；
(5)可以采用平行的目录结构，此时聚合模块的POM应该修改为<module>../project-a</module>
在执行mvn clean package命令后，Maven会首先解析聚合模块的POM、分析要构建的模块、并计算出一个反应堆构建顺序(Reactor Build Order)，然后根据这个顺序依次构建各个模块。反应堆是所有模块组成的一个构建结构。
反应堆构建顺序描述输出的是各模块的名称，而不是artifactId，所以在POM配置合理的name字段，其目的是让Maven的构建输出更清晰。
3.继承
背景：多个模块的pom.xml中有很多相同的配置，例如它们有相同的groupId和version，有相同的spring-core、spring-beans，还有相同的maven-compiler-plugin等配置。
在aggregator下创建parent子目录，然后在该目录下建立一个所有除aggregator之外模块的父模块。为此在parent目录下创建pom.xml，内容如下：
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion> <groupId>com.gqshao.myapp</groupId> <artifactId>parent</artifactId> <version>1.0-SNAPSHOT</version> <name>parent</name> <packaging>pom</packaging> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> </project>
该POM十分简单，使用了与其他模块一直的groupId和version，使用artifactId为parent表示这是一个父模块，作为父模块，其打包类型也必须为pom
由于父模块只是为了帮助消除配置的重复，因此它本身不包含除POM之外的项目文件，也就不需要src/main/java之类的文件夹了。
让其它模块继承它,project-a和project-b的POM修改类似于下面这种形式
<?xml version="1.0"?> <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.gqshao.myapp</groupId> <artifactId>parent</artifactId> <version>1.0-SNAPSHOT</version> <relativePath>../parent或../parent/pom.xml</relativePath> </parent> <artifactId>project-a或project-b</artifactId> <name>project-a</name> <dependencies> ... </dependencies> <build> <plugins> ... </plugins> </build> </project>
上述POM中使用parent元素声明父模块，parent下的子元素gourpId、artifactId和version指定了父模块的坐标，这三个元素是必须的。元素relativePath为../parent/（可以不写pom.xml，默认值../pom.xml），也就是说Maven默认父POM在上一层目录下。
最后，同样还需要把parent加入到聚合模块aggregator中
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion> <groupId>com.gqshao.myapp</groupId> <artifactId>aggregator</artifactId> <version>1.0-SNAPSHOT</version> <name>aggregator</name> <url>http://maven.apache.org</url> <packaging>pom</packaging> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <modules> <module>parent</module> <module>project-a</module> <module>project-b</module> </modules> </project>
(2)可继承的元素
(1)groupId：项目组ID，项目坐标的核心元素；
(2)version：项目版本，项目坐标的核心元素；
(3)description：项目的描述信息；
(4)organization：项目的组织信息；
(5)inceptionYear：项目的创伤年份；
(6)url：项目的URL地址；
(7)developers：项目的开发者信息；
(8)contributors：项目的贡献值信息；
(9)distributionManagement：项目的部署配置；
(10)issueManagement：项目的缺陷跟踪系统信息；
(11)ciManagement：项目的持续集成系统信息；
(12)scm：项目的版本控制系统信息；
(13)mailingLists：项目的邮件列表信息；
(14)properties：自定义的属性，重要；
(15)dependency：项目的依赖配置，重要；
(16)dependencyManagement：项目的依赖管理配置，重要；
(17)repositories：项目的仓库配置；
(18)build：包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等，重要；
(19)reporting：包括项目的报告输出目录配置、报告插件配置等。
(3)依赖管理
Maven提供的dependencyManagement元素既能让子模块继承到父模块的依赖配置，又能保证子模块依赖使用的灵活性。在dependencyManagement元素下的依赖声明不会引入实际的依赖，不过它能够约束dependencies下的依赖使用。
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>com.gqshao.myapp</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<name>parent</name>
<packaging>pom</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<springframework.version>2.5.6</springframework.version>
<junit.version>4.7</junit.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<configuration>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
首先该父POM，将springframework和junit依赖的版本以Maven变量的形式提取了出来，消除重复，并使各依赖的版本处于更加明显的位置。
这里使用的dependencyManagement既不会给parent引入依赖，也不会给它的子模块引入依赖，不过这段配置是会被继承的，现在修改project的POM如下：
<?xml version="1.0"?>
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.gqshao.myapp</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../parent/pom.xml</relativePath>
</parent>
<artifactId>project-a</artifactId>
<name>project-a</name>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<javax.mail.version>1.4.1</javax.mail.version>
<greenmail.version>1.3.1b</greenmail.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
<dependency>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
<version>${javax.mail.version}</version>
</dependency>
<dependency>
<groupId>com.icegreen</groupId>
<artifactId>greenmail</artifactId>
<version>${greenmail.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
</build>
</project>
上述的POM所有springframework依赖只配置了groupId和artifactId，省去了version，而junit依赖不仅省去了version，还省去了依赖范围scope。这是由于完整的依赖声明已经包含在父POM中，子模块只需要配置简单的groupId和artifactId就能获得对应的依赖，从而引入正确的依赖。这种方式是强烈推荐采用的。
如果子模块不声明依赖的使用，即使该依赖已经在父POM的dependencyManagement中声明了，也不会产生任何实际的效果。
依赖范围import：导入依赖范围，该依赖范围不会对三种classpath产生时间影响，该依赖范围只有在dependencyManagement元素下才 有效果，使用该范围的依赖通常指向一个POM，作用是将该POM目标中的dependencyManagement合并到当前POM的 dependencyManagement中。即在另一个模块中使用与另一个项目完全一样的dependencyManagement，除了复制配置或者 继承这两种方式外，还可以考虑import范围依赖将这一配置导入。
<dependencyManagement> <dependencies> <dependency> <groupId>com.gqshao.myapp</groupId> <artifactId>myapp-parent</artifactId> <version>1.0-SNAPSHOT</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
注意：上述代码中依赖的type值为pom，import依赖范围由于其特殊性，一般都是指向打包类型为pom的模块。如果有多个项目，它们使用的依赖版本都是一致的，就可以定义一个使用dependencyManagement专门管理依赖的POM，然后在各个项目模块中导入这些依赖。
(4)插件管理
Maven提供了类似dependencyManagement元素帮助管理依赖的pluginManagement元素帮助管理插件。当POM中配置了真正的plugin元素，并且groupId和artifactId与pluginManagement中配置的插件匹配时，pluginManagement的配置才会影响实际的插件行为。
例如：parent中配置maven-source-plugin，将其jar-no-fork目标绑定到verity生命周期阶段，已生成源代码。
<build> <pluginManagement> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-source-plugin</artifactId> <version>2.1.1</version> <executions> <execution> <id>attach-sources</id> <phase>verify</phase> <goals> <goal>jar-no-fork</goal> </goals> <inherited>false</inherited> <configuration> </configuration> </execution> </executions> </plugin> </plugins> </pluginManagement> </build>
子项目中应该如下配置：
<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-source-plugin</artifactId> </plugin> </plugins> </build>
另一个例子：子项目中都使用了maven-compiler-plugin开启Java6编译支持和maven-resources-plugin使用UTF-8编码处理资源文件，可以采用如下配置：
<build> <pluginManagement> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.6</source> <target>1.6</target> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-resources-plugin</artifactId> <configuration> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </pluginManagement> </build>
子项目可以完全移除关于maven-compiler-plugin和maven-resources-plugin的配置，而直接使用这两个插件。插件的行为，在parent的POM进行了统一配置。
4.聚合与继承的关系
聚合主要是为了方便快速构建项目，继承主要是为了消除重复配置。
对于聚合模块来说，它知道有哪些被聚合的模块，但那些被聚合的模块不知道这个聚合模块的存在。
对于继承关系的父POM来说，它不知道有哪些子模块继承于它，但那些子模块都必须知道自己的父POM。
两个特征的共同点是聚合POM和继承关系父POM中的packaging都必须是pom，同时聚合模块与继承关系中的父模块除了POM之外都没有实际的内容。
在一些实际项目中，为了方便，一个POM可以即是聚合POM，又是父POM。也就是说可以合并aggregator和parent项目，合并后的POM如下：
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>com.gqshao.myapp</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<name>parent</name>
<packaging>pom</packaging>
<modules>
<module>parent</module>
<module>project-a</module>
<module>project-b</module>
</modules>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<springframework.version>2.5.6</springframework.version>
<junit.version>4.7</junit.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<configuration>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>2.1.1</version>
<executions>
<execution>
<id>attach-sources</id>
<phase>verify</phase>
<goals>
<goal>jar-no-fork</goal>
</goals>
<inherited>false</inherited>
<configuration>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
该POM打包方式为pom，包含modules元素，用来聚合项目，还包含了properties、dependencyManagement和pluginManagement元素供子元素继承。
相应的，被聚合的项目和子项目的POM配置也要做微小的修改，本来parent和他们位于同级目录，因此要配置relativePath的值为../parent。但现在parent在上一层目录，这是Maven默认能识别的父模块位置，因此不需要在配置relativePath，POM修改如下：
<parent> <groupId>com.gqshao.myapp</groupId> <artifactId>Parent</artifactId> <version>1.0.0-SNAPSHOT</version> </parent> <artifactId>project-a</artifactId> <name>The Aroject A</name>
5.约定优于配置
Maven假设用户的项目是
源码目录为：src/main/java/
编译输出目录为：target/classes/
打包方式为：jar
包输出目录为：target/
Maven允许自定义源码目录
<build>
<sourceDirectory>src/java</sourceDirectory>
</build>
该项目中源码目录就成了src/java，而不是默认的src/main/java
超级POM$M2_HOME/lib/maven-model-builder-x.x.x.jar中的org/apache/maven/model/pom-4.0.0.xml下
(1)首先超级POM通过<repositories>和<pluginRepositories>定义了仓库和插件仓库，并且都关闭了SNAPSHOT支持。
<repositories>
<repository>
<id>central</id>
<name>Central Repository</name>
<url>http://repo.maven.apache.org/maven2</url>
<layout>default</layout>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>central</id>
<name>Central Repository</name>
<url>http://repo.maven.apache.org/maven2</url>
<layout>default</layout>
<snapshots>
<enabled>false</enabled>
</snapshots>
<releases>
<updatePolicy>never</updatePolicy>
</releases>
</pluginRepository>
</pluginRepositories>
(2)超级POM依次定义了主输出目录、主代码输出目录、最终构件的名称形式、测试代码输出目录、主源码目录、脚本源码目录、测试源码目录、主资源目录和测试资源目录。
<build>
<directory>${project.basedir}/target</directory>
<outputDirectory>${project.build.directory}/classes</outputDirectory>
<finalName>${project.artifactId}-${project.version}</finalName>
<testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
<sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
<scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>
<testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
<resources>
<resource>
<directory>${project.basedir}/src/main/resources</directory>
</resource>
</resources>
<testResources>
<testResource>
<directory>${project.basedir}/src/test/resources</directory>
</testResource>
</testResources>
</build>
(3)超级POM为核心插件设定版本
<build>
<pluginManagement>
<!-- NOTE: These plugins will be removed from future versions of the super POM -->
<!-- They are kept for the moment as they are very unlikely to conflict with lifecycle mappings (MNG-4453) -->
<plugins>
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.3</version>
</plugin>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.2-beta-5</version>
</plugin>
<plugin>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.1</version>
</plugin>
<plugin>
<artifactId>maven-release-plugin</artifactId>
<version>2.0</version>
</plugin>
</plugins>
</pluginManagement>
</build>
6.反应堆
在一个多模块的Maven项目中，反应堆(Reactor)是指所有模块组成的一个构建结构，对于单模块的项目，反应堆就是该模块本身，但对于多模块项目来说，反应堆就包含了各模块之间继承与依赖的关系，从而能够自动计算出合理的模块构建顺序。
(1)反应堆顺序
反应堆顺序为Maven自动进行计算，通过构建输出信息，可以知道反应堆顺序。
(2)剪裁反应堆
一般来说，用户会选择构建整个项目或者构建单独的模块。通过输入mvn -h可以了解剪裁反应堆的命令
1)-am,--also-make：同时构建所列模块的依赖模块；
2)-amd,--also-make-dependents：同时构建依赖于所列模块的模块；
3)-pl,--projects <arg>：构建指定的模块，模块间用逗号分隔；
4)-rf,--resume-from <arg>：从指定的模块回复反应堆。
例子：
默认情况下执行 mvn clean install会得到完整的反应堆，此时可以选择-pl选项指定构建几个模块
mvn clean package -pl project-a,project-b [INFO] Reactor Summary: [INFO] [INFO] project-a ......................................... SUCCESS [1.529s] [INFO] project-b ......................................... SUCCESS [0.780s
使用-am选项可以同时构建所列模块的依赖模块
mvn clean package -pl project-a -am [INFO] Reactor Summary: [INFO] [INFO] parent ............................................ SUCCESS [0.328s] [INFO] project-a ......................................... SUCCESS [1.388s]
使用-amd选项可以同时构建依赖于所列模块的模块
mvn clean package -pl parent -amd [INFO] Reactor Summary: [INFO] [INFO] parent ............................................ SUCCESS [0.156s] [INFO] project-a ......................................... SUCCESS [1.279s] [INFO] project-b ......................................... SUCCESS [0.640s]
使用-rf选项可以在完整的反应堆构建顺序基础上指定从哪个模块开始构建
mvn clean package -rf project-b [INFO] Reactor Summary: [INFO] [INFO] project-b ......................................... SUCCESS [1.263s] [INFO] aggregator ........................................ SUCCESS [0.000s]
在-pl -am或者-pl -amd的基础上，还能应用-rf参数，以对剪裁后的反应堆再次剪裁
mvn clean package -pl parent -amd -rf project-a [INFO] Reactor Summary: [INFO] [INFO] project-a ......................................... SUCCESS [1.358s] [INFO] project-b ......................................... SUCCESS [0.639s]
相关推荐
本示例将深入探讨"Maven聚合与继承"的概念。 **一、Maven聚合（Aggregation）** Maven聚合允许我们将多个独立的Maven项目组织在一起，形成一个单一的构建单元。在我们的示例中，`parent`项目就是一个聚合项目。它...
本篇文章将深入探讨Maven的两个重要特性：继承（Inheritance）和聚合（Aggregation），并结合提供的资源《一头扎进Maven3》第五讲源码及文档进行详细解释。 **一、Maven继承** Maven的继承机制允许我们在多个项目...
本文将深入探讨Maven的聚合与继承特性，并通过实例进行详细解释。 首先，Maven的依赖管理系统允许开发者声明项目所需的库和它们的版本，从而避免了版本冲突和手动管理jar包的问题。在Maven的POM（Project Object ...
本系列课程从maven基础到高级，老师手把手...3.聚合和继承 3.1.聚合 3.2.继承 4.maven高级特性 4.1.属性配置 4.2.版本管理 4.3.资源管理 5.私服 5.1.nexus安装 5.2.仓库的分类 5.3.创建仓库 5.4.配置仓库 5.5.使用仓库
Maven，作为Java开发中的构建工具，提供了强大的聚合（Aggregation）和继承（Inheritance）特性，使得多模块项目的管理变得高效且有序。本文将深入探讨如何利用这两个特性来创建一个复杂的多模块项目，并通过提供的...
本示例将深入探讨Maven中的“依赖”、“继承”和“聚合”这三个核心概念，帮助开发者更好地理解和应用Maven。 首先，我们来讨论"Maven依赖"。在Java开发中，一个项目往往需要引用其他库或者框架来完成特定功能。...
在Maven中，"聚合"和"继承"是两个重要的特性，它们有助于管理和组织大型的多模块项目。 **一、Maven聚合** Maven聚合（Aggregation）是用来管理多个相关项目的方式，这些项目可能共享一部分代码或者有共同的构建...
在本文中，我们将深入探讨 Maven 的聚合与继承特性，并结合前后端分离的实践，来创建一个高效的开发环境。Maven 是 Java 开发中广泛使用的构建工具，它通过配置管理依赖关系，简化项目的构建、测试和部署过程。让...
在UML中，有六种主要的类间关系：继承、实现、依赖、关联、聚合和组合。理解这些关系对于设计高质量的软件架构至关重要。 1. **继承**： 继承是类与类之间的一种层次结构关系，表示一个类（子类）可以从另一个类...
引入WEB-INF/classes和views等本模块的文件夹：<packagingIncludes>WEB-INF/classes/**,WEB-INF/vi
在"Maven 依赖，聚合，继承，插件运行应用"这个主题中，我们将深入探讨这四个核心概念。 1. **依赖管理**：Maven依赖是项目中各个模块之间共享代码的关键机制。当你在POM.xml文件中声明一个依赖，Maven会自动下载并...
在 UML 中，继承、实现、依赖、关联、聚合、组合这六种关系都是语义级别的，所以从代码层面并不能完全区分各种关系；但是后几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖。 在 UML 中，还有泛化关系、关联...
### UML学习之依赖、关联、聚合、组合与继承 #### 一、泛化(Generalization) **概念：** 泛化表示的是类与类之间的继承关系、接口与接口之间的继承关系，或者是类对接口的实现关系。在UML中，泛化关系通常用一个带...
**二、聚合与继承** 聚合和继承是Maven中两个重要的概念。在本项目中，聚合关注的是项目间的组织关系，而继承则关注的是共享配置。 1. **聚合**：在`<modules>`标签下，聚合POM列出所有子项目的相对路径，使得...
本文将深入探讨UML中的五个关键关系：继承、实现、依赖、关联和聚合，以及它们在软件设计中的作用。 1. **继承（Inheritance）**： 继承是面向对象编程的核心概念之一，它允许一个类（子类或派生类）从另一个类...
标题中的“遭遇继承与聚合”指的是Decorator模式在处理继承和组合关系时可能遇到的问题。继承是一种“is-a”关系，而组合则是一种“has-a”关系。在Decorator模式中，子类（Decorator）继承父类（Component），同时...
"UML继承聚合泛化依赖的实用解释" UML（Unified Modeling Language），即统一建模语言，是一种标准化的建模语言，用于描述软件系统的结构和行为。UML继承、聚合、泛化和依赖是UML中的四种基本关系，分别用来描述类...
要实现自定义样式，我们首先需要创建一个继承自`MarkerClusterer`的子类，重写其中的关键方法。例如，我们可以覆盖`getClusterIcon`方法来设定聚合标记的图标，该方法返回一个`BMap.Icon`对象，用于定义图标的位置、...
2. **部分整体原则**：如果类`B`需要使用类`A`的部分功能，但类`B`并不是类`A`的一种特殊形式，此时不应当使用继承，而应当使用组合或聚合。例如，“心脏是人的一部分”，这时应当通过组合的方式来实现功能而非继承...