English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
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 communes和 Les 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 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.
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.
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.
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.
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: emballage和 module.
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.
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, vues和 Ressources.
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.
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.
<?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
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.