Maven 高级篇之构建多模块项目的方法
基于 IDEA 创建 Maven 多模块项目。
1. 创建父项目
父项目必须遵循以下两点要求：
- packaging 标签的文本内容必须设置为 pom。
- 删除 src 目录。
1.1. 新建项目
文件 -> 新建 -> 项目
Maven -> 下一步
填写名称，GroupId，ArtifactId
选择在新窗口打开项目
1.2. 修改项目
在pom.xml添加<packaging>pom</packaging>，此时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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.gtcom</groupId>
<artifactId>gtcom-data</artifactId>
<version>1.0-SNAPSHOT</version>
<!--打包方式-->
<packaging>pom</packaging>
<properties>
<!--指定编译环境 JDK 版本-->
<maven.compiler.source>11</maven.compiler.source>
<!--指定运行环境JDK版本-->
<maven.compiler.target>11</maven.compiler.target>
<!--指定项目构建编码-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>
删除 src 目录。删除 src 前项目结构：
删除 src 后项目结构：
添加编译插件配置，项目中会统一使用 JDK 版本和编译级别，所以项目的编译级别必须统一，那么将编译插件添加到父工程，子模块会无条件去继承父工程的插件。此时pom.xml内容如下所示：
这一步不需要，因为子模块有 SpringBoot 模块，也有普通 Maven 模块，使用的编译插件配置并不相同。
还有就是 properties 中目前配置的三个就直接配置的是 Maven 编译插件的配置，不需要再在 build 中配置一次了。
Maven 官方说明：Setting the -source and -target of the Java Compiler
<?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.gtcom</groupId>
<artifactId>gtcom-data</artifactId>
<version>1.0-SNAPSHOT</version>
<!--打包方式-->
<packaging>pom</packaging>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<project.build.encoding>UTF-8</project.build.encoding>
</properties>
<build>
<plugins>
<!--编译插件-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<!--插件名称-->
<artifactId>maven-compiler-plugin</artifactId>
<!--插件版本-->
<version>3.8.1</version>
<!--插件配置信息-->
<configuration>
<!--编译环境 JDK 版本-->
<source>${maven.compiler.source}</source>
<!--运行环境 JDK 版本-->
<target>${maven.compiler.target}</target>
<!--编码格式-->
<encoding>${project.build.encoding}</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
2. 创建子模块（普通 Java 模块）
文件 -> 新建 -> 新模块
Maven -> 下一步
选择父项为上面创建的父项目，填写名称，GroupId，ArtifactId
建好后的项目结构：
子模块 data-service 的pom.xml（这里给子模块也提供了版本version，不提供的话会直接继承父项目的version），这里添加了源码打包插件配置，因为该模块需要打包发布到 Maven 私服供别的项目引用：
<?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">
<parent>
<groupId>com.gtcom</groupId>
<artifactId>gtcom-data</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>data-service</artifactId>
<version>1.0.0-SNAPSHOT</version>
<build>
<plugins>
<!--源码打包插件配置-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.2.1</version>
<configuration>
<attach>true</attach>
</configuration>
<executions>
<execution>
<phase>compile</phase>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
此时父项目 gtcom-data 的pom.xml，可以发现父项目包含的模块 modules 中已经有了 data-service 模块了：
<?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.gtcom</groupId>
<artifactId>gtcom-data</artifactId>
<version>1.0-SNAPSHOT</version>
<!--父项目包含的所有模块名称-->
<modules>
<module>data-service</module>
</modules>
<!--打包方式-->
<packaging>pom</packaging>
<properties>
<!--指定编译环境JDK版本-->
<maven.compiler.source>11</maven.compiler.source>
<!--指定运行环境JDK版本-->
<maven.compiler.target>11</maven.compiler.target>
<!--指定项目构建编码-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>
3. 创建子模块（SpringBoot 模块）
先在父项目的pom.xml中添加 SpringBoot 的依赖声明：
<!--依赖声明-->
<dependencyManagement>
<dependencies>
<!--SpringBoot-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.5.3</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
然后按照上面建普通 Java 子模块的方法创建一个 data-web 模块。修改pom.xml文件，添加 SpringBoot 依赖，此时 data-web 的pom.xml内容如下，我这里添加了 SpringBoot 编译打包插件和资源打包配置：
<?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">
<parent>
<artifactId>gtcom-data</artifactId>
<groupId>com.gtcom</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>data-web</artifactId>
<version>1.0.0-SNAPSHOT</version>
<dependencies>
<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>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
<resources>
<!-- src/main/java下的xml资源编译到classes下 -->
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
</resource>
<!-- src/main/resources下的资源编译到classes下 -->
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.*</include>
</includes>
</resource>
</resources>
</build>
</project>
此时父项目的pom.xml，可以发现父项目包含的模块中已经有了 data-web 模块了，这里我添加了依赖声明，子模块中需要的包的版本统一配置在这里，子模块的依赖就不需要配置版本号了：
<?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.gtcom</groupId>
<artifactId>gtcom-data</artifactId>
<version>1.0-SNAPSHOT</version>
<!--父工程包含的所有模块名称-->
<modules>
<module>data-service</module>
<module>data-web</module>
</modules>
<!--打包方式-->
<packaging>pom</packaging>
<properties>
<!--指定编译环境JDK版本-->
<maven.compiler.source>11</maven.compiler.source>
<!--指定运行环境JDK版本-->
<maven.compiler.target>11</maven.compiler.target>
<!--指定项目构建编码-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!--依赖版本管理-->
<spring.boot.version>2.5.3</spring.boot.version>
<mybatis.version>2.2.0</mybatis.version>
<fastjson.version>1.2.76</fastjson.version>
<commons.lang3.version>3.11</commons.lang3.version>
</properties>
<!--依赖声明-->
<dependencyManagement>
<dependencies>
<!--springboot-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring.boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis.version}</version>
</dependency>
<!--fastjson-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!--commons-lang3-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons.lang3.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
手动添加一个 SpringBoot 启动类和一个 application.properties 文件，此时的项目结构：
到这里就可以通过启动类直接运行 data-web 模块了。
4. 插件配置解释
普通 Maven 项目上运行 package 时的日志，通过观察可以发现调用的插件依次为红框标注的插件。
Maven 项目打的 Jar 包结构，里面并不包含依赖的 Jar 包：
SpringBoot 项目上运行 package 时调用的插件日志为：
SpringBoot 项目打的 Jar 包的结构，内部包含了依赖的 Jar 包，可直接运行：
由上可见，SpringBoot 项目较普通 Maven 项目的特别之处在于，SpringBoot 提供的插件将生成的 Jar 包进行了重新打包；这也是 BOOT-INF 文件夹的来由；
【注意：单独的 SpringBoot 项目的打包插件并不需要配置 executions】
5. 打包插件配置
5.1. 全 SpringBoot 模块项目
父项目 task-output 的 pom：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
</plugin>
</plugins>
</build>
子模块 output-common 的 pom：
该模块是基础模块，不需要单独运行。
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>
子模块 output-executor 的 pom：
<dependencies>
<dependency>
<groupId>com.gtcom</groupId>
<artifactId>output-common</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
子模块 output-manager 的 pom：
<dependencies>
<dependency>
<groupId>com.gtcom</groupId>
<artifactId>output-common</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
5.2. 非全 SpringBoot 模块项目
父项目 gtcom-data，pom 中不做打包插件配置。
子模块 data-search 的 pom：（非 SpringBoot 模块）
<build>
<plugins>
<!--源码打包插件配置-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.2.1</version>
<configuration>
<attach>true</attach>
</configuration>
<executions>
<execution>
<phase>compile</phase>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
子模块 data-task 的 pom：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>com.gtcom</groupId>
<artifactId>data-search</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
子模块 data-common 的 pom：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
</plugin>
</plugins>
</build>
子模块 data-web 的 pom：
<dependencies>
<dependency>
<groupId>com.gtcom</groupId>
<artifactId>data-common</artifactId>
</dependency>
<dependency>
<groupId>com.gtcom</groupId>
<artifactId>data-search</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
6. 多模块注入
6.1. 注解介绍
在平时使用 Spring Boot 时，常常会使用到@Configuration、@Contoller，@Service，@Component等注解，被添加这些注解的类，在 SpringBoot 启动时，会自动被 Spring 容器管理起来。组件扫描的作用就是：当 SpringBoot 启动时，根据定义的扫描路径，把符合扫描规则的类装配到 Spring 容器中。
6.1.1. @ComponentScan
@ComponentScan 注解源码：
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
// 指定扫描包的位置(同：basePackages 属性),可以是单个路径，也可以是扫描的路径数组
@AliasFor("basePackages")
String[] value() default {};
// 指定扫描包的位置(同：value 属性)
@AliasFor("value")
String[] basePackages() default {};
// 指定具体的扫描的类
Class<?>[] basePackageClasses() default {};
// bean的名称的生成器
Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
// 控制符合组件检测条件的类文件 默认是包扫描下的 **/*.class
String resourcePattern() default "**/*.class";
// 是否开启对@Component，@Repository，@Service，@Controller的类进行检测
boolean useDefaultFilters() default true;
// 包含的过滤条件
// 1. FilterType.ANNOTATION： 按照注解过滤
// 2. FilterType.ASSIGNABLE_TYPE： 按照给定的类型
// 3. FilterType.ASPECTJ： 使用ASPECTJ表达式
// 4. FilterType.REGEX： 正则
// 5. FilterType.CUSTOM： 自定义规则
ComponentScan.Filter[] includeFilters() default {};
// 排除的过滤条件，用法和includeFilters一样
ComponentScan.Filter[] excludeFilters() default {};
boolean lazyInit() default false;
@Retention(RetentionPolicy.RUNTIME)
@Target({})
public @interface Filter {
FilterType type() default FilterType.ANNOTATION;
@AliasFor("classes")
Class<?>[] value() default {};
@AliasFor("value")
Class<?>[] classes() default {};
String[] pattern() default {};
}
}
总结一下@ComponentScan的常用方式：
- 通过使用 value，basePackages 属性来指定扫描范围；
- 自定义扫描路径下边带有 @Controller，@Service，@Repository，@Component 注解的类加入 Spring 容器；
- 通过 includeFilters 加入扫描路径下没有以上注解的类加入 Spring 容器；
- 通过 excludeFilters 过滤出不用加入 Spring 容器的类；
- 自定义增加了 @Component 的注解方式。
6.1.2. @SpringBootApplication
在创建 SpringBoot 项目之后，在默认的启动类上会被添加@SpringBootApplication注解，这个注解默认帮我们开启一些自动配置的功能，比如：基于 Java 的 Spring 配置，组件扫描，特别是用于启用 SpringBoot 的自动配置功能。
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration // 允许自动配置
@ComponentScan(
excludeFilters = {@Filter( // 定义排除规则
type = FilterType.CUSTOM, // 采用自定义的方式
classes = {TypeExcludeFilter.class} // 自定义实现逻辑
), @Filter( // 同上
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
// 为 @EnableAutoConfiguration 添加 exclude 规则
@AliasFor(
annotation = EnableAutoConfiguration.class,
attribute = "exclude"
)
Class<?>[] exclude() default {};
// 为 @EnableAutoConfiguration 添加 excludeName 规则
@AliasFor(
annotation = EnableAutoConfiguration.class,
attribute = "excludeName"
)
String[] excludeName() default {};
// 为 @ComponentScan 添加 basePackages 规则
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackages"
)
String[] scanBasePackages() default {};
// 为 @ComponentScan 添加 basePackageClasses 规则
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackageClasses"
)
Class<?>[] scanBasePackageClasses() default {};
}
从上面的源码部分可以看到，@SpringBootApplication是一个组合注解，也就相当于使用一个@SpringBootApplication可以替代@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan几个注解联合使用。
注：此注释从 SpringBoot 1.2 开始提供，这意味着如果你运行的是较低的版本，并且需要这些功能，则需要手动添加@Configuration，@CompnentScan和@EnableAutoConfiguration。
那么，可能会有这样的问题，我只是使用了一个@SpringBootApplication注解，但是我如何对@ComponentScan的属性做自定义配置呢？
当然，Spring 团队已经很好的解决了这个问题，在@SpringBootApplication注解类中的属性上添加@AliasFor注解，从而实现通过对@SpringBootApplication中的属性进行自定义，达到对对应的注解的属性的自定义。
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackages"
)
String[] scanBasePackages() default {};
这段代码就是实现，通过对@SpringBootApplication的属性scanBasePackages，实现对@ComponentScan中的属性basePackages进行自定义。
@AliasFor
在 Spring 注解中，经常会发现很多注解的不同属性起着相同的作用，比如 @ComponentScan 的 value 属性和 basePackages 属性。所以在使用的时候就需要做一些基本的限制，比如 value 和 basePackages 的值不能冲突，比如任意设置 value 或者设置 basePackages 属性的值，都能够通过另一个属性来获取值等等。为了统一处理这些情况，Spring 创建了 @AliasFor 标签。
6.2. 多模块注入示例
6.2.1. 示例一
我这有个多模块项目 data-output，内部有三个模块，一个公共模块 output-common，两个 web 模块 output-manager，output-backstage。这三个模块都是 SpringBoot 项目。
output-manager，output-backstage 通过 pom 依赖的方式使用 output-common 中的类。
这三个项目内部的基础包路径分别是：com.gtcom.common、com.gtcom.manager、com.gtcom.backstage。
此时output-manager，output-backstage 的启动类注解上需要配置下面内容才能正常使用公共包中的类：
@SpringBootApplication(scanBasePackages = {"com.gtcom"})
6.2.2. 示例二
项目入口文件在子项目 security-demo 中，并且入口类所在包位置为：com.github.jdkong.security。也就是说，在不做任何配置的情况下，此项目只会扫描当前包路径及其子路径下的文件，并将符合条件的对象注入到容器中管理。
再看看配置文件所在的包路径位置：com.github.jdkong.browser.config，可见此包路径并不在项目扫描的路径范围之内。这也就导致了，我们定义的配置类，虽然加了@Configuration也不会对我们的项目起到作用。
可以对项目注解进行稍微修改，指定扫描包的范围，就可以简单的解决这个问题。如下：
@SpringBootApplication(scanBasePackages="com.github.jdkong")
public class SecurityApplication {
public static void main(String[] args) {
SpringApplication.run(SecurityApplication.class,args);
}
}
6.2.3. 示例三
SpringBoot 中 Service 自动注入很方便，例：
Service.class（接口类）
ServiceImpl.class（实现类）
Controller.class（使用类）
用以上三个类来说一下自动注入：
单体项目：分别ServiceImpl头上添加@Service，Controller中Service依赖添加@Autowired即可使用。
多模块项目：三个（种）类分别在三个 module 下：
moduleA : Service.class（com.example.moduleA ）
moduleB : ServiceImpl.class ( com.example.moduleB )
moduleC : Controller.class ( com.example.moduleC )
此时 B 依赖 A，C 依赖 AB，在 pom.xml 中添加好依赖关系。如何自动注入？
1、接口、实现、使用类，姿势不变，按单项目方式写即可；
2、在 moduleC 的 Application 启动类中做修改！
因为 Service 及 ServiceImpl 均在com.example包下（C 可以不在），可以看作是同一次 scan 过程；所以解决办法：
@SpringBootApplictaion(scanBasePackages="com.example")
或者
@ComponentScan(value = "com.example")
若是这样写scanBasePackages={" com.example.moduleA , com.example.moduleB "}，则会失败；
转载自:https://juejin.cn/post/7352769502130307124