[这可能是最好的Spring教程！]Maven的模块管理——怎样拆分大项目而且用par ...

题目的提出

在软件开发中，我们为了减少软件的复杂度，是不会把所有的功能都塞进一个模块之中的，塞在一个模块之中对于软件的管理无疑是极其困难且复杂的。所以把一个项目拆分为模块无疑是一个好方法

1.                         ┌ ─ ─ ─ ─ ─ ─ ┐
2.                           ┌─────────┐
3.                         │ │Module A │ │
4.                           └─────────┘
5. ┌──────────────┐ split  │ ┌─────────┐ │
6. │Single Project│───────▶  │Module B │
7. └──────────────┘        │ └─────────┘ │
8.                           ┌─────────┐
9.                         │ │Module C │ │
10.                           └─────────┘
11.                         └ ─ ─ ─ ─ ─ ─ ┘

复制代码

对于Maven工程来说，原来是一个大项目：

1. single-project
2. ├── pom.xml
3. └── src

复制代码

现在可以分拆成3个模块：

1. multiple-projects
2. ├── module-a
3. │   ├── pom.xml
4. │   └── src
5. ├── module-b
6. │   ├── pom.xml
7. │   └── src
8. └── module-c
9.     ├── pom.xml
10.     └── src

复制代码

我们能看到的是每一个模块都有属于自己的pom.xml，然后模块A的pom.xml是这样的：

1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
6.     <groupId>com.itranswarp.learnjava</groupId>
7.     <artifactId>module-a</artifactId>
8.     <version>1.0</version>
9.     <packaging>jar</packaging>
11.     <name>module-a</name>
13.     <properties>
14.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
16.         <maven.compiler.source>11</maven.compiler.source>
17.         <maven.compiler.target>11</maven.compiler.target>
18.         <java.version>11</java.version>
19.     </properties>
21.     <dependencies>
22.         <dependency>
23.             <groupId>org.slf4j</groupId>
24.             <artifactId>slf4j-api</artifactId>
25.             <version>1.7.28</version>
26.         </dependency>
27.         <dependency>
28.             <groupId>ch.qos.logback</groupId>
29.             <artifactId>logback-classic</artifactId>
30.             <version>1.2.3</version>
31.             <scope>runtime</scope>
32.         </dependency>
33.         <dependency>
34.             <groupId>org.junit.jupiter</groupId>
35.             <artifactId>junit-jupiter-engine</artifactId>
36.             <version>5.5.2</version>
37.             <scope>test</scope>
38.         </dependency>
39.     </dependencies>
40. </project>

复制代码

之后B的pom.xml也大同小异，只用把module-a  和  module-a  改为自己的就行。这个时间我们就会发现一个很麻烦的事，我们很多地方都是一样的，但是每一个模块的pom都需要我们重复声明出来，那我们能不能用像对象那样继承下来，这样就不消重复声明白呢？Maven无疑是有这样的功能的
题目的解决

简化后的结构

我们现在看看简化后的模块结构式怎样的

1. multiple-project
2. ├── pom.xml
3. ├── parent
4. │   └── pom.xml
5. ├── module-a
6. │   ├── pom.xml
7. │   └── src
8. ├── module-b
9. │   ├── pom.xml
10. │   └── src
11. └── module-c
12.     ├── pom.xml
13.     └── src

复制代码

与之对比的是根目次多了一个pom，然后多加了一个"模块"parent，里面没有代码src，只有一个裸的pom。
看了对比之后我们一个一个讲是怎么修改的，结构又是怎么样的
修改细则

parent

我们先来看parent里面的pom是怎么个事

1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
6.     <groupId>com.itranswarp.learnjava</groupId>
7.     <artifactId>parent</artifactId>
8.     <version>1.0</version>
9.     <packaging>pom</packaging>
11.     <name>parent</name>
13.     <properties>
14.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
16.         <maven.compiler.source>11</maven.compiler.source>
17.         <maven.compiler.target>11</maven.compiler.target>
18.         <java.version>11</java.version>
19.     </properties>
21.     <dependencies>
22.         <dependency>
23.             <groupId>org.slf4j</groupId>
24.             <artifactId>slf4j-api</artifactId>
25.             <version>1.7.28</version>
26.         </dependency>
27.         <dependency>
28.             <groupId>ch.qos.logback</groupId>
29.             <artifactId>logback-classic</artifactId>
30.             <version>1.2.3</version>
31.             <scope>runtime</scope>
32.         </dependency>
33.         <dependency>
34.             <groupId>org.junit.jupiter</groupId>
35.             <artifactId>junit-jupiter-engine</artifactId>
36.             <version>5.5.2</version>
37.             <scope>test</scope>
38.         </dependency>
39.     </dependencies>
40. </project>

复制代码

我们能发现的是，对于之前的模块A修改实在也不多，修改的分别是parent  pom parent
这里我们偏重讲一下pom，首先我们先明白这个标签代表了什么，
这个标签他表示打包的方式，常见的值为jar（Java库）、war（Web应用）、pom（父项目）等。这个地方parent的packaging设置为pom，因为它不生成任何可执行的JAR文件，仅提供设置和依赖管理。
其他模块的简化思路

看完了parent的代码之后我们就慢慢地去理清简化的思路
编码与java版本设置

首当其冲的无疑就是这个部分，这个地方模块AB都是需要的，而且都是一样的，那么这个元素就是可以被继承的，也就是是可以省略的

1. <properties>
2.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
3.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
4.         <maven.compiler.source>11</maven.compiler.source>
5.         <maven.compiler.target>11</maven.compiler.target>
6.         <java.version>11</java.version>
7.     </properties>

复制代码

公共依赖项

其次就是AB都需要的依赖项如slf4j-api、logback-classic和junit-jupiter-engine，以及作用域的设置

1. <dependencies>
2.         <dependency>
3.             <groupId>org.slf4j</groupId>
4.             <artifactId>slf4j-api</artifactId>
5.             <version>1.7.28</version>
6.         </dependency>
7.         <dependency>
8.             <groupId>ch.qos.logback</groupId>
9.             <artifactId>logback-classic</artifactId>
10.             <version>1.2.3</version>
11.             <scope>runtime</scope>
12.         </dependency>
13.         <dependency>
14.             <groupId>org.junit.jupiter</groupId>
15.             <artifactId>junit-jupiter-engine</artifactId>
16.             <version>5.5.2</version>
17.             <scope>test</scope>
18.         </dependency>
19.     </dependencies>

复制代码

修改后的模块A的pom

我们再开看看修改后模块A的pom是怎么样的

1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
6.     <parent>
7.         <groupId>com.itranswarp.learnjava</groupId>
8.         <artifactId>parent</artifactId>
9.         <version>1.0</version>
10.         <relativePath>../parent/pom.xml</relativePath>
11.     </parent>
13.     <artifactId>module-a</artifactId>
14.     <packaging>jar</packaging>
15.     <name>module-a</name>
16. </project>

复制代码

不得不说有了parent之后，整个模块都变得简便了起来
在设置好parent模块后，我们只需要引用parent作为其他模块的父模块。
首先通过​ ​​​标签引用​​parent​​模块

1.     <parent>
2.         <groupId>com.itranswarp.learnjava</groupId>
3.         <artifactId>parent</artifactId>
4.         <version>1.0</version>
5.         <relativePath>../parent/pom.xml</relativePath>
6.     </parent>

复制代码

有了这些之后就相当于继承了parent里面的元素了。
之后我们再导入自己独有的元素就基本上完成了对此模块的设置

1. <artifactId>module-a</artifactId>
2. <packaging>jar</packaging>
3. <name>module-a</name>

复制代码

继承parent模块后，模块A和模块B的pom.xml文件已经大幅简化。所有公共设置项，如UTF-8编码、Java编译版本、以及日志和测试的依赖库，均已在parent中设置好。这样，模块A和模块B仅需保留独有的内容，简化了设置并降低了维护成本。
相互的引用

假如模块A需要引用模块B的代码，可以在模块A的中增长对模块B的依赖项，如下：

1. <dependencies>
2.     <dependency>
3.         <groupId>com.itranswarp.learnjava</groupId>
4.         <artifactId>module-b</artifactId>
5.         <version>1.0</version>
6.     </dependency>
7. </dependencies>

复制代码

通过这一设置，Maven会在构建模块A时自动获取模块B生成的JAR文件，使得模块A可以使用模块B中的代码和功能。
根目次pom的设置

末了的末了，我们设置末了根目次pom的思路就是为了完成所有项目的统一编译：

1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
5.     <modelVersion>4.0.0</modelVersion>
6.     <groupId>com.itranswarp.learnjava</groupId>
7.     <artifactId>build</artifactId>
8.     <version>1.0</version>
9.     <packaging>pom</packaging>
10.     <name>build</name>
12.     <modules>
13.         <module>parent</module>
14.         <module>module-a</module>
15.         <module>module-b</module>
16.         <module>module-c</module>
17.     </modules>
18. </project>

复制代码

这样，在根目次执行mvn clean package时，Maven根据根目次的pom.xml找到包括parent在内的共4个，一次性全部编译。
这可能是最好的Spring教程！

感谢您看到这里  这可能是最好的Spring教程系列  更多的文章可以到这查看这可能是最好的Spring教程！即便无基础也能看懂的入门Spring，仍在连续更新。，我还在荔枝更新出最详细的Spring教程

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。