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

SpringBoot 多模块项目

Progetto a più moduli

Il progetto Spring Boot che contiene un progetto Maven annidato si chiama progetto a più moduliNella struttura a più moduli, il progetto padre agisce come contenitore delle configurazioni di base di Maven.

In altre parole, progetto a più moduliè costruito dal POM del padre per gestire un gruppo di moduli figli. O progetto a più modulida citare uno o più moduli figli dal POM del padre per definire.

Il progetto父maven deve includere pom Il tipo di imballaggio del progetto lo rende un aggregatore. Il progetto principale} pom.xml Il file contiene tutte le dipendenze ereditate dai sotto-progetti modulo, dipendenze comunie proprietàelenchi. Il file pom principale si trova nella directory principale del progetto. I sotto-moduli sono progetti Spring Boot reali, che ereditano le proprietà Maven dal progetto principale.

Quando eseguiamo un progetto a più moduli, tutti i moduli vengono distribuiti insieme sul server Tomcat embedded. Possiamo anche distribuire un singolo modulo.

Il file POM principale

Il file POM principale definisce ID di gruppo, ID dell'artefatto, versione, e packaging.. Nei progetti Maven precedenti, abbiamo visto che il livello principale POM definisce il pacchetto jar.. Ma nel progetto a più moduli, il livello principale POM Definire il file pom di imballaggio. Il file pom di imballaggio fa riferimento ad altri progetti Maven.

Perché ci serve un progetto a più moduli

Dividere il progetto in moduli è utile e facile da mantenere. Possiamo anche modificare o eliminare i moduli del progetto senza influenzare gli altri moduli. Questo è utile quando dobbiamo distribuire i moduli separatamente.

Dobbiamo solo specificare tutte le dipendenze nel file pom principale. Tutti gli altri moduli condividono lo stesso file pom, quindi non dobbiamo specificare le stesse dipendenze in ogni modulo.

Sotto-modulo-ear, war e jar

I sotto-moduli possono essere qualsiasi progetto e possono avere qualsiasi tipo di imballaggio. Possiamo creare liberamente qualsiasi tipo di dipendenza tra i moduli e i pacchetti.

Ad esempio, stiamo creando EAR (Enterprise Archive), WAR (Web ARchive) e JAR (Java ARchive) file. I file JAR sono incapsulati nei file WAR, mentre i file WAR sono incapsulati nei file EAR. Il file EAR è un pacchetto software finale che può essere distribuito su un server di applicazioni.

Il file EAR contiene uno o più file WAR. Ogni file WAR contiene un progetto di servizio, che ha codice comune per tutti i file WAR e il tipo di imballaggio nel file JAR.

Progetto/Modulo Maven

I sotto-moduli sono progetti Maven indipendenti, che condividono le proprietà del progetto principale. Tutti i sotto-progetti possono essere costruiti con un comando, poiché si trovano nel progetto principale. Definire le relazioni tra i progetti diventa più facile.

Struttura di directory di un progetto a più moduli

Facciamo conoscere la struttura di directory di un progetto a più moduli.

Nell'immagine seguente, abbiamo creato un progetto chiamato spring-boot-multi-module-project che contiene il progetto principale. pom Dopo di che, abbiamo creato due Modulo Mavene rispettivamente denominati module1 e module2 Questi due moduli contengono i propri file pom.

Apriamo il file POM principale e guardiamo la configurazione creata durante la creazione del modulo Maven nel progetto.

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>

Il file pom sopra è lo stesso dell'esempio precedente. Ma in questo pom In questo file, ci sono due cose da notare: imballaggioe modulo

Quando creiamo progetti a moduli multipli, dobbiamo configurare il pom di packaging nel file pom dei genitori, invece di jar.

<packaging>pom</packaging>

Quando creiamo moduli Maven nel progetto, Spring Boot configurerà modulo Configurazione automatica dei moduli nel pom dei genitori delle etichette, come indicato di seguito.

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

Ora, vedremo Il contenuto del file pom di module1.

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>

Occorre notare che il file pom sopra riportato non contiene elementi come starter-web, web-mvc, ecc.Dipendenze comuni come queste. Pom padre.

Esempio di progetto Spring Boot a modulo multiplo

Facciamo creare un esempio di applicazione a modulo multiplo.

Nell'esempio seguente, abbiamo creato un progetto chiamato il progetto Maven di spring-boot-multimodule.Questo è l'applicazione principale. Nell'applicazione principale, abbiamo creatoCinqueModuli, come indicato di seguito: Applicazione Modello Repository service-api service-impl

Modulo applicazione

Il modulo applicazione è il modulo principale del progetto. Contiene la classe dell'applicazione, nella quale viene definito il metodo main necessario per eseguire l'applicazione Spring Boot. Include anche Proprietà di configurazione dell'applicazione, controller, viewe Risorse.

Il modulo applicazione include il modulo modello, il modulo di implementazione del servizio come modulo dipendente dal modello, il modulo repository e il modulo API di servizio.

Modulo modello

Il modulo modello contiene Entitàe quelli utilizzati nel progetto Visual Objects

Modulo repository

Il modulo repository contiene <In progetto utilizzati strong>  Repository. Dipende dal modulo modello.

Modulo API di servizio

Il modulo API di servizio contiene tutte le progetti Servizio.Dipende anche dal modulo modello.

Modulo di implementazione del servizio

Il modulo di implementazione del servizio può implementare il servizio. Dipende dal modulo di repository e dal modulo API di servizio.

Aggregatore POM (pom padre)

Il pom padre contiene tutti i moduli dell'applicazione. Include anche tutte le dipendenze comuni e le proprietà necessarie per un modulo superiore. Poiché il progetto ha definito Spring IO Platform come superiore, le dipendenze non specificano la versione.

Facciamo conoscere la struttura dell'applicazione a modulo multiplo che abbiamo creato.

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

步骤1: Crea un file chiamato spring-boot-multimodule的 progetto Maven

Passo 2: Apri pom.xml file (pom padre) e cambiare il tipo di imballaggio jar modificare pom.  

pom.xml (pom padre)
<?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 Platform è l'applicazione padre generata, in grado di utilizzare Spring Boot e tutte le configurazioni predefinite -->
<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 Dependencies -->
<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>
 

In questo file pom.xml, una cosa da notare è che, poiché non è stato creato un modulo Maven, non è configurato. Ora, creeremo un modulo Maven come descritto sopra.

Passo 3: Crea un file chiamato   dell'applicazione Modulo Maven

Passo 4: Apri il modulo applicazione   pom.xml File e assicurati che il tipo di pacchetto sia   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>
      <!-- Moduli del progetto -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.service.impl</artifactId>
        <version>${project.version}</version>
      </dependency>
      <!-- Dipendenze 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>
 

步骤5: Creazione  主要这是要运行的类。

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

步骤6: nel pacchetto   smaple.multimodule.web。

creare un nome chiamato   WelocameController 的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) 
    {
        //Tenta di ottenere l'account numero 23
        Account account = accountService.findOne("23");
        if(account == null){
            //Se si verifica un problema durante la creazione dell'account, restituisce la vista che mostra lo stato di errore
            model.put("message", "Errore nel recupero dell'account!");
            model.put("account", "");
            return "welcome/show";
        }  
        //Restituisce la vista che mostra le informazioni di 23 account
        String accountInfo = "Il tuo numero di account è ".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");
    }
}
 

Passo 7: nella cartella   Crea un file chiamato 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>Messaggio:</b>
      <span th:text="${message}" />
    </div>
    <div>
      <b>Il tuo account:</b>
      <span th:text="${account}" />
    </div>
</body>
</html>
 

Passaggio 8: Apri   application.properties Apri il file  application messagee  thymeleafLa configurazione della cache è impostata su  No.

application.properties

#Informazioni dell'applicazione
application.message = Hello User!
dummy.type = type-inside-the-war
#Configurazione Spring Thymeleaf
spring.thymeleaf.cache = false
 

Dopo aver creato tutti i file menzionati, la directory del modulo applicazione è come segue:

Creiamo il secondo modulo, ovvero   model.

Passaggio 9: Crea un   Maven Modulecon il nome   model.

Passaggio 10: Apri il modello   pom.xml Modulo di file, e assicurati che il tipo di imballaggio sia   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>Modulo Progetto - Modello</name>
    <description>Modulo che contiene tutte le Entità e gli Oggetti Visivi da utilizzare nel progetto. Non ha alcuna dipendenza. 
    </description>
</project>
 

Passaggio 11: nel pacchetto   sample.multimodule.domain.entity。

creare un nome chiamato Account 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;
    /**
     * Crea un account vuoto.
     */
    public Account() {
    }
    
    /**
     * Crea un nuovo account.
     * 
     * @param number
     * Numero dell'account
     * @param id
     * ID dell'account
     */
    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;
    }
}
 

Dopo aver creato tutti i file menzionati, la directory del modulo modello sarà come segue:

Creiamo   terzo modulo

Passaggio 12: Crea un file chiamato   del repository Modulo Maven strong>

Passaggio 13: Apri il modulo applicazione   pom.xml File e assicurati che il tipo di pacchetto sia   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>Modulo Progetto - Repository</name>
    <description>Modulo che contiene tutti i repository da utilizzare nel progetto. Dipende dal Modulo Model.</description>
    <dependencies>
      <!-- Moduli del progetto -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
      <!-- Dipendenze Spring Boot -->
      <dependency>
        <groupId>org.hsqldb</groupId>
        <artifactId>hsqldb</artifactId>
        <scope>runtime</scope>
      </dependency>
    </dependencies>
    
</project>
 

Passaggio 14: nel pacchetto   sample.multimodule.repository

Creare un nome per   AccountRepository 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);
}
 

Dopo aver creato tutti i file menzionati, la directory del modulo repository è come segue:

Creiamo  quartoIl modulo, che è   service-api.

Passo 15: Crea un file chiamato   service-api Modulo Maven

Passo 16 : Aprire <strong>ApplicazioneNella file > pom.xml di service-api, assicurarsi che il tipo di pacchettizzazione sia   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>Modulo Progetto - API Servizi</name>
    <description>Modulo che contiene l'API di tutti i servizi del progetto. Dipende dal Modulo Model.</description>
    <dependencies>
      <!-- Project Modules -->
      <dependency>
        <groupId>sample.multimodule</groupId>
        <artifactId>sample.multimodule.model</artifactId>
        <version>${project.version}</version>
      </dependency>
    </dependencies> 
</project>
 

Passo 17: Creare un nome per   il pacchetto sample.multimodule.service.api.

Passo 18: Creare un nome per   La classe AccountNotFoundException.Se non viene trovato il conto, gestirà l'eccezione.

AccountNotFoundException.java

package sample.multimodule.service.api;
public class AccountNotFoundException extends RuntimeException 
{
    private static final long serialVersionUID = -3891534644498426670L;
    public AccountNotFoundException(String accountId) 
    {
        super("Non esiste un account con id: " + accountId);
    }
}
 

Passo 19: Crea un file chiamato   La classe AccountService.Fornisce servizi relativi agli account, come  Ricercae  Creazioneconto.

AccountService.java

package sample.multimodule.service.api;
import java.util.List;
import sample.multimodule.domain.entity.Account;
public interface AccountService 
{
    /**
     * Trova l'account utilizzando il numero di conto fornito.
     * 
     * @param number Il numero dell'account
     * @return L'account
     * @throws AccountNotFoundException se non esiste un account con tale numero.
     */
    Account findOne(String number) throws AccountNotFoundException;
    /**
     * Crea un nuovo account.
     * @param number
     * @return account creato
     */
    Account createAccountByNumber(String number);
}
 

Dopo aver creato tutti i file menzionati, la directory del modulo service-api è come segue:

Passo 20: Crea un file chiamato   service-impl Modulo Maven

Passo 21: : Apri l'applicazione   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>Modulo Progetto - Implementazione Servizio</name>
    <description>Modulo che contiene le implementazioni dei servizi definiti nel modulo Service API. Dipende dal modulo Repository e dal modulo 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>
 

Passo 22: nel pacchetto   sample.multimodule.service.impl。

creare un nome chiamato AccountServiceImpl 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/>
     * Metodo fittizio per scopi di test.
     * 
     * @param number Il numero del conto. Imposta 0000 per ottenere 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;
    }
}
 

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

现在打开  父pom 文件,我们看到已创建的所有Maven模块都在  中的父pom标签。我们不需要手动配置它。

现在确保所有五个模块都已安装创建,如下所示:

创建后所有模块,主项目目录如下所示:

步骤23: 现在,将   SampleWebJspApplication.java 文件作为Java应用程序运行。

步骤24: 打开浏览器并调用URL http://localhost: 8080。它返回  消息和账号为   23。