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

Projet multi-modulaire SpringBoot

Multi-Projet Module

Les projets Spring Boot contenant des projets Maven imbriqués sont appelés Projet multimodule. Dans un projet multimodule, le projet principal joue le rôle de conteneur de configuration Maven de base.

Autrement dit Projet multimoduleIl est construit à partir d'un POM principal qui gère un ensemble de sous-modules. Ou Projet multimoduleRéférencé par le POM principal pour définir un ou plusieurs sous-modules.

Le projet Maven principal doit contenir pom Le type d'emballage rend ce projet un aggregateur. Le projet principal pom.xml Le fichier contient toutes les dépendances héritées par les sous-projets Les modules, les dépendances communesLes propriétésLa liste. Le pom principal est situé dans le répertoire racine du projet. Les modules secondaires sont des projets Spring Boot réels, ils héritent des propriétés Maven du projet principal.

Lorsque nous exécutons un projet à modules multiples, tous les modules sont déployés ensemble sur le serveur Tomcat intégré. Nous pouvons également déployer un module individuel.

Le pom parent

Le pom parent définit ID de groupe, ID d'artefact, version, et packaging.. Dans les projets Maven précédents, nous avons vu que le parent POM définissait le paquetage jar.. Mais dans un projet à modules multiples, le parent POM Définir le pom de paquetage. Le pom de paquetage fait référence à d'autres projets Maven.

Pourquoi avons-nous besoin de projets à modules multiples

Diviser un projet en plusieurs modules est utile et facile à maintenir. Nous pouvons également facilement éditer ou supprimer des modules dans le projet sans affecter les autres modules. Cela est utile lorsque nous devons déployer séparément les modules.

Nous devons simplement spécifier toutes les dépendances dans le pom parent. Tous les autres modules partagent le même pom, donc nous n'avons pas besoin de spécifier les mêmes dépendances dans chaque module.

sous-module-ear, war et jar

Les sous-modules peuvent être n'importe quel projet et peuvent avoir n'importe quel type de paquetage. Nous pouvons créer librement toutes sortes de dépendances entre les modules et les ensembles.

Par exemple, nous créons EAR (archive d'entreprise), WAR (Web ARchive) et JAR (Java ARchive) fichiers. Les fichiers JAR sont liés aux fichiers WAR, et les fichiers WAR sont liés aux fichiers EAR. Les fichiers EAR sont des paquets logiciels finaux qui peuvent être déployés sur un serveur d'application.

Les fichiers EAR contiennent un ou plusieurs fichiers WAR. Chaque fichier WAR contient un projet de service, ce projet a du code commun pour tous les fichiers WAR et les types de paquetage dans le JAR.

Projet Maven sous-module/le module

Les sous-modules sont des projets Maven indépendants, ils partagent les propriétés du projet parent. Tous les sous-projets peuvent être construits avec une seule commande, car ils se trouvent dans le projet parent. Il est plus facile de définir les relations entre les projets.

Structure de répertoire d'un projet à modules multiples

Laissez-nous comprendre la structure de répertoire d'un projet à modules multiples.

Dans l'image suivante, nous avons créé un nommé spring-boot-multi-module-project projet qui contient le parent pom Après cela, nous avons créé deux Maven模块et sont nommés module1 module2 Ces deux modules contiennent leurs propres fichiers pom.

Laissez-nous ouvrir le POM parent et examiner la configuration lors de la création d'un module Maven dans le projet.

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

Le fichier pom ci-dessus est le même que dans l'exemple précédent. Mais dans ce cas pom Dans le fichier de package, il faut noter deux choses: emballagemodule.

Lorsque nous créons un projet avec plusieurs modules, nous devons configurer le packaging pom dans le fichier parent pom, au lieu de jar.

<packaging>pom/packaging>

Lorsque nous créons un module Maven dans le projet, Spring Boot le fait dans module le module automatiquement configuré dans le parent pom à l'intérieur de l'étiquette, comme suit.

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

Maintenant, nous allons examiner module1le contenu du fichier pom de ce projet.

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>

Il est à noter ici que le fichier POM mentionné précédemment ne contient pas telles que starter-web, web-mvc, etc.Les dépendances communes telles que Parent POM.

Exemple de projet multimodulaire Spring Boot

Laissez-nous créer un exemple d'application multimodulaire.

Dans les exemples suivants, nous avons créé un projet nommé spring-boot-projet Maven multimodule.Ceci est l'application principale. Dans l'application principale, nous avons crééCinqLes modules, tels que montrés ci-dessous: Application Modèle Dépôt service-api service-impl

Module d'application

Le module d'application est le module principal du projet. Il contient les classes de l'application, dans lesquelles le main method nécessaire pour exécuter l'application Spring Boot est définie. Il contient également Propriétés de configuration de l'application, contrôleurs, vuesRessources.

Le module d'application inclut le module modèle, le module d'implémentation du service en tant que module de dépendance contenant le modèle, le module de dépôt et le module API de service.

Module modèle

Le module modèle contient Entitéet ceux utilisés dans le projet Visual Objects .

Module de dépôt

Le module de dépôt contient <Les éléments utilisés dans le projet>  Dépôt. Cela dépend du module modèle.

Module API de service

Le module API de service contient toutes les projets Service.Cela dépend également du module modèle.

Module d'implémentation du service

Le module d'implémentation du service peut implémenter le service. Cela dépend du module de dépôt et du module API de service.

Aggrégateur POM (parent POM)

Le parent POM contient tous les modules de l'application. Il inclut également toutes les dépendances et propriétés communes nécessaires pour un module de plus d'un type. Comme le projet a défini Spring IO Platform en tant que parent, les dépendances ne sont pas définies avec une version.

Laissez-nous comprendre la structure de l'application multimodulaire que nous avons créée.

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

Étape1: 创建一个名为 spring-boot-multimodule的 Maven項目.

Étape2: Ouvrir pom.xml 文件 (parent pom),並將打包類型 jar 更改為 pom.  

pom.xml (parent 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模块。

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

Étape4: Ouvrir le module application   pom.xml et assurez-vous que le type de paquetage est   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>
      <!-- Modules de projet -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.service.impl</artifactId>
        <version>${project.version}</version>
      </dependency>
      <!-- Dépendances 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>
 

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

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

Étape6: dans le paquet   smaple.multimodule.web。

créer un nom de   WelocameController 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:Bonjour Monde}")
    private String message = "Bonjour Monde";
    @Autowired
    protected AccountService accountService;
    @RequestMapping("/")
    public String welcome(Map<String, Object> model) 
    {
        //essaie d'obtenir23compte n°
        Account account = accountService.findOne("23");
        if(account == null){
            //Si il y a une problème lors de la création du compte,retournez l'affichage de l'état d'erreur
            model.put("message", "Erreur lors de l'obtention du compte!");
            model.put("account", "");
            return "welcome"}/show";
        }  
        //affichage23vue d'information du compte
        String accountInfo = "Votre numéro de compte est ".concat(account.getNumber());
        model.put("message", this.message);
        model.put("account", accountInfo);
        return "welcome"}/show";
    }
    @RequestMapping("foo")
    public String foo(Map<String, Object> model) {
        lancer une RuntimeException("Foo");
    }
}
 

Le7Étape: : Dans le dossier   src/main/créez un fichier nommé 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>Message: </b>
      <span th:text="${message}" />
    </div>
    <div>
      <b>Votre compte: </b>
      <span th:text="${account}" />
    </div>
</body>
</html>
 

Étape8: Ouvrir   application.properties le fichier, puis  message de l'application和  thymeleafLa configuration du cache est  Non.

application.properties

# Information de l'application
application.message = Hello User!
dummy.type = type-inside-the-war
# Configuration de Spring Thymeleaf
spring.thymeleaf.cache = false
 

Après avoir créé tous les fichiers ci-dessus, le répertoire du module de l'application est le suivant:

Laissez-nous créer un deuxième module, à savoir   model.

Étape9: Créer un   Module Maven,nommé   model.

Étape10: Ouvrir le modèle   pom.xml Module de fichier, et assurez-vous que le type d'emballage est   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 - Modèle</name>
    Module qui contient toutes les Entités et les Objets Visuels à utiliser dans le projet. Il n'a aucune dépendance. 
    </description>
</project>
 

Étape11: dans le paquet   sample.multimodule.domain.entity。

créer un nom de Account de la 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;
    /**
     * Créer un compte vide.
     */
    public Account() {
    }
    
    /**
     * Créer un nouveau compte.
     * 
     * @param number
     *            le numéro de compte
     * @param id
     *            l'identifiant du compte
     */
    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;
    }
}
 

Après avoir créé tous les fichiers mentionnés ci-dessus, le répertoire du module modèle est le suivant:

Créons   troisième le module

Étape12: 创建一个名为   du dépôt Maven模块. strong>

Étape13: Ouvrir le module application   pom.xml et assurez-vous que le type de paquetage est   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 - Dépôt</name>
    <description>Module qui contient tous les dépôts à utiliser dans le projet. Dépend du Module Modèle.</description>
    <dependencies>
      <!-- Modules de projet -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
      <!-- Dépendances Spring Boot -->
      <dependency>
        <groupId>org.hsqldb</groupId>
        <artifactId>hsqldb</artifactId>
        <scope>runtime</scope>
      </dependency>
    </dependencies>
    
</project>
 

Étape14: dans le paquet   sample.multimodule.repository

创建一个名称为   AccountRepository de la 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);
}
 

Après avoir créé tous les fichiers mentionnés ci-dessus, le répertoire du module dépôt est le suivant:

Créons  quatrièmele module, qui est   service-de l'API.

Étape15: 创建一个名为   service-de l'API Maven模块.

Étape16 : Ouvrir l'applicationservice-dans le fichier pom.xml de l'API et assurez-vous que le type de paquetage est   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 Service</name>
    <description>Module qui contient l'API de tous les services du projet. Dépend du Module Modèle.</description>
    <dependencies>
      <!-- Project Modules -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies> 
</project>
 

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

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

Étape19: 创建一个名为   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模块目录如下所示:

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

Étape21: : 打开应用程序   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 qui contient les implémentations de services définis sur le module Service API. Dépend du module Repository et du module 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>
 

Étape22: dans le paquet   sample.multimodule.service.impl。

créer un nom de AccountServiceImpl de la 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éthode dummy pour des fins de test.
     * 
     * @param number Le numéro de compte. Définir 0000 pour obtenir un {@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;
    }
}
 

Après avoir créé tous les fichiers ci-dessus,   service-impl Le répertoire du module est le suivant:

Maintenant, ouvrez  fichier parent pom Nous voyons tous les modules Maven créés dans  dans le fichier parent pomÉtiquette. Nous n'avons pas besoin de le configurer manuellement.

Maintenant, assurez-vous que tous les cinq modules ont été installés et créés, comme suit:

Après la création de tous les modules, le répertoire principal du projet est le suivant:

Étape23: Maintenant, mettez   SampleWebJspApplication.java Exécutez le fichier en tant qu'application Java.

Étape24: Ouvrez un navigateur et appellez l'URL http: //localhost: 8080. Il retourne  messageet le compte   23.