一篇解决springBoot+Maven多模块项目_springboot单模块项目改造成多模块项目的优势是什么

首先：使用maven多模块项目的好处？

1、代码复用

比如一个项目的前台服务和后台管理系统，想让他们单独运行，如果划分成两个单独的项目的话，实体类、service、dao等就会产生重复，以前的做法是直接复制过去，但实体类要是改动某些属性的话，两个系统都要改。但如果我们 把公共的部分单独提取成一个模块，让前后台系统在pom文件中去引用这个公共的模块 ，就可以避免这个问题。

3、减少build的时间

如果项目很大，改动一点就要build整个项目，等待时间就会很长。现在改动那个模块就只build那个模块，减少等待时间。就算用了热加载工具如springBoot的devtools或者神器JRebel，那还是项目越小越快不是。

多个模块光看着就比单个模块显得高大上，对吧。无形装逼，最为致命。

ok，下面介绍springBoot+ Maven多模块项目 在idea中的创建、打包、运行过程，其核心是Maven的三个特性： 依赖、继承和聚合 。只要理解了Maven的这三个特性，其他类型的多模块项目都是一个道理。
来，先看一下项目结构

parent： pom 项目，用来聚合其他子模块和进行总的依赖版本管理。不用单独运行，所以他没有启动类。
common：提取出来的一个公共模块，主要用于被其他模块依赖。不用单独运行。所以他也没有启动类。
module_a：可单独运行的模块。
module_b：可单独运行的模块。
当时想的是，module_a是前台服务，module_b是后台管理系统，我要单独运行，不能因为module_a挂了导致module_b启动不起来。
下面正式开始。。。

一、先把项目和多个模块建立起来

1、先建立一个pom类型父工程

我这里是用的spring Initialzr创建的，也可以建立一个普通的maven项目，主要是pom.xml文件中的*<packaging>pom<packaging>*打包方式要是pom的方式。

建立父工程的好处就是 1、方便聚合其他子模块，实现一键操作所有子模块。2、聚合后能自动识别子模块间的依赖关系。
举个例子：模块A依赖模块B，对模块A进行打包前要先install模块B，否则就会提示无法处理模块B这个依赖，若是依赖有多个就要先把依赖一个个install，就很烦。用父工程聚合子模块后，就能自动帮你处理这个问题，就很好。若此时模块A还继承自某个父工程，也要先把父工程install后才能对模块A进行打包，否则也会报错。

2、在父工程上右键new Module依次将其他子模块建立出来

这个地方的Content root决定了子模块和父模块是同一级显示和还是上下级的显示

二、添加依赖关系

先看父工程的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/>
    </parent>
    <!--父工程聚合子模块，
       1、能对聚合的模块统一进行操作
       2、能自动识别子模块间的依赖关系(即该先install那个)-->
    <modules>
        <module>module_a</module>
        <module>module_b</module>
        <module>common</module>
    </modules>
    <groupId>com.jyf.mavenmulti</groupId>
    <artifactId>parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>parent</name>
    <!--父工程的类型为pom工程-->
    <packaging>pom</packaging>
    <description>maven多模块父工程-用来聚合多个子模块和统一管理依赖版本</description>
    <properties>
        <java.version>1.8</java.version>
        <junit.version>4.12</junit.version>
    </properties>
    <!--父工程被继承后用<dependencyManagement>对所有的依赖版本号进行统一管理-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!--<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>-->
</project>
说明：由于我是用spring initializer 创建的pom父工程，父工程的pom文件的节点用的是spring-boot-starter-parent，说明他向上继承了spring-boot-starter-parent，而这个依赖追溯到源头发现是spring-boot-dependencies，这个相当于是一个依赖库，定义了当前springBoot版本能用到的所有依赖以及适配的版本号。
 当然也可以不继承spring-boot-starter-parent，而是利用<dependencyManagement>，在父工程的pom文件中单独定义当前maven多模块项目可能用到的各种依赖，以便子工程使用。比如下面这样： 
<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.2.RELEASE</version>
                <!--<type>pom</type>配合<scope>import</scope>标签可以额外引入其他的pom文件中的<dependencyManagement>内容，解决了maven单继承的问题。-->
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.1.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
    </dependencyManagement>
然后是common模块的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--继承父工程-->
    <parent>
        <groupId>com.jyf.mavenmulti</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!--父工程pom.xml文件相对位置-->
        <relativePath>../pom.xml</relativePath>
    </parent>
    <artifactId>common</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>common</name>
    <packaging>jar</packaging>
    <description>公共的被其他模块依赖的模块</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    common模块中不能加入build标签中的maven插件，因为这里它的作用只是将公共的部分分离出来，被其他模块引用，
    若加入了那个maven插件，就会导致别的模块引入该common模块失败，提示找不到程序包。
</project>
然后是module_a的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--继承父工程-->
    <parent>
        <groupId>com.jyf.mavenmulti</groupId>
        <artifactId>parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!--父工程pom.xml文件相对位置-->
        <relativePath>../pom.xml</relativePath>
    </parent>
    <artifactId>module_a</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>module_a</name>
    <packaging>jar</packaging>
    <description>子模块A，可以单独运行</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--在a模块中引入common模块，能自动识别该common模块,我不清楚这地方为啥能自动识别，此时他也没在本地仓库里啊-->
        <dependency>
            <groupId>com.jyf.mavenmulti</groupId>
            <artifactId>common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <!--注意：这个地方的junit是没有版本号的，
        maven会自动的向上找,找到<dependencyManagerment>标签并使用它里面声明的依赖的版本号-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
module_b的pom.xml内容和module_a差不多就不贴了。
 ok，到此这个maven多模块项目算是简单的搭建好了。 
<dependencyManagerment> 标签的作用
 
．　首先,该标签里面的依赖不会被子模块直接继承。若是不加这个标签，则父pom里面的 所有依赖 都会被子模块直接继承过去，若子模块不需要使用全部的依赖，你却强制给子模块，子模块打包时会因为多余的jar包显得很臃肿。
 一般做法是：
 　　在父pom的<dependencyManagerment>标签里面声明所有的依赖及其版本号，可以用<properties>标签进一步对版本号进行集中管理。子模块若想使用父pom中声明的依赖，需要在自己的模块中声明一下，但不用写版本号（当子模块继承了父pom后，会默认向上找父pom中<dependencyManagerment>标签中依赖声明的版本号；若子模块中写了版本号，就优先使用自己的版本号）。这样子模块用什么依赖就取什么依赖即可，父pom也可以对所有的依赖进行统一的管理。 
三、测试一下
 
common模块中建一个Test类 
@Data
public class Test {
    private int id;
    private String name;
module_a的controller中向页面返回Test类的一个对象 
@Controller
@RequestMapping("/controllerA")
public class ControllerA {
    @ResponseBody
    @RequestMapping("/test")
    public Test test(){
        Test test = new Test();
        test.setId(1);
        test.setName("tom");
        return test;
运行模块A
  

 
 ok,打包成功！
 因为聚合的存在，我们可以在父工程中实现一键打包所有的子模块，并能自动处理依赖关系
 因为模块A和模块B是两个单独运行的模块，所以想运行哪个就单独拿出来运行就行了。 
遇到的问题：
 
1、在自动打包common模块时报错，说找不到主类(main class)?
 
原因：我在父工程的pom.xml中使用了spring-boot-maven-plugin这个maven插件（它的作用请看下一题），common模块继承了父工程，所有他也有了这个插件，这个插件找不到主类（springBoot的启动类，让我给删了，因为他也不需要单独运行）就报错了。
解决：把父工程pom.xml中的这个插件删掉就行了。父工程又不需要打包，这样common模块就继承不过去了，就没事了。其他两个子模块想使用就单独在自己的pom.xml中引入即可。
2、 这个插件的作用？
 
spring-boot-maven-plugin这个插件是专门为springBoot项目服务的，
 作用是打包时，对mvn package打包后的结果进行二次打包，目的是将当前项目所有的依赖也打包进来(会自动的找到启动类作为main class)，官方解释此时的jar包叫fat.jar
 若不加这个插件，就只打包当前项目中的东西，依赖不会被打包进来。
 注意，
 　spring-boot-maven-plugin打成的jar包可以运行，但是不能被其他工程依赖。 ，所以被其他模块依赖的模块如common模块，不能加这个，否则会提示找不到程序包。 
看完了吧，看完了赶紧试试吧，光看没用，自己动手去实现一下才是硬道理。 
好的到此本篇文章算是结束了，觉得不错的点个赞在走呗。
1.1 基本概况
真实maven的项目都应该是分模块的，每个模块都对应着一个pom.xml。它们之间通过继承和聚合（也称作多模块，multi-module）相互关联。
常见的web项目结构：
Dao层负责数据库交互，封装了Hibernate交互的类。
	Service层处理业务逻辑，放一些Service接口和实现相关的Bean。
	Web层负责与客户端交互，主要有一些Structs的Action类。
	对应的项目结构：
	org.myorg.app.dao
	org.myorg.app.
                                    archetype 是一个 Maven 项目模板工具包，通过 archetype 我们可以快速搭建 Maven 项目。每个模板里其实就是附带不同的依赖和插件。一般在公司私服里都会有属于本公司的一套 archetype 模板，里面有着调试好的项目用到的依赖包和版本号。
                                    使用多模块的原因
使用Java技术开发的工程项目，无论是数据处理系统还是Web网站，随着项目的不断发展，需求的不断细化与添加，工程项目中的代码越来越多，包结构也越来越复杂这时候工程的进展就会遇到各种问题：
1）不同方面的代码之间相互耦合，这时候一系统出现问题很难定位到问题的出现原因，即使定位到问题也很难修正问题，可能在修正问题的时候引入更多的问题。
2）多方面的代码集中在一个整体结构中，新入的开发者很难对整体项目有直观的感受，增加了新手介入开发的成本，需要有一个熟悉整个项目的开发者维护整个项目的结构（通常在
在下一个页面中，输入我们的公司名称或者域名的倒写加项目名，然后next
在下一个页面上直接finish就可以了
这个时候我们的顶级工程就创建完成了，由于是顶级工程，我们需要在其pom文件里面添加这么一段标识
接着就是构建在顶级工程一下的子模块了
然后，直接next到了这个窗口
                                    1、打开idea创建一个maven工程，这个是parent工程，package打包方式修改为pom，将src等没有用的文件全部删除，删除后目录如下
2、创建一个子工程，点【File】-【Project Structure】
点【Modules】-【+】-【New Module】，创建子工程report-data-producer
创建完后，继续按上面的步骤创建子工程report-data-h...
                                    1.控制反转将对象的创建交给了spring,简化了开发，降低了代码之间的耦合性和侵入性。
2.方便对程序进行声明式事物管理，我们只需通过配置就可以完成对事物管理。
3.方便集成各种优秀的框架，spring不排斥各种优秀框架，其内部提供了对各种优秀框架如(struts2，hibernate,mybatis,quartz，jpa)等的直接支。
4.方便对程序进行测试，spring对于Junit4的支持，可通过注解方便测试程序。
5.降低了JavaEE API的使用难度，JDBC,Javamail,远程调用等，s
                                    将一个大型项目拆分为多个模块，每个模块只负责自己的一部分功能，可以使得代码更加清晰、结构更加清晰。这样，当需要修改某个功能时，只需要修改对应模块的代码，不会影响到其他模块的代码，从而提高了代码的可维护性。而将项目拆分为多个模块后，每个模块可以单独提交，从而使得版本控制系统中的历史记录更加清晰。而将项目拆分为多个模块后，每个人可以负责自己的模块，从而减少了代码冲突的可能性，便于团队协作。而将项目拆分为多个模块后，每个模块可以单独编译，从而提高了编译和构建的效率。
                                    在需要统一版本的位置,使用 ${自定义标签名} 引用声明的版本号。另外，自定义标签声明数据的配置并不是只能用于声明依赖的版本号,凡是需要统一声明后再引用的场合都可以使用,例如:统一配置项目构建的源码的字符集格式。xml复制代码。
                                    比起传统复杂的单体工程，使用Maven的多模块配置，可以帮助项目划分模块，鼓励重用，防止POM变得过于庞大，方便某个模块的构建，而不用每次都构建整个项目，并且使得针对某个模块的特殊控制更为方便。比起传统复杂的单体工程，使用Maven的多模块配置，可以帮助项目划分模块，鼓励重用，防止POM变得过于庞大，方便某个模块的构建，而不用每次都构建整个项目，并且使得针对某个模块的特殊控制更为方便。
                                    设计模式真言：“高内聚、低耦合”，springmvc项目，一般会把项目分成多个包：controller、service、dao、util等，但是随着项目的复杂性提高，想复用其他一个模块的话，因为是包的形式，剥离出来会比较困难，耦合性有点强，常用的方法就是复制代码修改，但是这样会做很多无用功与增加出错几率。...