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

Projeto multi-módulo SpringBoot

Multi-Module project

A Spring Boot project that contains nested Maven projects is called Multi-module project. In a multi-module project, the parent project acts as a container for the basic Maven configuration.

In other words, Multi-module projectIt is built from a parent pom that manages a set of submodules. Or Multi-module projectReferenced by the parent POM to define one or more submodules.

The parent Maven project must include pom The packaging type makes this project an aggregator. The parent project's pom.xml The file includes all the properties inherited by the subproject Module, common dependenciesPropertiesThe list. The parent pom is located in the root directory of the project. The submodules are actual Spring Boot projects, which inherit Maven properties from the parent project.

Quando executamos o projeto multi-modular, todos os módulos são implantados juntos no servidor Tomcat embutido. Também podemos implantar módulos individuais.

POM pai

POM pai define ID de grupo, ID de artefato, versãoe empacotamento.No entanto, no projeto Maven anterior, já vimos que o nível superior POM define o empacotamento jar.No entanto, no projeto multi-modular, o nível superior POM Definir o pom de empacotamento. O pom de empacotamento faz referência a outros projetos Maven.

Por que precisamos de projetos multi-modulares

Dividir o projeto em vários módulos é útil e fácil de manter. Também podemos editar ou excluir módulos no projeto sem afetar outros módulos. Isso é útil quando precisamos implantar módulos separadamente.

Precisamos apenas especificar todas as dependências no pom pai. Todos os outros módulos compartilham o mesmo pom, portanto, não precisamos especificar as mesmas dependências em cada módulo.

submódulos-ear, war e jar

Os submódulos podem ser qualquer projeto e podem ter qualquer pacote. Podemos criar dependências de qualquer tipo entre módulos e pacotes.

Por exemplo, estamos criando EAR (arquivo de arquivo empresarial), WAR (Web ARchive) e JAR (Java ARchive) arquivo. O arquivo JAR é empacotado no arquivo WAR, e o arquivo WAR é empacotado no arquivo EAR. O arquivo EAR é o pacote final que pode ser implantado no servidor de aplicativos.

O arquivo EAR contém um ou mais arquivos WAR. Cada arquivo WAR contém um projeto de serviço, que possui código genérico para todos os arquivos WAR e tipos de empacotamento no JAR.

Subprojeto Maven/módulo

Os submódulos são projetos Maven independentes, compartilhando as propriedades do projeto pai. Todos os subprojetos podem ser construídos com um único comando, pois estão localizados no projeto pai. é mais fácil definir as relações entre os projetos.

Estrutura de diretórios de projetos multi-modulares

Vamos entender a estrutura de diretórios de projetos multi-modulares.

Nesta figura, criamos um chamado spring-boot-multi-module-project projetos que contêm o pai pom Depois disso, criamos dois Maven模块Eles são nomeados respectivamente module1 module2 Esses dois módulos contêm seus próprios arquivos pom.

Vamos abrir o POM pai e verificar a configuração ao criar o módulo Maven no projeto.

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.w3codebox</groupId>
<artifactId>spring-boot-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-multi-module-project</name>
<description>Projeto de exemplo 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>

O arquivo pom acima é o mesmo que o exemplo anterior. Mas neste pom no arquivo, precisamos prestar atenção a duas coisas: empacotamentomódulo.

Quando criamos projetos de múltiplos módulos, precisamos configurar o pacote pom no arquivo pai pom, em vez de jar.

<packaging>pom</packaging>

Quando criamos módulos Maven no projeto, o Spring Boot configura automaticamente module etiquetas do pai pom configurando automaticamente o módulo, conforme mostrado a seguir.

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

Agora, vamos verificar module1o conteúdo do arquivo 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>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Aqui, é importante notar que o arquivo pom mencionado acima não contém starter-web, web-MVC e outrosEtc. dependências públicas. Ele herda todas as dependências e propriedades públicas POM pai.

Exemplo de projeto Spring Boot multimódulo

Vamos criar um exemplo de aplicação multimódulo.

Neste exemplo, criamos um aplicativo chamado spring-boot-projeto Maven multimodule.Este é o aplicativo principal. No aplicativo principal, criamosCincoMódulos, conforme mostrado a seguir: Aplicação Modelo Repositório service-api service-impl

Módulo de aplicação

O módulo de aplicação é o módulo principal do projeto. Ele contém a classe da aplicação, onde é definido o método main necessário para executar a aplicação Spring Boot. Ele também contém Propriedades de configuração da aplicação, controladores, vistasRecursos.

O módulo de aplicação inclui o módulo de modelo, o módulo de implementação de serviço como dependência que contém o modelo, o módulo de repositório e o módulo de API de serviço.

Módulo de modelo

O módulo de modelo contém Entidadese os usados no projeto Objetos Visuais .

Módulo de repositório

O módulo de repositório contém <No projeto usado>  Repositório. Ele depende do módulo de modelo.

Módulo de API de serviço

O módulo de API de serviço contém todas as Serviço.Também depende do módulo de modelo.

Módulo de implementação de serviço

O módulo de implementação de serviço pode implementar serviços. Ele depende do módulo de repositório e do módulo de API de serviço.

Agregador POM (POM pai)

O POM pai contém todos os módulos da aplicação. Ele também inclui todas as dependências e propriedades comuns necessárias por mais de um módulo. Como o projeto definiu o Spring IO Platform como pai, as dependências não têm versão definida.

Vamos entender a estrutura da aplicação multimódulo que criamos.

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

Passos1: 创建一个名为 spring-boot-multimodule projeto Maven.

Passos2: Abra pom.xml arquivo pom (pai pom) e alterar o tipo de pacote jar alterar para pom.  

pom.xml (pai 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>
 

注意一件事,由于尚未创建Maven模块,因此未配置。现在,我们将如上所述创建一个Maven模块。

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

Passos4: Abra o módulo do aplicativo   pom.xml o arquivo, e certifique-se de que o tipo de pacote seja   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 do projeto -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.service.impl</artifactId>
        <version>${project.version}</version>
      </dependency>
      <!-- Dependências do 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>
 

Passos5: 创建  主要这是运行的类。

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);
    }
}
 

Passos6: No pacote   smaple.multimodule.web。

Criar um nome de   WelocameController a classe 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) 
    {
        //tentando obter23número de conta
        Account account = accountService.findOne("23");
        if(account == null){
            //Se houver problemas ao criar a conta, retorne a visão do estado de erro
            model.put("message", "Erro ao obter conta!");
            model.put("account", "");
            return "welcome"}/show";
        }  
        //retornar exibição23visão de informações de conta
        String accountInfo = "Seu número de conta é " + 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");
    }
}
 

o7Passo: : No diretório   src/main/crie um arquivo chamado show.html HTML templates ->welcome。

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

Passos8: Abra   application.properties o arquivo, abra  mensagem do aplicativo和  thymeleafA configuração do cache é  Não.

application.properties

#Informações do aplicativo
application.message = Hello User!
dummy.type = type-dentro-o-war
#Configuração do Spring Thymeleaf
spring.thymeleaf.cache = false
 

Após criar todos os arquivos mencionados acima, a pasta do módulo do aplicativo será como segue:

Vamos criar o segundo módulo, ou seja   model。

Passos9: Crie um   Maven Module,o nome é   model。

Passos10: Abra o modelo   pom.xml Módulo de arquivo, e certifique-se de que o tipo de pacote seja   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 contém todas as Entidades e Objetos Visuais a serem usados no projeto. Não possui dependências. 
    </description>
</project>
 

Passos11: No pacote   sample.multimodule.domain.entity。

Criar um nome de Account da classe.

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;
    /**
     * Criar uma conta vazia.
     */
    public Account() {
    }
    
    /**
     * Criar uma nova conta.
     * 
     * @param number
     *            o número da conta
     * @param id
     *            a id da conta
     */
    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;
    }
}
 

Após criar todos os arquivos mencionados acima, a estrutura do diretório do módulo modelo será como follows:

Vamos criar   terceiro módulo

Passos12: 创建一个名为   do repositório Maven模块. <strong>

Passos13: Abra o módulo do aplicativo   pom.xml o arquivo, e certifique-se de que o tipo de pacote seja   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 - Repositório</name>
    <description>Módulo que contém todos os repositórios a serem usados no projeto. Dependendo do Módulo Modelo.</description>
    <dependencies>
      <!-- Módulos do projeto -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
      <!-- Dependências do Spring Boot -->
      <dependency>
        <groupId>org.hsqldb</groupId>
        <artifactId>hsqldb</artifactId>
        <scope>runtime</scope>
      </dependency>
    </dependencies>
    
</project>
 

Passos14: No pacote   sample.multimodule.repository

创建一个名称为   AccountRepository da classe.  
  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);
}
 

Após criar todos os arquivos mencionados acima, a estrutura do diretório do módulo repositório será como follows:

Vamos criar  quartomódulo, que é   service-do api.

Passos15: 创建一个名为   service-do api Maven模块.

Passos16 : Abra o <strong>aplicativoservice-no arquivo pom.xml do api, e certifique-se de que o tipo de pacote seja   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 Serviço</name>
    <description>Module que contém a API de todos os serviços do projeto. Dependendo do Módulo Modelo.</description>
    <dependencies>
      <!-- Project Modules -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies> 
</project>
 

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

Passos18: 创建一个名称为   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);
    }
}
 

Passos19: 创建一个名为   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;
    /**
     * Creates a new account.
     * @param number
     * @return created account
     */
    Account createAccountByNumber(String number);
}
 

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

Passos20: 创建一个名为   service-impl的 Maven模块.

Passos21: : 打开应用程序   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>Modulo que contém a implementação de serviços definida no módulo Service API. Dependendo do módulo Repository e Service API.</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>
 

Passos22: No pacote   sample.multimodule.service.impl。

Criar um nome de AccountServiceImpl da classe.

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/>
     * Método falso para fins de teste.
     * 
     * @param number O número da conta. Defina 0000 para obter um {@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;
    }
}
 

Após a criação de todos os arquivos mencionados acima,   service-impl o diretório do módulo, conforme mostrado a seguir:

Agora abra  pai pom arquivo, vemos que todos os módulos Maven criados estão em  no pai pomEtiqueta. Não precisamos configurá-lo manualmente.

Agora, certifique-se de que todos os cinco módulos foram instalados e criados, conforme mostrado a seguir:

Após a criação de todos os módulos, o diretório do projeto principal é o seguinte:

Passos23: Agora, vá para   SampleWebJspApplication.java Arquivo como aplicativo Java executável.

Passos24: Abra o navegador e chame a URL http: //localhost: 8080. Ela retorna  mensageme a conta é   23.