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

SpringBoot Multimodulprojekt

Multi-Modulprojekt

Spring Boot-Projekte, die eingebettete Maven-Projekte enthalten, werden als Multimodulare Projekt. Im multimodularen Projekt spielt der Parent-Projekt die Rolle des Containers für die grundlegende Maven-Konfiguration.

Mit anderen Worten, Multimodulare Projektwird aus einem Parent-POM, das eine Gruppe von Submodulen verwaltet, gebaut. Oder Multimodulare ProjektDurch Bezugnahme auf einen oder mehrere Submodule durch den Parent-POM definiert.

Der Parent-Maven-Projekt muss enthalten pom Das Verpackungstyp macht dieses Projekt zu einem Aggregator. Der Parent-Projekt pom.xml Die Datei enthält alle von den Subprojekten geerbten Module, gemeinsame AbhängigkeitenEigenschaftenListe. Der Parent-POM befindet sich im Stammverzeichnis des Projekts. Die Abhängigkeiten sind Module, die von dem Parent-Projekt geerbt werden.

Wenn wir ein mehrmodulares Projekt ausführen, werden alle Module gemeinsam auf dem eingebetteten Tomcat Server bereitgestellt. Wir können auch ein einzelnes Modul bereitstellen.

Übergeordnetes POM

Der übergeordnete POM definiert Gruppen-ID, Artefakt-ID, Version, und packaging.. In früheren Maven-Projekten haben wir gesehen, dass das übergeordnete POM das Verpackungspom definiert hat jar.. Aber in mehrmodularen Projekten ist der übergeordnete POM Definieren Sie das Verpackungspom. Das Verpackungspom verweist auf andere Maven-Projekte.

Warum brauchen wir mehrmodulare Projekte

Das Projekt in mehrere Module zu teilen ist nützlich und einfach zu warten. Wir können die Module im Projekt leicht bearbeiten oder löschen, ohne die anderen Module zu beeinflussen. Dies ist nützlich, wenn wir Module einzeln bereitstellen müssen.

Wir müssen nur alle Abhängigkeiten im übergeordneten pom angeben. Alle anderen Module teilen den gleichen pom, daher müssen wir die gleichen Abhängigkeiten in jedem Modul nicht separat angeben.

Untermodule-ear, war und jar

Die Untermodule können jeder Art von Projekt sein und jede Art von Verpackung haben. Wir können frei zwischen Modulen und Bündeln jede Art von Abhängigkeiten erstellen.

Zum Beispiel erstellen wir EAR (Unternehmensarchiv), WAR (Web ARchive) und JAR (Java ARchive) Dateien. Die JAR-Dateien werden mit den WAR-Dateien verbunden, und die WAR-Dateien werden mit den EAR-Dateien verbunden. EAR-Dateien sind die Endsoftwarepakete, die auf Anwendungsservern bereitgestellt werden können.

EAR-Dateien enthalten eine oder mehrere WAR-Dateien. Jede WAR-Datei enthält ein Service-Projekt, das auf die gemeinsamen Codes aller JAR- und Packungstypen in den WAR-Dateien zugreift.

Maven-Unterprojekte/Modul

Die Untermodule sind独立的maven项目,它们共享父项目的属性。 Alle Unterprojekte können mit einem Befehl gebaut werden, da sie sich im übergeordneten Projekt befinden. Es ist einfacher, die Beziehungen zwischen Projekten zu definieren.

Verzeichnisstruktur eines mehrmodularen Projekts

Lassen Sie uns die Verzeichnisstruktur eines mehrmodularen Projekts verstehen.

In der folgenden Abbildung erstellen wir ein Modul namens spring-boot-multi-module-project Projekte erstellt haben, enthält es am unteren Ende das übergeordnete pom Nachdem wir zwei Maven模块und heißen sie module1 module2 Diese beiden Module enthalten ihre eigenen pom-Dateien.

Lassen Sie uns das übergeordnete POM öffnen und die Konfiguration überprüfen, die beim Erstellen eines Maven-Moduls im Projekt verwendet wird.

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>

Die obige pom-Datei ist identisch mit dem obigen Beispiel. Aber in diesem pom In der Datei, beachten Sie zwei Dinge: VerpackungModul.

Wenn wir ein Projekt mit mehreren Modulen erstellen, müssen wir im Elternpom die Paketierung konfigurieren, nicht jar.

<packaging>pom</packaging>

Wenn wir Maven-Module in einem Projekt erstellen, konfiguriert Spring Boot module im Elternpom automatisch konfigurierte Module, wie folgt.

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

Nun werden wir überprüfen module1Inhalt der pom-Datei.

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>

Hier ist zu beachten, dass die obige pom-Datei keine Elemente wie starter-web, web-mvc und andereSolche gemeinsamen Abhängigkeiten wie Übergeordneter POM.

Beispiel für ein Spring Boot mehrmodulares Projekt

Lassen Sie uns ein Beispiel für eine mehrmodulare Anwendung erstellen.

In den folgenden Beispielen haben wir ein Projekt mit dem Namen erstellt spring-boot-multimodule Maven-Projekt.Dies ist das Hauptanwendung. In der Hauptanwendung haben wir erstelltFünfModule, wie folgt: Anwendung Modell Speicher service-api service-impl

Anwendungsmodule

Das Anwendungsmodule ist das Hauptmodul des Projekts. Es enthält die Anwendungsklasse, in der der main-Methode definiert ist, die für den Betrieb der Spring Boot Anwendung erforderlich ist. Es enthält auch Anwendungskonfigurationsattribute, Controller, AnsichtenRessourcen.

Das Anwendungsmodule umfasst das Modellmodul, das Service-Implementierungsmodul als Abhängigkeitsmodul, das Speichermodul und das Service-API-Modul.

Modellmodul

Das Modellmodul enthält Entitätenund in Projekten verwendete Visuelle Objekte .

Speichermodul

Das Speichermodul enthält <In Projekten verwendete strong>  Das Speichermodul. Es hängt vom Modellmodul ab.

Service-API-Modul

Das Service-API-Modul enthält alle Projekte Dienst.Es hängt auch von dem Modellmodul ab.

Service-Implementierungsmodul

Der Service-Implementierungsmodul kann Dienstleistungen implementieren. Es hängt von dem Speichermodul und dem Service-API-Modul ab.

POM-Aggregator (übergeordneter POM)

Der übergeordnete POM enthält alle Anwendungsmodule. Er enthält auch alle gemeinsamen Abhängigkeiten und Eigenschaften, die für einen oder mehrere Module erforderlich sind. Da das Projekt die Spring IO Platform als übergeordnetes Element definiert hat, werden die Abhängigkeiten ohne Versionsnummer definiert.

Lassen Sie uns die Struktur der mehrmodularen Anwendung, die wir erstellt haben, verstehen.

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

Schritte1: 创建一个名为 spring-boot-multimodule Maven-Projekt.

Schritte2: Öffnen Sie pom.xml Datei (Überordner-Pom) und ändern Sie den Verpackungstyp jar ändern in pom.  

pom.xml (Überordner-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 Plattform ist die Elternanwendung der generierten Anwendung, die Spring Boot und alle Standardkonfigurationen verwenden kann -->
<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模块。

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

Schritte4: Öffnen Sie das Modul des Anwendungsmoduls   pom.xml Datei sicherzustellen, dass das Paketierungsformat   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>
      <!-- Projektmodule -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.service.impl</artifactId>
        <version>${project.version}</version>
      </dependency>
      <!-- Spring Boot Abhängigkeiten -->
          <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>
 

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

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

Schritte6: im Paket   smaple.multimodule.web。

unterhalb erstellt eine Namens   WelocameController der Controller-Klasse.  
  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:Hallo Welt}")
    private String message = "Hallo Welt";
    @Autowired
    protected AccountService accountService;
    @RequestMapping("/")
    public String welcome(Map<String, Object> model) 
    {
        //versucht zu erhalten23Kontonummer
        Account account = accountService.findOne("23");
        if(account == null){
            //Wenn beim Erstellen des Kontos ein Problem auftritt, zeigen Sie die Ansicht des Fehlerstatus an
            model.put("message", "Fehler beim Abrufen des Kontos!");
            model.put("account", "");
            return "welcome"}/show";
        }  
        //Rückgabe der Anzeige23eine Ansicht der Kontoinformationen
        String accountInfo = "Ihre Kontonummer ist ".concat(account.getNumber());
        model.put("message", this.message);
        model.put("account", accountInfo);
        return "welcome"}/show";
    }
    @RequestMapping("foo")
    public String foo(Map<String, Object> model) {
        throw new RuntimeException("Foo");
    }
}
 

der7Schritt: : Im Verzeichnis   src/main/unterhalb von resource erstellen Sie eine Datei mit dem Namen show.html HTML templates ->willkommen。

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

Schritte8: Öffnen Sie   application.properties Datei, um  application message和  thymeleafDie Cache-Konfiguration ist  Nein.

application.properties

#Anwendungsinformation
application.message = Hello User!
dummy.type = type-inside-the-war
#Spring Thymeleaf Konfiguration
spring.thymeleaf.cache = false
 

Nachdem alle oben genannten Dateien erstellt wurden, sieht der Verzeichnis der Anwendungsmodule wie folgt aus:

Lassen Sie uns den zweiten Modul erstellen, nämlich   model。

Schritte9: Erstellen Sie ein   Maven Modulmit dem Namen   model。

Schritte10: Öffnen Sie das Modell   pom.xml Dateimodul und stellen Sie sicher, dass der Verpackungstyp ist   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 - Modell</name>
    Modul, das alle Entitäten und visuellen Objekte enthält, die im Projekt verwendet werden sollen. Es hat keine Abhängigkeiten. 
    </description>
</project>
 

Schritte11: im Paket   sample.multimodule.domain.entity.

unterhalb erstellt eine Namens Account Klasse.

Account.java

package sample.multimodule.domain.entity;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
@Entity
public class Account 
{
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;
    private String number;
    private String type;
    private String creditCardNumber;
    /**
     * create an empty account.
     */
    public Account() {
    }
    
    /**
     * create a new account.
     * 
     * @param number
     *            the account number
     * @param id
     *            the account id
     */
    public Account(long id, String number) {
        this.number = number;
        this.id = id;
    }
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getCreditCardNumber() {
        return creditCardNumber;
    }
    public void setCreditCardNumber(String creditCardNumber) {
        this.creditCardNumber = creditCardNumber;
    }
}
 

Nachdem alle上述Dateien erstellt wurden, sieht der Verzeichnisbaum des Model-Moduls wie folgt aus:

Lassen Sie uns erstellen   dritte Modul

Schritte12: 创建一个名为   Repository Maven模块. <strong>

Schritte13: Öffnen Sie das Modul des Anwendungsmoduls   pom.xml Datei sicherzustellen, dass das Paketierungsformat   jar.

pom.xml

<?xml version="1.0" encoding="UTF-8" standalone="no">
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>sample.multimodule.repository</artifactId>
    <packaging>jar</packaging>
    <name>Project Module - Repository</name>
    <description>Modul, das alle Repositories enthält, die im Projekt verwendet werden. Abhängig vom Model-Modul.</description>
    <dependencies>
      <!-- Projektmodule -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
      <!-- Spring Boot Abhängigkeiten -->
      <dependency>
        <groupId>org.hsqldb</groupId>
        <artifactId>hsqldb</artifactId>
        <scope>runtime</scope>
      </dependency>
    </dependencies>
    
</project>
 

Schritte14: im Paket   sample.multimodule.repository

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

Nachdem alle上述Dateien erstellt wurden, sieht der Verzeichnisbaum des Repository-Moduls wie folgt aus:

Lassen Sie uns erstellen  vierteModul, das   service-api.

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

Schritte16 : Öffnen Sie das <strong>Programmservice-api im > pom.xml-Datei sicherzustellen, dass das Paketierungsformat   jar.  

pom.xml

<?xml version="1.0" encoding="UTF-8" standalone="no">
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>sample.multimodule.service.api</artifactId>
    <packaging>jar</packaging>
    <name>Project Module - Service-API</name>
    <description>Modul, das die API aller Projekt-Services enthält. Abhängig vom Model-Modul.</description>
    <dependencies>
      <!-- Project Modules -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies> 
</project>
 

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

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

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

AccountService.java

package sample.multimodule.service.api;
import java.util.List;
import sample.multimodule.domain.entity.Account;
public interface AccountService 
{
    /**
     * 使用提供的帐号查找帐户。
     * 
     * @param number 帐户编号
     * @return The account
     * @throws AccountNotFoundException 如果没有这样的帐户存在。
     */
    Account findOne(String number) throws AccountNotFoundException;
    /**
     * 创建一个新的帐户。
     * @param number
     * @return created account
     */
    Account createAccountByNumber(String number);
}
 

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

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

Schritte21: : 打开应用程序   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>Modul, das die Implementierung der Dienste enthält, die im Service API Modul definiert sind. Abhängig von Repository Modul und Service API Modul.</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>
 

Schritte22: im Paket   sample.multimodule.service.impl。

unterhalb erstellt eine Namens AccountServiceImpl Klasse.

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/>
     * Pseudo-Methode zum Testzweck.
     * 
     * @param number Die Kontonummer. Setzen Sie 0000, um eine {@link AccountNotFoundException} zu erhalten 
     */
    @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;
    }
}
 

Nachdem alle oben genannten Dateien erstellt wurden,   service-impl Modulverzeichnis ist wie folgt:

Öffnen Sie  übergeordneten pom Datei, sehen wir alle von Maven erstellten Maven-Module in  im übergeordneten pomEtikett. Wir müssen es nicht manuell konfigurieren.

Jetzt stellen Sie sicher, dass alle fünf Module wie folgt installiert und erstellt wurden:

Nachdem alle Module erstellt wurden, das Hauptprojektverzeichnis ist wie folgt:

Schritte23: Jetzt, legen Sie   SampleWebJspApplication.java Datei als Java-Anwendung ausführen.

Schritte24: Öffnen Sie den Browser und rufen Sie die URL http: auf //localhost: 8080. Es gibt zurück  Nachrichtund Konto   23.