English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriales de SpringBoot

Proyectos de múltiples módulos de SpringBoot

Multi-Proyecto de módulo

El proyecto de Spring Boot que contiene proyectos Maven anidados se llama Proyecto de múltiples módulos. En el proyecto de múltiples módulos, el proyecto padre actúa como contenedor de la configuración base de Maven.

En otras palabras, Proyecto de múltiples módulosSe construye a partir de un pom que gestiona un grupo de módulos hijos. O Proyecto de múltiples módulosSe refiere a uno o más módulos hijos del POM padre para definir.

El proyecto maven padre debe contener pom El tipo de paquete hace que este proyecto sea un aggregador. El proyecto pom.xml El archivo contiene todas las dependencias heredadas por los subproyectos Módulos, dependencias comunes和 PropiedadesLa lista. El pom padre se encuentra en el directorio raíz del proyecto. Los módulos hijos son proyectos de Spring Boot reales, que heredan las propiedades Maven del proyecto padre.

Cuando ejecutamos proyectos de múltiples módulos, todos los módulos se despliegan juntos en el servidor de Tomcat integrado. También podemos desplegar módulos individuales.

POM superior

POM superior define ID de grupo, ID de artefacto, versión，y empaquetado。。En proyectos Maven anteriores, ya hemos visto que el nivel superior POM define el embalaje jar.。Pero en proyectos de múltiples módulos, el nivel superior POM Definir el POM de embalaje. El POM de embalaje hace referencia a otros proyectos Maven.

Por qué necesitamos proyectos de múltiples módulos

Dividir el proyecto en varios módulos es útil y fácil de mantener. También podemos editar o eliminar fácilmente los módulos del proyecto sin afectar a otros módulos. Esto es útil cuando necesitamos desplegar módulos por separado.

Solo necesitamos especificar todas las dependencias en el POM padre. Todos los otros módulos comparten el mismo POM, por lo que no es necesario especificar las dependencias idénticas en cada módulo.

submódulo-ear, war y jar

Los submódulos pueden ser cualquier proyecto y pueden tener cualquier embalaje. Podemos crear libremente cualquier tipo de dependencia entre módulos y paquetes.

por ejemplo, estamos creando EAR (archivo de archivo empresarial), WAR (Web ARchive) y JAR (Java ARchive) archivo. El archivo JAR se une al archivo WAR, y el archivo WAR se une al archivo EAR. El archivo EAR es el paquete final que se puede desplegar en el servidor de aplicaciones.

El archivo EAR contiene uno o más archivos WAR. Cada archivo WAR contiene un proyecto de servicio, que tiene código común para todos los archivos WAR y tipos de empaquetado en el JAR.

Maven子项目/módulo

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

多模块项目目录结构

让我们了解多模块项目目录结构。

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

Vamos a abrir el POM padre y ver la configuración cuando se crea el módulo Maven en el proyecto.

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/>　<!--　buscar el padre desde el repositorio　-->
</parent>
<groupId>com.w3codebox</groupId>
<artifactId>spring-boot-ejemplo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring<-boot-multi-module-project</name>
<description>Proyecto de demostración para 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>

El archivo pom superior es idéntico al ejemplo anterior. Pero en este pom en el archivo, hay dos cosas que debemos tener en cuenta: empaquetado和 módulo.

Cuando creamos proyectos de múltiples módulos, necesitamos configurar el pom de paquete en el archivo pom padre, en lugar de jar. 

<packaging>pom</packaging>

Cuando creamos módulos Maven en el proyecto, Spring Boot lo hace en module la configuración automática del módulo en el pom padre de la etiqueta, como se muestra a continuación.

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

Ahora, vamos a ver module1del contenido del archivo 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.w3codebox</groupId>
<artifactId>spring-boot-multi-module-project</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>com.w3codebox</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>
junitjunit

在此处，需要注意的是，上述pom文件不包含诸如 starter-web，web-mvc等之类的公共依赖项。它继承了所有公共依赖项和属性 父pom。

Spring Boot多模块项目示例

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

在以下示例中，我们创建了一个名为 spring-boot-multimodule的maven项目。这是主要应用程序。在主应用程序中，我们创建了五个模块，如下所示: 应用 模型 存储库 Después de crear todos los archivos anteriores,-api Después de crear todos los archivos anteriores,-service

应用程序模块

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

应用程序模块包括模型模块，服务实现模块作为包含模型的依赖项模块，存储库模块和服务API模块。

模型模块

模型模块包含 实体和在项目中使用的 Visual Objects .

存储库模块

存储库模块包含 <在项目中使用的strong> 　存储库。它取决于模型模块。

服务API模块

服务API模块包含所有项目 服务。这也取决于模型模块。

服务实现模块

服务实现模块可以实现服务。它取决于存储库模块和服务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-service　　
　　　　│──  pom.xml　　
　　　　└──  src　　
　　　　　　　　└──  main　　
　　　　　　　　　　　　└──  java　　
　　　　　　　　　　　　　　　　└──  sample　　
　　　　　　　　　　　　　　　　　　　　└──  multimodule　　
　　　　　　　　　　　　　　　　　　　　　　　　└──  service　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　└──  impl　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　└──  AccountServiceImpl.java

Pasos1: 创建一个名为 spring-boot-multimódulo proyecto Maven.

Pasos2: Abra pom.xml archivo (padre pom) y cambiar el tipo de embalaje jar cambiar a pom. 　

pom.xml (padre 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>
<!--　Springio 平台是生成的应用程序的父应用程序，能够使用 Spring Boot 及其所有默认配置　-->
<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 依赖　-->
<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模块。

Pasos3: 创建一个名为 　 application的 Maven模块 .

Pasos4: Abre el módulo de aplicación 　 pom.xml el archivo y asegúrate de que el tipo de paquete sea 　 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>
　　　　　　<!--　Módulos del proyecto　-->
　　　　　　<dependency>
　　　　　　　　<groupId>sample.multimodule</groupId>
　　　　　　　　<artifactId>sample.multimodule.service.impl</artifactId>
　　　　　　　　<version>${project.version}</version>
　　　　　　</dependency>
　　　　　　<!--　Dependencias de Spring Boot　-->
　　　　　　　　　　<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>
　

Pasos5: 创建 　主要这是一个类。这是要运行的类。

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);
　　　　this.dummyType = dummyType;
this.dummyType = dummyType;
　

Pasos6: en el paquete 　 smaple.multimodule.web。

se crea una instancia de nombre 　 WelocameController la　clase　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:Hola　Mundo}")
　　　　private　String　message　=　"Hola　Mundo";
　　　　@Autowired
　　　　protected　AccountService　accountService;
　　　　@RequestMapping("/")
　　　　public　String　welcome(Map<String,　Object>　model)　
　　　　{
　　　　　　　　//intenta　obtener23número de　cuenta
　　　　　　　　Account　account　=　accountService.findOne("23");
　　　　　　　　if(account == null){
　　　　　　　　　　　　//Si ocurre un problema al crear la cuenta，devuelve　la　vista　del　estado de error
　　　　　　　　　　　　model.put("message",　"¡Error al obtener la　cuenta!");
　　　　　　　　　　　　model.put("account",　"");
　　　　　　　　　　　　return "welcome"}/show";
　　　　　　　　this.dummyType = dummyType;　　
　　　　　　　　//devolver　mostrar23vista　de　información　de　cuenta
　　　　　　　　String　accountInfo　=　"Tu　número　de　cuenta　es　".concat(account.getNumber());
　　　　　　　　model.put("message",　this.message);
　　　　　　　　model.put("account",　accountInfo);
　　　　　　　　return "welcome"}/show";
　　　　this.dummyType = dummyType;
　　　　@RequestMapping("foo")
　　　　public String foo(Map<String, Object> model) {
　　　　　　　　throw new RuntimeException("Foo");
　　　　this.dummyType = dummyType;
this.dummyType = dummyType;
　

El7Paso: : En la carpeta 　 src/main/Cree un archivo llamado show.html 的 HTML templates ->bienvenido。

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>Mensaje: </b>
　　　　　　<span th:text="${message}"　/>
　　　　</div>
　　　　<div>
　　　　　　<b>Su cuenta: </b>
　　　　　　<span th:text="${account}"　/>
　　　　</div>
</body>
</html>
　

Pasos8: Abra 　 application.properties El archivo, y luego 　application message和 　thymeleafLa configuración de la caché se establece en 　No.

application.properties 

#Información de la aplicación
application.message = ¡Hola Usuario!
dummy.type = type-inside-the-war
#Configuración de Spring Thymeleaf
spring.thymeleaf.cache = false
　

Después de crear todos los archivos mencionados anteriormente, la carpeta del módulo de aplicación se verá así:

Vamos a crear el segundo módulo, es decir 　 model。

Pasos9: Cree un 　 Maven Module，con el nombre de 　 model。

Pasos10: Abra el modelo 　 pom.xml Módulo de archivo, y asegúrese de que el tipo de paquete sea 　 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>
　　　　Módulo que contiene todas las Entidades y Objetos Visuales que se utilizarán en el proyecto. No tiene ninguna dependencia.　
　　　　</description>
</project>
　

Pasos11: en el paquete 　 sample.multimodule.domain.entity.

se crea una instancia de nombre Account la clase.

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() {
　　　　this.dummyType = dummyType;
　　　　
　　　　/**
　　　　　*　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;
　　　　this.dummyType = dummyType;
　　　　public long getId() {
　　　　　　　　return id;
　　　　this.dummyType = dummyType;
　　　　public void setId(long id) {
　　　　　　　　this.id = id;
　　　　this.dummyType = dummyType;
　　　　public String getNumber() {
　　　　　　　　return number;
　　　　this.dummyType = dummyType;
　　　　public void setNumber(String number) {
　　　　　　　　this.number = number;
　　　　this.dummyType = dummyType;
　　　　public String getType() {
　　　　　　　　return type;
　　　　this.dummyType = dummyType;
　　　　public void setType(String type) {
　　　　　　　　this.type = type;
　　　　this.dummyType = dummyType;
　　　　public String getCreditCardNumber() {
　　　　　　　　return creditCardNumber;
　　　　this.dummyType = dummyType;
　　　　public void setCreditCardNumber(String creditCardNumber) {
　　　　　　　　this.creditCardNumber = creditCardNumber;
　　　　this.dummyType = dummyType;
this.dummyType = dummyType;
　

Después de crear todos los archivos mencionados anteriormente, la estructura del directorio del módulo de modelo es la siguiente:

Vamos a crear 　 tercer módulo

Pasos12: 创建一个名为 　 repositorio Maven模块. <strong>

Pasos13: Abre el módulo de aplicación 　 pom.xml el archivo y asegúrate de que el tipo de paquete sea 　 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　-　Repositorio</name>
　　　　<description>Módulo que contiene todos los repositorios que se utilizarán en el proyecto. Dependiente del Módulo de Modelo.</description>
　　　　<dependencies>
　　　　　　<!--　Módulos del proyecto　-->
　　　　　　<dependency>
　　　　　　　　<groupId>sample.multimodule</groupId>
　　　　　　　　<artifactId>sample.multimodule.model</artifactId>
　　　　　　　　<version>${project.version}</version>
　　　　　　</dependency>
　　　　　　<!--　Dependencias de Spring Boot　-->
　　　　　　<dependency>
　　　　　　　　<groupId>org.hsqldb</groupId>
　　　　　　　　<artifactId>hsqldb</artifactId>
　　　　　　　　<scope>runtime</scope>
　　　　　　</dependency>
　　　　</dependencies>
　　　　
</project>
　

Pasos14: en el paquete 　 sample.multimodule.repository

创建一个名称为 　 AccountRepository la clase. 　
　 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);
this.dummyType = dummyType;
　

Después de crear todos los archivos mencionados anteriormente, la estructura del directorio del módulo de repositorio es la siguiente:

Vamos a crear 　cuartoel módulo, que es 　 Después de crear todos los archivos anteriores,-api.

Pasos15: 创建一个名为 　 Después de crear todos los archivos anteriores,-api Maven模块.

Pasos16 : Abre la aplicaciónDespués de crear todos los archivos anteriores,-el archivo pom.xml de api y asegúrate de que el tipo de paquete sea 　 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　-　API de Servicio</name>
　　　　<description>Module que contiene la API de todos los servicios del proyecto. Dependiente del Módulo de Modelo.</description>
　　　　<dependencies>
　　　　　　<!--　Project Modules　-->
　　　　　　<dependency>
　　　　　　　　<groupId>sample.multimodule</groupId>
　　　　　　　　<artifactId>sample.multimodule.model</artifactId>
　　　　　　　　<version>${project.version}</version>
　　　　　　</dependency>
　　　　</dependencies>　
</project>
　

Pasos17: 创建名称为 　 sample.multimodule.service.api的软件包。

Pasos18: 创建一个名称为 　 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);
　　　　this.dummyType = dummyType;
this.dummyType = dummyType;
　

Pasos19: 创建一个名为 　 AccountService的类。它提供与帐户相关的服务，例如 　查找和 　创建帐户。

AccountService.java 

package sample.multimodule.service.api;
import java.util.List;
import sample.multimodule.domain.entity.Account;
public interface AccountService　
{
　　　　/**
　　　　　*　使用提供的帐号查找帐户。
　　　　　*　
　　　　　*　@param number The account number
　　　　　*　@return The account
　　　　　*　@throws AccountNotFoundException if no such account exists.
　　　　　*/
　　　　Account findOne(String number) throws AccountNotFoundException;
　　　　/**
　　　　　*　创建一个新的帐户。
　　　　　*　@param number
　　　　　*　@return created account
　　　　　*/
　　　　Account createAccountByNumber(String number);
this.dummyType = dummyType;
　

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

Pasos20: 创建一个名为 　 Después de crear todos los archivos anteriores,-impl的 Maven模块.

Pasos21: : 打开应用程序 　 Después de crear todos los archivos anteriores,-service 的 　 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>
　

Pasos22: en el paquete 　 sample.multimodule.service.impl。

se crea una instancia de nombre AccountServiceImpl la clase.

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}　
　　　　　*/
　　　　return account;
　　　　public Account findOne(String number) throws AccountNotFoundException {
　　　　　　　　if(number.equals("0000")) {
　　　　　　　　　　　　throw new AccountNotFoundException("0000");
　　　　　　　　this.dummyType = dummyType;
　　　　　　　　Account account = accountRepository.findByNumber(number);
　　　　　　　　if(account == null){
　　　　　　　　　　account = createAccountByNumber(number);
　　　　　　　　this.dummyType = dummyType;
　　　　　　　　return　account;
　　　　this.dummyType = dummyType;
　　　　return account;
　　　　@Override
　　　　　　　　public Account createAccountByNumber(String number) {
　　　　　　　　Account account = new Account();
　　　　　　　　account.setNumber(number);
　　　　this.dummyType = dummyType;
　　　　return accountRepository.save(account);
　　　　　　　　public String getDummyType() {
　　　　this.dummyType = dummyType;
　　　　return dummyType;
　　　　　　　　public void setDummyType(String dummyType) {
　　　　this.dummyType = dummyType;
this.dummyType = dummyType;
　

} 　 Después de crear todos los archivos anteriores,-service impl

el directorio del módulo, como se muestra a continuación: 　Ahora abra en el archivo pom padre 　Vemos que todos los módulos Maven creados están enen el archivo pom padre

Etiqueta. No necesitamos configurarlo manualmente.

Ahora asegúrese de que todos los cinco módulos se hayan instalado y creado, como se muestra a continuación:

Pasos23: Ahora, asegúrese de que todos los módulos se hayan creado después de la creación, como se muestra a continuación: 　 SampleWebJspApplication.java Ejecutar el archivo como aplicación Java.

Pasos24: Abra el navegador y llame a la URL http: //localhost: 8080. Regresa 　mensajesy la cuenta de 　 23.

Empaquetado de SpringBootDevTools de SpringBoot