likes
comments
collection
share

Maven 高级篇之构建多模块项目的方法

作者站长头像
站长
· 阅读数 13

基于 IDEA 创建 Maven 多模块项目。

1. 创建父项目

父项目必须遵循以下两点要求:

  • packaging 标签的文本内容必须设置为 pom。
  • 删除 src 目录。

1.1. 新建项目

文件 -> 新建 -> 项目

Maven 高级篇之构建多模块项目的方法

Maven -> 下一步

Maven 高级篇之构建多模块项目的方法

填写名称,GroupId,ArtifactId

Maven 高级篇之构建多模块项目的方法

选择在新窗口打开项目

Maven 高级篇之构建多模块项目的方法

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 前项目结构:

Maven 高级篇之构建多模块项目的方法

删除 src 后项目结构:

Maven 高级篇之构建多模块项目的方法

添加编译插件配置,项目中会统一使用 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 高级篇之构建多模块项目的方法

Maven -> 下一步

Maven 高级篇之构建多模块项目的方法

选择父项为上面创建的父项目,填写名称,GroupId,ArtifactId

Maven 高级篇之构建多模块项目的方法

建好后的项目结构:

Maven 高级篇之构建多模块项目的方法

子模块 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 文件,此时的项目结构:

Maven 高级篇之构建多模块项目的方法

到这里就可以通过启动类直接运行 data-web 模块了。

4. 插件配置解释

普通 Maven 项目上运行 package 时的日志,通过观察可以发现调用的插件依次为红框标注的插件。

Maven 高级篇之构建多模块项目的方法

Maven 项目打的 Jar 包结构,里面并不包含依赖的 Jar 包:

Maven 高级篇之构建多模块项目的方法

SpringBoot 项目上运行 package 时调用的插件日志为:

Maven 高级篇之构建多模块项目的方法

SpringBoot 项目打的 Jar 包的结构,内部包含了依赖的 Jar 包,可直接运行:

Maven 高级篇之构建多模块项目的方法

Maven 高级篇之构建多模块项目的方法

由上可见,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头上添加@ServiceControllerService依赖添加@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
评论
请登录