Spring Boot 多模块项目

2025年1月17日 | 阅读 11 分钟

多模块项目

包含嵌套 Maven 项目的 Spring Boot 项目称为多模块项目。在多模块项目中，父项目充当基础 Maven 配置的容器。

换句话说，多模块项目由一个父 POM 构建，该父 POM 管理一组子模块。或者，多模块项目由引用一个或多个子模块的父 POM 定义。

父 Maven 项目必须包含打包类型pom，这会将项目标识为聚合器。父项目的pom.xml 文件包含所有模块、公共依赖项和由子项目继承的属性列表。父 POM 位于项目的根目录。子模块是实际的 Spring Boot 项目，它们继承了父项目的 Maven 属性。

当我们运行多模块项目时，所有模块将一起部署在嵌入式 Tomcat 服务器中。我们也可以单独部署某个模块。

父 POM

父 POM 定义Group ID、Artifact ID、version和packaging。在之前的 Maven 项目中，我们已经看到父 POM 定义的打包类型是jar。但在多模块项目中，父POM定义打包类型为pom。打包类型为 pom 的项目引用其他 Maven 项目。

为什么我们需要多模块项目

将项目拆分成多个模块有助于轻松维护。我们还可以轻松地编辑或删除项目中的模块，而不会影响其他模块。当我们需要单独部署模块时，这非常有用。

我们只需要在父 POM 中指定所有依赖项。所有其他模块共享相同的 POM，因此我们不需要在每个模块中单独指定相同的依赖项。这使得在一个大项目中更容易保持代码井井有条。

子模块-ear, war, 和 jar

子模块可以是任何项目，并且可以具有任何打包类型。我们可以自由地创建模块之间的任何类型的依赖关系并将它们捆绑在一起。

例如，我们创建一个EAR（企业归档）、WAR（Web 归档）和JAR（Java 归档）文件。JAR 文件被打包到 WAR 文件中，WAR 文件又被打包到 EAR 文件中。EAR 文件是最终准备好部署到应用程序服务器的包。

EAR 文件包含一个或多个 WAR 文件。每个 WAR 文件包含所有 WAR 文件通用的服务项目，其打包类型为 JAR。

Maven 子项目/模块

子模块是独立的 Maven 项目，它们共享父项目的属性。
所有子项目都可以通过一个命令构建，因为它位于父项目内部。
更容易定义项目之间的关系。

多模块项目目录结构

让我们来理解一下多模块项目的目录结构。

在下面的图像中，我们创建了一个名为spring-boot-multi-module-project的项目。它在目录底部包含父pom。之后，我们分别创建了两个Maven 模块，名为module1和module2。这两个模块包含它们自己的 pom 文件。

让我们打开父 POM，看看当我们创建 Maven 模块时，它配置了什么。

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.2.2.BUILD-SNAPSHOT</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.javatpoint</groupId>
<artifactId>spring-boot-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-multi-module-project</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<packaging>pom</packaging>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>	
<dependency>
 <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.1.RELEASE</version>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</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>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
<repository>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>https://repo.spring.io/snapshot</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</pluginRepository>
<pluginRepository>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>https://repo.spring.io/snapshot</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
<modules>
<module>module1</module>
<module>module2</module>
</modules>
</project>

上面的 pom 文件与我们在前面示例中看到的相同。但在pom文件中，有两点值得注意：packaging和modules。

当我们创建多模块项目时，我们需要在父 pom 文件中配置打包类型为 pom，而不是jar。

当我们创建项目中的 Maven 模块时，Spring Boot 会自动在module标签内的父 POM 中配置模块，如下所示：

<modules>
<module>module1</module>
<module>module2</module>
</modules>

现在，我们将看看module1的 pom 文件里面有什么。

pom.xml

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.javatpoint</groupId>
<artifactId>spring-boot-multi-module-project</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>com.javatpoint</groupId>
<artifactId>module1</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>module1</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

这里需要注意的一点是，上面的 pom 文件不包含像starter-web, web-mvc等通用依赖项。它继承了来自父 POM的所有通用依赖项和属性。

Spring Boot 多模块项目示例

让我们创建一个多模块应用程序的示例。

在下面的示例中，我们创建了一个名为spring-boot-multimodule的 Maven 项目。这是主应用程序。在主应用程序中，我们创建了五个模块，如下所示：
应用程序
model
repository
service-api
service-impl

Application Module

应用程序模块是项目的主模块。它包含应用程序类，其中定义了运行 Spring Boot 应用程序所必需的 main 方法。它还包含应用程序配置属性、Controller、视图和资源。

Application Module 依赖于 Model Module、Service Implementation Module，它们包含 Model Module、Repository Module 和 Service API 模块。

Model Module

Model Module 包含项目中使用的实体和视觉对象。

Repository Module

Repository 模块包含项目中使用的存储库。它依赖于 Model Module。

Service API Module

Service API 模块包含所有项目服务。它还依赖于 Model Module。

Service Implementation Module

Service Implementation 模块实现了服务。它依赖于 Repository Module 和 Service API Module。

POM Aggregator (Parent POM)

父 POM 包含所有应用程序模块。它还包含一个或多个模块所需的所有通用依赖项和属性。依赖项是无版本定义的，因为项目已将 Spring IO Platform 定义为父项。

让我们来理解一下我们创建的多模块应用程序的结构。

Spring-boot-multimodule
├── pom.xml
│   └── REDME.adoc
├── application
│   ├── pom.xml
│   └── src
│       └── main
│           ├── java
│           │   └── sample
│           │       └── multimodule
│           │           ├── SampleWebJspApplication.java
│           │           └── web
│           │               └── WelcomeController.java
│           └── resources
│               ├── application.properties
│               └── templates
│                   └── welcome
│                       └── show.html
├── model
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── sample
│                   └── multimodule
│                       └── domain
│                           └── entity
│                               └── Account.java
|
├── repository
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── sample
│                   └── multimodule
│                       └── repository
│                           └── AccountRepository.java
├── service-api
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── sample
│                   └── multimodule
│                       └── service
│                           └── api
│                               ├── AccountNotFoundException.java
│                               └── AccountService.java
└── service-impl
    ├── pom.xml
    └── src
        └── main
            └── java
                └── sample
                    └── multimodule
                        └── service
                            └── impl
                                └── AccountServiceImpl.java

步骤 1：创建一个名为spring-boot-multimodule的Maven 项目。

步骤 2：打开pom.xml（父 POM）文件，并将打包类型jar更改为pom。

pom.xml (父 POM)

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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>
<!-- Spring IO Platform is the parent of the generated application to
be able to use Spring Boot and all its default configuration -->
<parent>
<groupId>io.spring.platform</groupId>
<artifactId>platform-bom</artifactId>
<version>2.0.1.RELEASE</version>
</parent>
<groupId>sample.multimodule</groupId>
<artifactId>sample.multimodule</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<name>Parent - Pom Aggregator</name>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- Spring Boot dependencies -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>

上面 pom 文件中需要注意的一点是，没有配置 Maven 模块，因为我们还没有创建它们。现在我们将逐一创建上面指定的 Maven 模块。

步骤 3：创建一个名为application的Maven 模块。

步骤 4：打开应用程序模块的pom.xml文件，确保打包类型为jar。

pom.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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>
    <parent>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>sample.multimodule.application</artifactId>
    <packaging>jar</packaging>
    <name>Project Module - Application</name>
    <dependencies>
      <!-- Project modules -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.service.impl</artifactId>
        <version>${project.version}</version>
      </dependency>

      <!-- Spring Boot dependencies -->
		  <dependency>
			  <groupId>org.apache.tomcat.embed</groupId>
			  <artifactId>tomcat-embed-jasper</artifactId>
			  <scope>provided</scope>
		  </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
    
    </dependencies>
    
    <build>
        <plugins>
            <!-- Spring Boot plugins -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

步骤 5：创建main类。这是要运行的类。

SampleWebJspApplication.java

package sample.multimodule;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.orm.jpa.EntityScan;
@SpringBootApplication
public class SampleWebJspApplication 
{
public static void main(String[] args) throws Exception 
{
SpringApplication.run(SampleWebJspApplication.class, args);
}
}

步骤 6：在smaple.multimodule.web包下创建一个名为WelocameController的 Controller 类。

WelcomeController.java

package sample.multimodule.web;
import java.util.Date;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import sample.multimodule.domain.entity.Account;
import sample.multimodule.service.api.AccountService;
@Controller
public class WelcomeController 
{
@Value("${application.message:Hello World}")
private String message = "Hello World";
@Autowired
protected AccountService accountService;
@RequestMapping("/")
public String welcome(Map<String, Object> model) 
{
// Trying to obtain 23 account
Account account = accountService.findOne("23");
if(account == null){
// If there's some problem creating account, return show view with error status
model.put("message", "Error getting account!");
model.put("account", "");
return "welcome/show";
}  
// Return show view with 23 account info
String accountInfo = "Your account number is ".concat(account.getNumber());
model.put("message", this.message);
model.put("account", accountInfo);
return "welcome/show";
}
@RequestMapping("foo")
public String foo(Map<String, Object> model) {
throw new RuntimeException("Foo");
}
}

步骤 7：在src/main/resource -> templates ->welcome文件夹下创建一个名为show.html的HTML文件。

show.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Spring Boot Multimodule</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <div>
      <b>Message: </b>
      <span th:text="${message}" />
    </div>
    <div>
      <b>Your account: </b>
      <span th:text="${account}" />
    </div>
</body>
</html>

步骤 8：打开application.properties文件，配置应用程序消息并将thymeleaf缓存设置为false。

application.properties

# Application messages
application.message = Hello User!
dummy.type = type-inside-the-war
# Spring Thymeleaf config
spring.thymeleaf.cache = false

创建完所有上述文件后，应用程序模块目录如下所示：

让我们创建第二个模块，即model。

步骤 9：创建一个名为model的Maven 模块。

步骤 10：打开 model 模块的pom.xml文件，确保打包类型为jar。

pom.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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>
    <parent>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>sample.multimodule.model</artifactId>
    <packaging>jar</packaging>
    <name>Project Module - Model</name>
    <description>Module that contains all Entities and Visual Objects to be used in the project. It doesn't have any dependencies. 
    </description>
</project>

步骤 11：在sample.multimodule.domain.entity包下创建一个名为Account的类。

Account.java

package sample.multimodule.domain.entity;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
@Entity
public class Account 
{
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String number;

    private String type;

    private String creditCardNumber;

    /**
     * Create an empty account.
     */
    public Account() {

    }
    
    /**
     * Create a new account.
     * 
     * @param number
     *            the account number
     * @param id
     *            the account id
     */
    public Account(Long id, String number) {
        this.number = number;
        this.id = id;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getCreditCardNumber() {
        return creditCardNumber;
    }

    public void setCreditCardNumber(String creditCardNumber) {
        this.creditCardNumber = creditCardNumber;
    }

}

创建完所有上述文件后，model 模块目录如下所示：

让我们创建第三个模块，即repository。

步骤 12：创建一个名为repository的Maven 模块。

步骤 13：打开应用程序模块的pom.xml文件，确保打包类型为jar。（此处原文可能有误，应为 repository 模块的 pom.xml）

pom.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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>
    <parent>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>sample.multimodule.repository</artifactId>
    <packaging>jar</packaging>
    <name>Project Module - Repository</name>
    <description>Module that contains all repositories to be used in the project. Depends of Model Module.</description>

    <dependencies>
      <!-- Project modules -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>

      <!-- Spring Boot dependencies -->
      <dependency>
        <groupId>org.hsqldb</groupId>
        <artifactId>hsqldb</artifactId>
        <scope>runtime</scope>
      </dependency>

    </dependencies>
    
</project>

步骤 14：在sample.multimodule.repository包下创建一个名为AccountRepository的类。

AccountRepository.java

package sample.multimodule.repository;
import org.springframework.data.domain.*;
import org.springframework.data.repository.*;
import org.springframework.stereotype.Repository;
import sample.multimodule.domain.entity.Account;
@Repository
public interface AccountRepository extends CrudRepository<Account, Long> 
{
Account findByNumber(String number);
}

创建完所有上述文件后，repository 模块目录如下所示：

让我们创建第四个模块，即service-api。

步骤 15：创建一个名为service-api的Maven 模块。

步骤 16：打开service-api应用程序的pom.xml文件，确保打包类型为jar。

pom.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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>
    <parent>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>sample.multimodule.service.api</artifactId>
    <packaging>jar</packaging>
    <name>Project Module - Service API</name>
    <description>Module that contains API of all project services. Depends of Model Module.</description>

    <dependencies>

      <!-- Project Modules -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies> 
</project>

步骤 17：创建一个名为sample.multimodule.service.api的包。

步骤 18：创建一个名为AccountNotFoundException的类。如果找不到账户，它会处理异常。

AccountNotFoundException.java

package sample.multimodule.service.api;
public class AccountNotFoundException extends RuntimeException 
{
private static final long serialVersionUID = -3891534644498426670L;
public AccountNotFoundException(String accountId) 
{
super("No such account with id: " + accountId);
}
}

步骤 19：创建一个名为AccountService的类。它提供与账户相关的服务，例如查找和创建账户。

AccountService.java

package sample.multimodule.service.api;
import java.util.List;
import sample.multimodule.domain.entity.Account;
public interface AccountService 
{
    /**
     * Finds the account with the provided account number.
     * 
     * @param number The account number
     * @return The account
     * @throws AccountNotFoundException If no such account exists.
     */
    Account findOne(String number) throws AccountNotFoundException;
    /**
     * Creates a new account.
     * @param number
     * @return created account
     */
    Account createAccountByNumber(String number);
}

创建完所有上述文件后，service-api 模块目录如下所示：

步骤 20：创建一个名为service-impl的Maven 模块。

步骤 21：打开service-impl应用程序的pom.xml文件，确保打包类型为 jar。

pom.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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>
    <parent>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>sample.multimodule.service.impl</artifactId>
    <packaging>jar</packaging>
    <name>Project Module - Service Implementation</name>
    <description>Module that contains services implementation defined on Service API module. Depends of Repository Module and Service API Module.</description>    
    <dependencies>
      <!-- Project Modules -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.repository</artifactId>
        <version>${project.version}</version>
      </dependency>
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.service.api</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies>
</project>

步骤 22：在sample.multimodule.service.impl包下创建一个名为AccountServiceImpl的类。

AccountServiceImpl.java

package sample.multimodule.service.impl;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import sample.multimodule.domain.entity.Account;
import sample.multimodule.repository.AccountRepository;
import sample.multimodule.service.api.AccountService;
import sample.multimodule.service.api.AccountNotFoundException;
@Service
public class AccountServiceImpl implements AccountService 
{
@Value("${dummy.type}")
private String dummyType;
@Autowired
    private AccountRepository accountRepository;
    /**
     * {@inheritDoc}
     * <p/>
     * Dummy method for testing purposes.
     * 
     * @param number The account number. Set 0000 to get an {@link AccountNotFoundException} 
     */
    @Override
    public Account findOne(String number) throws AccountNotFoundException {
        if(number.equals("0000")) {
            throw new AccountNotFoundException("0000");
        }
        Account account = accountRepository.findByNumber(number);
        if(account == null){
          account = createAccountByNumber(number);
        }
        return account;
    }
    @Override
    public Account createAccountByNumber(String number) {
        Account account = new Account();
        account.setNumber(number);
        return accountRepository.save(account);
    }
    public String getDummyType() {
        return dummyType;
    }
    public void setDummyType(String dummyType) {
        this.dummyType = dummyType;
    }
}

创建完所有上述文件后，service-impl模块目录如下所示：

现在打开父 POM文件，我们会看到我们创建的所有 Maven 模块都配置在父 POM 的标签内。我们不需要手动配置它。

现在确保所有五个模块都已创建，如下所示：

创建完所有模块后，主项目目录如下所示：

步骤 23：现在以 Java 应用程序的方式运行SampleWebJspApplication.java文件。

步骤 24：在浏览器中打开并调用 URL https://:8080。它将返回Message和账户号23。

下载项目

下一主题Spring Boot 打包

Spring Boot 多模块项目

多模块项目

父 POM

为什么我们需要多模块项目

子模块-ear, war, 和 jar

Maven 子项目/模块

多模块项目目录结构

Spring Boot 多模块项目示例

POM Aggregator (Parent POM)

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Spring Boot 教程

创建项目

项目组件

Tool Suite

Spring Boot AOP

Spring Boot 数据库

Spring Boot 视图

SB 缓存

Spring Boot 其他

Spring Boot - RESTful

Spring 教程

Spring Cloud

Spring 微服务

面试题

Spring Boot 多模块项目

多模块项目

父 POM

为什么我们需要多模块项目

子模块-ear, war, 和 jar

Maven 子项目/模块

多模块项目目录结构

Spring Boot 多模块项目示例

POM Aggregator (Parent POM)

相关帖子

Spring Boot Starter Parent

Spring Boot Actuator

Spring Boot Starter Test

Spring Boot 自动配置

Spring Boot DevTools

Spring Boot 注解

Spring Boot 打包

Spring Boot 启动器

Spring Boot 应用程序属性

Spring Boot Starter Web

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器