SpringBoot教程-Spring Boot 多模块项目
Spring Boot 多模块项目
Spring Boot 多模块项目 多模块项目是一个包含嵌套 Maven 项目的 Spring Boot 项目。在多模块项目中，父项目充当了基本 Maven 配置的容器。
换句话说，多模块项目是由一个父 POM 引用一个或多个子模块来构建的。父 Maven 项目必须包含打包类型为 pom 的配置，以使其成为聚合器。父项目的 pom.xml 文件包含了所有模块、共享依赖和属性的列表，这些都会被子项目继承。父 POM 位于项目的根目录。子模块是实际的 Spring Boot 项目，它们继承了来自父项目的 Maven 属性。
当我们运行多模块项目时，所有模块都会一起部署在嵌入式 Tomcat 服务器上。我们也可以单独部署某个模块。
父 POM
父 POM 定义了 Group ID、Artifact ID、版本和打包类型。在之前的 Maven 项目中，我们见过父 POM 定义的打包类型是 jar。但在多模块项目中，父 POM 定义的是 pom 打包类型，用来引用其他 Maven 项目。
为什么我们需要多模块项目
将项目拆分为多个模块有利于维护。我们可以轻松地编辑或删除项目中的某些模块，而不会影响其他模块。当需要单独部署某个模块时，这样的项目结构也很有用。
我们只需要在父 POM 中指定所有依赖项。所有其他模块都共享同一个 POM，因此不需要在每个模块中单独指定相同的依赖项。这样可以让代码在大型项目中更容易维护。
子模块 - EAR、WAR 和 JAR
子模块可以是任何类型的项目，并且可以有任何打包类型。我们可以在模块之间自由地创建任何类型的依赖关系和打包组合。
例如，我们可以创建一个 EAR（企业存档）、WAR（Web 存档）和 JAR（Java 存档）文件。一个 JAR 文件被打包进一个 WAR 文件，然后 WAR 文件被打包进一个 EAR 文件。最终的 EAR 文件是准备部署在应用服务器上的包。
EAR 文件包含一个或多个 WAR 文件。每个 WAR 文件包含服务项目，其中包含对所有 WAR 文件共享的代码，并使用 JAR 打包类型。
Spring Boot 多模块项目 Maven 子项目 / 模块
子模块是独立的 Maven 项目，可以从父项目继承属性。 所有子项目可以通过单个命令构建，因为它们都在父项目中。 更容易定义项目之间的关系。
多模块项目的目录结构。
在下面的图片中，我们创建了一个名为 spring-boot-multi-module-project 的项目。它包含了位于目录底部的父 POM。之后，我们创建了两个 Maven 模块，分别命名为 module1 和 module2。这两个模块包含了各自的 pom 文件。
Spring Boot 多模块项目 让我们打开父 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>cn.javatiku</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 文件中将 packaging 配置为 pom，而不是 jar。
<packaging>pom</packaging>
当我们在项目中创建 Maven 模块时，Spring Boot 会自动在父 pom 中的 module 标签下配置这些模块，如下所示。
<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>cn.javatiku</groupId>
<artifactId>spring-boot-multi-module-project</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>cn.javatiku</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 项目，它是主应用程序。主应用程序中，我们创建了五个模块，如下所示：
1.application
2.model
3.repository
4.service-api
5.service-impl
应用程序模块（Application Module）
应用程序模块是项目的主要模块。它包含应用程序类，其中定义了运行 Spring Boot 应用程序所必需的 main 方法。它还包含应用程序配置属性、控制器、视图和资源。
应用程序模块包含了 Model 模块和 Service Implementation 模块作为依赖项，而这些模块本身又依赖于 Model 模块、Repository 模块和 Service API 模块。
模型模块（Model Module）
模型模块包含了在项目中使用的实体和视觉对象。
存储库模块（Repository Module）
存储库模块包含了在项目中使用的存储库。它依赖于 Model 模块。
服务 API 模块（Service API Module）
服务 API 模块包含了所有项目服务。它也依赖于 Model 模块。
服务实现模块（Service Implementation Module）
服务实现模块实现了服务。它依赖于 Repository 模块和 Service API 模块。
POM 聚合器（父 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：打开 application 模块的 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：创建一个名为 SampleWebJspApplication 的主类，这是要运行的类。
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：在包 sample.multimodule.web 下创建一个名为 WelcomeController 的控制器类。
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/resources/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：打开 repository 模块的 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.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 包下创建一个名为 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：在 sample.multimodule.service.api 包下创建一个名为 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 模块的目录结构如下所示：
现在让我们创建第五个模块，名为 service-impl。
步骤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 文件中配置在 module 标签内，我们无需手动配置。
现在确保所有五个模块都已创建，如下所示：
在创建了所有模块后，主项目目录如下所示：
步骤23：现在运行 SampleWebJspApplication.java 文件作为 Java 应用程序。
步骤24：打开浏览器并访问 URL http://localhost:8080。它会返回消息和账户号码为 23。
