Spring Boot 项目 (一) 构建多模块工程

1 写在前面

动力：

之前编写的 Spring Boot 程序把所有的代码都塞在一个整体的源文件目录下，不利于后续的编码。再加之前端使用了 Angular 组织代码，后台也将重构成模块化形式；

局限：

由于编写模块化代码需要对模块化代码有一定基础了解(比如 JDK9 与前端的模块化)，与 Maven 了解，并且对 Spring Boot 的架构有一定了解，所以在没有足够的学习之前，是不能完成模块化 这一目标的。

2 从零构建一个模块化 Web 工程

2.1 代码结构分析

我们将编写一个简单的 司机与车辆 vehicleSys

首先我们的代码将分为几个模块：

1. vs-domain: 用于定义 实体类；
2. vs-dao: 用于定义数据库访问接口；
3. vs-service: 用于定义处理服务；
4. vs-web: 用于定义与前端的数据交互;

2.2 工程结构构建

2.2.1 主 Project

首先新建一个工程：

我们的工程目录并不存放任何实际代码，而是管理各种模块，因此在 Spring Initializr 初始化项目时，我们不需要勾选任何依赖，只有 Maven Type 需要使用 POM 

 

 可以看到 Spring 为我们生成了以下结构：

 

 

 浏览它生成的依赖：

    <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>

 

 可以看到 Spring 为我们添加了主要使用的测试依赖，由于 Springboot 2.2.1 开始默认提供了 JUNIT5，所以我们将在之后的测试中使用它(如果有测试的话)：

 并且也添加了各种核心依赖，这里只列出当前工程使用到的核心依赖：

• spring-core：Spring 核心；
• snakeyaml：解析 Resources 下的 y(a)ml 配置文件；
• jakarta.annotation-api：JAVA 注解包，包括 security 和 sql ；
• jakarta.servlet-api：Servlet 核心；
• spring-boot-starter-logging：提供包括 log-back(默认)，slf4j 的日志支持；
• spring-boot-autoconfigure：完成 Spring Boot 自动配置魔法的核心依赖；
• jackson/gson：序列化工具，默认使用 jackson

2.2.2 vs-domain

在项目根目录下右键，new - Module，需要注意的是我们这次将使用 Maven ，新建 vs-domain 模块，一直 next 完成；

并且编写 Driver 类与 Car 类，这里使用了 Lombok 简化代码，请在 vs-domain 的 POM 文件中添加 lombok 依赖 

package pancc.vs.domain;

import lombok.*;

import java.io.Serializable;
import java.util.Set;

/**
 * @author pancc
 * @version 1.0
 */
@Getter
@Setter
@Builder
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class Driver implements Serializable {
    private static final long serialVersionUID = -5208610208917077981L;

    private Long id;
    private String name;
    private Integer age;


    @EqualsAndHashCode.Exclude
    private Set<Car> cars;
}

 

package pancc.vs.domain;

import lombok.*;

import java.io.Serializable;

/**
 * @author pancc
 * @version 1.0
 */
@Getter
@Setter
@Builder
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class Car implements Serializable {

    private static final long serialVersionUID = 1925499860719739118L;

    private Long id;
    private String name;
    private Long price;

}

2.2.3 vs-dao

跟 vs-domain 一样，我们在工程下添加 vs-domain 模块，并且编写代码，需要注意的是我们现在暂时将重点放在模块化上，所以 dao 只是 mock，并且由于我们需要用到之前编写的 vs-domain 模块中的实体类，因此需要在 vs-dao 模块的 POM 文件中添加依赖：

    <dependencies>
        <dependency>
            <groupId>pancc.vs</groupId>
            <artifactId>vs-domain</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

然后编写 mock 的 DriverDao:

package pancc.vs.dao;

import org.springframework.stereotype.Component;
import pancc.vs.domain.Car;
import pancc.vs.domain.Driver;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;


/**
 * @author pancc
 * @version 1.0
 */
@Component
public class DriverDao {
    private static final Set<Driver> DRIVER_SET;

    static {
        DRIVER_SET = Collections.unmodifiableSet(
                Collections.singleton(
                        Driver.builder().id(250L).name("Kate").cars(
                                new HashSet<>(
                                        Arrays.asList(
                                                Car.builder().id(1L).name("Ben").price(2500L).build(),
                                                Car.builder().id(2L).name("Tesla").price(30000L).build()))
                        ).build()));
    }

    public Set<Driver> queryAll() {
        return DRIVER_SET;
    }
}

 

2.2.4 vs-service 

vs-service 模块与 vs-dao 的编写过程没有区别，这里只贴出代码:

package pancc.vs.service;

import org.springframework.stereotype.Service;
import pancc.vs.dao.DriverDao;
import pancc.vs.domain.Driver;

import java.util.Set;

/**
 * @author pancc
 * @version 1.0
 */
@Service
public class DriverService {

    private final DriverDao driverDao;

    public DriverService(DriverDao driverDao) {
        this.driverDao = driverDao;
    }

    public Set<Driver> queryAll() {
        return this.driverDao.queryAll();
    }
}

 

有一点令人不快的是，对于习惯了以前的 Spring Boot 编程的人，此时的 idea 并没有在 @Autowire 注解导航可用的 bean，这个问题将在之后解决；

2.2.5 vs-web

从这里开始我们必须注意，由于从主工程的 POM 文件中继承的 spring-boot-starter-parent 并不包含 web 依赖，我们必须手动添加，同时也要添加使用到的 vs-service ：

    <dependencies>
        <dependency>
            <groupId>pancc.vs</groupId>
            <artifactId>vs-service</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.11.RELEASE</version>
        </dependency>
    </dependencies>

 

编写 DriverController ：

package pancc.vs.web.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import pancc.vs.domain.Driver;
import pancc.vs.service.DriverService;

import java.util.Set;

/**
 * @author pancc
 * @version 1.0
 */
@RestController
@RequestMapping("driver")
public class DriverController {

    @Autowired
    private DriverService driverService;

    @GetMapping("all")
    Set<Driver> all() {
        return this.driverService.queryAll();
    }
}

可以看到，此时 IDEA 仍旧没有为：@Autowired  注解导航 Bean

 

 

我们的目的是在 web 环境下使用， 让我们为 vs-web 编写启动类 ：

package pancc.vs.web;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author pancc
 * @version 1.0
 */
@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

请注意 App 所在的 Package ，这为解决接下来的问题很有帮助。

2.3 构建之后的问题

现在我们的 vs-web 的目录结构是这样的：

 

 同时， IDEA 也标识了这是一个 Spring Boot 应用。运行它，很好，我们得到了一个运行错误：

Field driverService in pancc.vs.web.controller.DriverController required a bean of type 'pancc.vs.service.DriverService' that could not be found.

 

让我们先查看 Controller，哦豁完蛋：

 

 

没问题，我们将在下一节修复它；

2.3.1 回顾 Spring Boot 

在着手解决上边的问题之前，让我们来复习一下 Spring Boot 的核心注解：

When a class does not include a package declaration, it is considered to be in the “default package”. The use of the “default package” is generally discouraged and should be avoided. It can cause particular problems for Spring Boot applications that use the @ComponentScan, @ConfigurationPropertiesScan, @EntityScan, or @SpringBootApplication annotations, since every class from every jar is read.

 与

　We generally recommend that you locate your main application class in a root package above other classes. The @SpringBootApplication annotation is often placed on your main class, and it implicitly defines a base “search package” for certain items. For example, if you are writing a JPA application, the package of the @SpringBootApplication annotated class is used to search for @Entity items. Using a root package also allows component scan to apply only on your project.

这两段话简要来说就是 @SpringBootApplication 注解会将自身所在包作为默认包扫描各种组件：Entity, Repository, Service, Controller....

2.3.2 修复错误

让我们梳理一下几个类的包位置：

• App: pancc.vs.web
• DriverController: pancc.vs.web.controller
• DriverService: pancc.vs.service
• DriverDao: pancc.vs.dao
• Driver: pancc.vs.domain
• Car: pancc.vs.domain

可以看到，只有 DriverController 在 App 的包下，因此只有 DriverController  可以被扫描到；其他类则处于不同包下不能被扫描；

　

让我们先修复 DriverService ，这是最近需要修复的：

修改在 App 上的注释：  @SpringBootApplication(scanBasePackages = { "pancc.vs.service"})   

现在我们得到了一个没有报错的 DriverController ,同时也没有起到 Controller 作用的 普通类：

继续运行 App , 会得到另一个错误：  

Parameter 0 of constructor in pancc.vs.service.DriverService required a bean of type 'pancc.vs.dao.DriverDao' that could not be found.

请不要忽视了添加 App 所在的包扫描，修改成下面的任意 1 项：

 @SpringBootApplication(scanBasePackages = { "pancc.vs.service"},scanBasePackageClasses = {App.class}) 

 @SpringBootApplication(scanBasePackages = {"pancc.vs.web", "pancc.vs.service"}) 

现在我们的 IDEA 能很好地导航 DriverController 依赖的 DriverService ，不要忘记我们的问题还没有修复完整，DriverService 内的 Bean 依赖 DriverDao 也需要修复，继续修改 启动注解：

 @SpringBootApplication(scanBasePackages = {"pancc.vs.web", "pancc.vs.service","pancc.vs.dao"}) 

现在我们的程序可以运行了，启动它并用 IDEA 的 RestServices 测试端口 /driver/all

 

2.3.3 懒人向修复

1 通配符：你可以使用通配符匹配包扫描路径。

 @SpringBootApplication(scanBasePackages = {"pancc.vs.*"}) 可以避免重复劳动。

 

2 转移启动类到包顶层：就像 2.3.1 Spring Boot 文档中描述的一样，将 App 置于顶层中

将 App 置于 包 pancc.vs 中，现在我们的包结构变成了：

• App: pancc.vs
• DriverController: pancc.vs.web.controller
• DriverService: pancc.vs.service
• DriverDao: pancc.vs.dao
• Driver: pancc.vs.domain
• Car: pancc.vs.domain

你可以删掉  scanBasePackages 属性了

2.4 打包

2.4.1 在打包之前

让我们看看  spring-boot-starter-web 依赖中有哪些需要注意的内容

• spring-boot-starter：spring 核心
• spring-boot-starter-json：rest 支持
• spring-boot-starter-tomcat：内置 web 容器
• hibernate-validator：验证注解
• spring-web：web 支持
• spring-webmvc：mvc 支持

2.4.2 使用外部容器

 spring-boot-starter-web 依赖中存在 scope 为 compile 的 spring-boot-starter-tomcat ，所以我们在打包的时候需要将内置容器排除，同时在开发的时候需要使用内置容器，所以使用 provided ：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

同时，需要设置打包方式为 war ，可以设置打包的输出名字：

    <packaging>war</packaging>

    <!--Maven >= 3-->
    <build>
        <finalName>vs-web</finalName>
    </build>

    <!--Maven < 3-->
<!--
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
            <finalName>vs-web</finalName>
        </configuration>
    </plugin>
    -->

同时由于使用外部容器，我们需要让启动类 App 继承 SpringBootServletInitializer，以便将 Servlet，Filter，ServletContextInitializer Beans 绑定到外部容器上：

package pancc.vs.web;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

/**
 * @author pancc
 * @version 1.0
 */
@SpringBootApplication(scanBasePackages = {"pancc.vs.*"})
public class App extends SpringBootServletInitializer {


    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(App.class);
    }

    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

设置完，在 vs-web 模块目录下执行 mvn clean && mvn package：

 

 

 可以看到 maven 同时编译了依赖各个模块的的 class 同时在 vs-web 模块的 target 下生成了 vs-web.war 包

 

 

 查看 vs-web.war 包的结构，可以看到依赖的各个模块被很好的打包进去了：

 

 

 

将 vs-web.war 复制到 ~\tomcat\webapps 目录下，执行启动程序并访问 链接  http://localhost:8080/vs-web/driver/all:

 

 

 

2.4.3 使用可执行 jar 包

由于目标是可执行 Jar 包，所以 vs-web 需要保留内置的 Tomcat 容器，此时我们的 App 不需要继承 SpringBootServletInitializer， 并且需要使用到 spring-boot-maven-plugin 插件，用于重新打包 Maven 打包好的 Jar 包。

现在我们的 POM 文件变成了：

<?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>multiple</artifactId>
        <groupId>pancc.vs</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>vs-web</artifactId>

    <dependencies>
        <dependency>
            <groupId>pancc.vs</groupId>
            <artifactId>vs-service</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.11.RELEASE</version>
        </dependency>
    </dependencies>

    <packaging>jar</packaging>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <layout>JAR</layout>
                    <mainClass>pancc.vs.web.App</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
        <finalName>vs-web</finalName>
    </build>
</project>

在 vs-web 模块目录下执行 mvn clean && mvn package && java -jar ./target/vs-web.jar, 可以看到程序正确执行，之后便可以愉快的测试了:

 

访问  http://localhost:8080/driver/all 查看结果吧

 

2.5 我们漏了什么？

请注意 2.4.3 中 打包的可执行 JAR 包的结构，它的主类变成了 org.springframework.boot.loader.JarLauncher，我们将在之后抽点时间来分析它的源码；

 

在 2.3.1 与 2.3.2 中我们分析了 Spring Boot 注解的包扫描问题，其中注解扫描的内容还包括 @Entity  ，这是属于 javax.persistence 的注解，我们将在 Spring Boot 项目 (二) 中使用它