Spring Boot – Proyecto de varios módulos

Llega un momento en la fase de desarrollo de una aplicación en que algunas cosas se complican. Se vuelve críticamente difícil para administrar los servicios, repositorios, entidades, etc. de una aplicación. Como sabemos, Spring Boot se desarrolló por razones como la configuración automática, la eficiencia, el desarrollo rápido, la reducción de esfuerzos engorrosos, etc. Para superar este problema u otro similar, podemos usar Spring Boot para hacer la aplicación como Multi-Module. Proyecto. En un Proyecto de Múltiples Módulos, una aplicación se divide en múltiples módulos, donde cada módulo juega un papel importante en la funcionalidad determinada de una aplicación. Un módulo puede considerarse como un proyecto o subproyecto independiente.

Nota : el proyecto de varios módulos es solo un conjunto de varios proyectos en los que cada proyecto tiene su propia función respectiva. 

Ventajas de un Proyecto Multi-Módulo

1. Proporciona una gran capacidad para construir todos los submódulos con un solo comando.
2. Podemos ejecutar el comando de compilación desde el módulo principal.
3. Al compilar la aplicación, el sistema de compilación se encarga del orden de compilación.
4. La implementación de las aplicaciones se vuelve muy conveniente y flexible.
5. Además, el código de los distintos módulos en diferentes proyectos se puede reutilizar.
6. Por último, pero no menos importante, con la ayuda de la arquitectura de proyectos de módulos múltiples, podemos obtener beneficios de la arquitectura de microservicios.

Funcionamiento del Proyecto Multi-Módulo

• En primer lugar, debe crear un módulo principal.
• El módulo principal actúa como un contenedor de submódulos.
• Además, puede usar el módulo principal para el arranque de la aplicación (método main()).
• Alternativamente, también puede usar cualquiera de los submódulos implementando el método main() para iniciar la aplicación y eliminar el método main() del módulo principal.
• Su módulo principal debe tener un paquete ‘pom’ en lugar de jar y war.
• Cuando crea submódulos, todos ellos se enumeran en la etiqueta ‘<módulos>’ en pom.xml del módulo principal.
• Todas las dependencias que haya registrado en el pom.xml del módulo principal serán heredadas automáticamente por los submódulos directamente.
• Por lo tanto, no necesita agregar dependencias al pom.xml del submódulo para usarlos.

La arquitectura del Proyecto Multimódulo

Creación de un proyecto de varios módulos (STS – Spring Tool Suite)

• Cree un proyecto Spring Starter simple ( Archivo -> Nuevo -> Proyecto Spring Starter -> Siguiente -> (Seleccionar dependencias) -> Siguiente -> Finalizar )
• Cambie o agregue ‘ <packaging>pom</packaging>’ .
• Agregue un submódulo ( haga clic con el botón derecho en Módulo principal -> Nuevo -> otro -> Maven -> Módulo Maven -> Siguiente (Seleccione ambas casillas de verificación) -> Siguiente -> jar o guerra -> Finalizar ).
• Después de crear submódulos, el módulo principal contendrá las carpetas de los submódulos, y también se crearán proyectos independientes de los respectivos submódulos ya creados.

Proyecto de varios módulos (módulo principal) – Maven

ParentGFG – Módulo para padres

pom.xml (Configuraciones)

<?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.6.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>sia</groupId>
    <artifactId>ParentGFG</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>ParentGFG</name>
    <description>Multi Module Project</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
  
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
  
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
  
    <modules>
        <module>GFG-Module1</module>
        <module>GFG-Module2</module>
    </modules>
</project>

Notas: 

1. Después de crear Spring Starter Project con un paquete jar o war, asegúrese de agregar o cambiar la etiqueta ‘packaging’ con ‘pom’ -> ‘<packaging>pom</packaging>’.
2. Cuando cree submódulos, la etiqueta ‘módulos’ se generará automáticamente con los módulos respectivos agregados.
3. También puede eliminar la carpeta ‘src’ del Módulo principal después de implementar el método main() en cualquiera de los submódulos, ya que el Módulo principal también puede actuar como un contenedor.

GFG-Module1 (Sub-Módulo)

Un proyecto independiente GFG-Module1 (Sub-Module) – Maven

pom.xml (Configuraciones)

• Declara un módulo principal del cual formará parte este submódulo.
• Las etiquetas de información de este submódulo también se inicializan.

<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>sia</groupId>
    <artifactId>ParentGFG</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>GFG-Module1</artifactId>
  <name>GFG-Module1</name>
  <description>GeeksforGeeks</description>
</project>

Main.java (Bootstrapping de la aplicación)

package controller;
  
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
  
@SpringBootApplication
public class Main {
  
    public static void main(String[] args)
    {
        SpringApplication.run(Main.class, args);
    }
}

RestApi.java (punto final de la aplicación)

• Esta clase utiliza la dependencia ‘Starter Web’ que se hereda automáticamente del pom.xml del módulo principal.
• Esta clase de controlador acepta requests HTTP.
• Aquí, la solicitud HTTP GET es aceptada por el método get().
• Este método utiliza una clase de entidad que se crea y declara en un submódulo (GFG-Module2).
• Para importar clases, etc. de diferentes módulos, debe pasar el cursor sobre el subrayado de error rojo.
• Haga clic en -> ‘arreglar la configuración del proyecto’ y seleccione el submódulo respectivo en el que ha creado la clase.

package controller;
  
import entity.UserModel;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
  
@RestController
@RequestMapping("/get")
public class RestApi {
  
    @GetMapping public UserModel get()
    {
  
        UserModel entity = new UserModel();
        entity.setId("1");
        entity.setName("Darshan.G.Pawar");
        entity.setEmail("geek@geek");
        entity.setPincode("422 009");
  
        return entity;
    }
}

 GFG-Module2 (Sub-Módulo)

Un proyecto GFG-Module2 (Sub-Module) independiente – Maven

pom.xml (Configuraciones)

<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>sia</groupId>
    <artifactId>ParentGFG</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>GFG-Module2</artifactId>
  <name>GFG-Module2</name>
  <description>GeeksforGeeks</description>
</project>

UserModel.java (clase de entidad de datos de usuario)

• Esta clase representa una clase de entidad de usuario, que ha sido utilizada por el método get() de la clase RestApi.java.
• Esta clase requiere un conjunto importante de métodos Getter y Setter de todos los campos de variables de instancia.
• Esta clase usa la dependencia ‘Lombok’ que se hereda automáticamente del pom.xml del módulo principal.
• Por lo tanto, la anotación ‘ @Data ‘ de la biblioteca Lombok se usa para generar automáticamente métodos Getter y Setter en tiempo de ejecución.
• La anotación ‘ @RequiredArgsConstructor ‘ se usa para generar automáticamente un constructor para campos requeridos (donde la restricción es ‘ @NonNull’ ) o campos finales de una clase.
• Si una clase no contiene campos, la anotación ‘ @RequiredArgsConstructor ‘ actúa como una anotación ‘ @NoArgsConstructor ‘ que crea un constructor de parámetros cero.

package entity;
  
import lombok.Data;
import lombok.RequiredArgsConstructor;
  
@Data
@RequiredArgsConstructor
public class UserModel {
  
    String id;
    String name;
    String email;
    String pincode;
}

Salida: RestApi.java de GFG-Module1

1. GFG-Module2 (submódulo) declara un objeto de entidad (datos).
2. Estos datos se utilizan en el cuerpo de la respuesta que devuelve la API RESTful de GFG-Module1 (submódulo).

Salida de cuerpo JSON predeterminada (objeto UserModel) de @RestController

Nota : Deberá ejecutar GFG-Module1 como el método principal() y la clase de controlador está en este submódulo.