Bota de resorte – Embalaje

Spring Framework se creó para proporcionar un marco de aplicación de código abierto para ofrecer un mejor soporte de infraestructura para desarrollar aplicaciones Java. Es uno de los marcos de Java Enterprise Edition (Java EE) más populares, Spring Framework ayuda a los desarrolladores a crear aplicaciones de alto rendimiento utilizando objetos de Java simples (POJO). Pero trabajar con Spring es un proceso engorroso porque tenemos que gestionar sus configuraciones manualmente. Aquí viene Spring-Boot, que se desarrolló para facilitar el proceso de desarrollo de aplicaciones con la ayuda de su característica principal: la configuración automática. Además, en el centro de las características esenciales de Spring Boot se encuentra su característica de empaquetado.

Requisitos previos :

1. Todos los tipos de embalaje son adecuados para sus respectivas limitaciones.
2. Por lo tanto, debe elegir el tipo de empaque respectivo que sea mejor para las limitaciones de su aplicación.

Importancia del empaquetado de la aplicación Spring Boot

1. La función de empaquetado de Spring Boot ayuda a administrar la aplicación, sus módulos, que además son importantes para la implementación de la aplicación.
2. Maven y Gradle son las tecnologías de administración de paquetes más utilizadas que admiten Spring y Spring Boot.
3. Ambos proporcionan sus respectivos complementos que realmente logran empaquetar: (Spring Boot Maven Plugin / Spring Boot Gradle Plugin).
4. Se aseguran de que todas las bibliotecas de dependencia se incluyan en el archivo JAR ejecutable y estén disponibles en el classpath en tiempo de ejecución.
5. Spring Boot Maven Plugin permite a los desarrolladores empaquetar archivos jar o war ejecutables con la ejecución de la aplicación en su lugar. Spring proporciona compatibilidad con contenedores integrados.
6. También nos da la opción de excluir dependencias para evitar posibles conflictos de jar al implementar en un contenedor externo.
7. También ayuda a ejecutar los archivos ‘jar’ de forma independiente sin el uso del comando jar (java -jar).

El embalaje como contenedor y gestor

Tipos de embalaje en Spring Boot

1. frasco
2. guerra
3. pompón
4. oído

Jerarquía de los métodos de embalaje utilizados 

1. Envasado en tarro

• JAR significa Archivo Java.
• Encapsula una o más clases de Java ( EJB – Enterprise Java Beans ), un manifiesto y un descriptor (por ejemplo, un archivo XML) se denomina archivo JAR.
• Su extensión es ‘.jar’
• Es el embalaje de nivel más bajo.
• JAR es un paquete tradicional que se usa para empaquetar bibliotecas (clases y metadatos de Java) y la aplicación de interfaz de usuario de escritorio ocasional.
• En Spring Boot Applications, ‘jar’ es el paquete predeterminado que se implementa en los servidores integrados de Spring.
• En este caso, la elección del envase JAR es una elección basada en la nube.
• Todas las plataformas en la nube de Java son capaces de ejecutar un archivo JAR ejecutable.
• Por lo tanto, ‘Spring Initializr’ hace que el paquete JAR sea predeterminado a menos que le indique lo contrario.
• Si está creando un archivo JAR ejecutable, debe elegir cualquiera de los siguientes: Thymeleaf, FreeMarker, Groovy Templates, JSP Java Server Pages, Moustache.
• Spring Boot Maven Plugin produce un archivo de manifiesto en el archivo JAR que denota la clase de arranque como la clase principal para el archivo JAR ejecutable.
• Después de compilar su aplicación con paquetes mvn ( haga clic con el botón derecho en el proyecto -> Ejecutar como -> Maven Build o Maven Clean ), el archivo ‘.jar’ de su aplicación se creará en la carpeta ‘objetivo’.
• Después de ejecutar el archivo ‘.jar’, puede realizar una solicitud, por ejemplo: http://localhost:8080/mapeo de métodos…
• Como el jar es el valor predeterminado, no necesita incluir la etiqueta de empaquetado en pom.xml (compilación de Maven).
• Ejemplo – 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.6.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>sia</groupId>
    <artifactId>Geeks</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Geeks</name>
    <description>GFG</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </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>
            </plugin>
        </plugins>
    </build>
</project>

Nota : 

1. Su aplicación debe tener una clase principal que se ejecutará cuando se ejecute el archivo JAR.
2. También necesitará una cantidad mínima de Spring Configuration para iniciar la aplicación.

Ejemplo: GfgWebApplication.java (Clase principal: Bootstrapping de la aplicación Spring Boot)

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

2. Embalaje de guerra

• WAR significa Archivo Web.
• Las aplicaciones web Java tradicionales se empaquetan como archivos WAR.
• Los archivos WAR son perfectamente adecuados para su implementación en un servidor de aplicaciones Java tradicional.
• Algunas plataformas en la nube (como CloudFoundry) son capaces de implementar y ejecutar archivos WAR.
• Debe incluir ‘ <packaging>war</packaging> ‘ en pom.xml – archivo de compilación de Maven.
• El módulo web contiene clases de servlet, archivos JSP, archivos HTML, JavaScript, etc. están empaquetados como un archivo JAR con extensión .war.
• Contiene un directorio especial llamado WEB-INF.
• Los contenedores de servlets de Java, incluidos los contenedores Tomcat y Jetty incorporados, generalmente buscan JSP en algún lugar bajo /WEB-INF.
• Pero si está creando su aplicación como un archivo JAR ejecutable, no hay forma de satisfacer ese requisito.
• Por lo tanto, mientras empaqueta con WAR, necesita trabajar solo con JSP (Java Server Pages) dentro de las páginas web de su aplicación.

Ejemplo: pom.xml (Maven)

<?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>GFG</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>GFG</name>
    <description>GeeksforGeeks</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-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
    </dependencies>
  
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
  
</project>

Nota : cuando elige el paquete WAR para la implementación de aplicaciones en un servidor de aplicaciones Java tradicional, debe incluir una clase de inicializador web.

Ejemplo: GfGApplication.java (clase principal: arranque de la aplicación)

package gfg;
  
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
  
@SpringBootApplication
public class GfGApplication extends SpringBootServletInitializer {
  
    public static void main(String[] args) {
        SpringApplication.run(GfGApplication.class, args);
    }
  
}

Trabajando con empaques WAR –

1. Para compilar nuestra aplicación WAR implementable con Tomcat, ejecutamos el paquete mvn ( haga clic con el botón derecho en el proyecto -> Ejecutar como -> Maven Build o Maven Clean ).
2. Después de actualizar, nuestro archivo WAR se genera en target/________.war
3. Copie nuestro archivo WAR de target/________.war a tomcat/webapps/
4. Desde una terminal, vaya a la carpeta tomcat/bin y ejecute: catalina.bat run (en Windows), catalina.sh run (en sistemas basados ​​en Unix).
5. Vaya a http://localhost:8080/’.war file name’/mapeo de métodos

3. Embalaje POM

• Podemos usar Spring Boot para hacer que la aplicación sea un proyecto de varios módulos.
• 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.
• Estos módulos también se coordinan con otros módulos.
• Por lo tanto, debemos gestionarlos con la ayuda de los envases pom.
• El empaquetado pom actúa como contenedor para otros submódulos que a su vez están empaquetados en archivos jar o war.
• El empaque pom puede tener submódulos que tienen empaques diferentes.
• Debe incluir ‘ <packaging>pom</packaging> ‘ en el archivo pom.xml.
• Se declaran y enumeran en la etiqueta ‘módulos’.

Paquetes de los módulos

Ejemplo: pom.xml (Maven)

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

4. Embalaje de oreja

• EAR significa archivo empresarial.
• Su archivo tiene una extensión ‘.ear’.
• Puede contener varios módulos EJB: Enterprise Java Beans (JAR) y módulos web (WAR).
• Es un JAR especial que contiene un archivo application.xml en la carpeta META-INF.