Spring Boot

Introducción

En los últimos años, se han realizado muchas inversiones en Spring Boot para conseguir una gran sencillez en el uso del ecosistema basado en el framework Spring.

Principalmente, Spring boot es una clase SpringApplication que proporciona una forma práctica de comenzar una aplicación Spring que arranca con un método main(). En muchas situaciones, podemos delegar al método estático SpringApplication.run() la tarea de iniciar la aplicación. También es un mecanismo de autoconfiguración basado en las dependencias que están relacionadas con la aplicación. Esta aplicación puede ser standalone, un servidor, un Batch, etc.

Spring Boot es una aplicación genérica que facilita la creación de aplicaciones estándares. Podemos diseñar rápidamente aplicaciones web, batch o microservicios, basándonos en implementaciones predeterminadas que se pueden personalizar. Para aplicaciones web/web services, Spring permite, por ejemplo, crear aplicaciones independientes autónomas que pueden incorporar un contenedor Tomcat, y es posible elegir Jetty o Undertow o cualquiera de las otras implementaciones disponibles como sustituto para el contenedor de servlets interno o elegir usar un contenedor externo.

Existe un sistema de autoconfiguración que detecta automáticamente los componentes técnicos que necesita la aplicación....

Configuración de los ejemplos

Describiremos algunos ejemplos de uso.

<parent> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-parent</artifactId> 
 <version>1.5.22.RELEASE</version> 
</parent> 
<dependencies> 
 <dependency> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-web</artifactId> 
 </dependency> 
</dependencies> 

<parent> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-parent</artifactId> 
 <version>2.6.6.RELEASE</version> 
</parent> 
<dependencies> 
 <dependency> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-web</artifactId> 
 </dependency> 
</dependencies> 
[...] 
 
<build> 
  <plugins> 
    <plugin> 
      <groupId>org.springframework.boot</groupId> 
      <artifactId>spring-boot-maven-plugin</artifactId> ...

Configuración automática Spring Boot

La anotación @EnableAutoConfiguration es una composición de anotaciones @Configuration, un juego de anotaciones @Conditional que se configura en función de las anotaciones @ConditionalOnClass y @ConditionalOnMissing y que tiene en cuenta las clases encontradas en el classpath.

El servicio discovery permite cargar en runtime implementaciones de un servicio utilizando las factories. Estas últimas se cargan a través de la clase SpringFactoryLoader, que recupera una lista de factories por el nombre o tipo de la clase.

Spring Boot detecta la presencia del archivo META-INF/spring.factories, que contiene la clave:

org.springframework.boot.autoconfigure.EnableAutoConfiguration= 
fr.eni.spring5.autoconfigure.LibXAutoConfiguration, 
fr.eni.spring5.autoconfigure.LibXWebAutoConfiguration 

Este archivo tiene su correspondencia en Spring, que contiene más de cien líneas de configuración automática: spring-boot/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories. La factory tiene más de cien líneas, que contienen los mismos tipos de claves que la mencionada anteriormente.

Configuración automática de los Beans Spring

La configuración automática de Spring Boot intenta configurar la aplicación por sí sola, a partir de las dependencias de los jars añadidos. Por ejemplo...

Los starters

Los starters son dependencias que añaden configuración automática a la aplicación basada en Spring Boot. El uso de un starter permite indicar que queremos añadir una funcionalidad a la aplicación y que dejamos que el framework complete nuestra configuración. Para elegir la versión del contenedor, es suficiente con elegir el starter correcto.

A continuación, se muestra una lista de starters. Algunos se describen con más detalle en las siguientes secciones. La lista es bastante larga:

Eventos de aplicación

Spring utiliza los eventos para notificar ciertas cosas, como la actualización del contexto a través del evento ContextRefreshedEvent:

@Component 
public class MyListener { 
 @EventListener 
 public void handleContextRefresh(ContextRefreshedEvent event) { 
 ... 
 } 
} 

Esto permite notificar a la clase MyListener cuando se ha actualizado el contexto y se puede utilizar para ejecutar código arbitrario cuando el contexto de la aplicación se ha iniciado completamente. Los eventos son importantes para determinar la readiness (la aplicación está preparada para recibir consultas) y la liveness (la aplicación está arrancada).

Una aplicación Spring Boot proporciona los siguientes eventos:

Recuperación de argumentos de la línea de comandos

Hay dos interfaces Spring Boot que permite ejecutar código justo antes de que la aplicación termine de arrancar, a través de dos interfaces: CommandLineRunner y ApplicationRunner. Estas interfaces se llaman justo antes del método run(), después de que finalice SpringApplication. Esto también puede formar parte de la fase de configuración de la aplicación.

@SpringBootApplication 
public class SpringBootWebApplication implements CommandLineRunner { 
 public static void main(String[] args) throws Exception { 
   SpringApplication.run(SpringBootWebApplication.class, args); 
 } 
 @Override 
 public void run(String... args) throws Exception { 
   logger.info("Application Started !!"); 
 } 
} 

@Slf4j 
public class SpringBootApplicationRunner implements ApplicationRunner...

Configurar los logs

Spring Boot utiliza Commons Logging para todos los registros de actividad o logs, pero es posible cambiar el comportamiento predeterminado. Se proporcionan configuraciones predeterminadas para Java Util Logging, Log4J2 y Logback. En cada caso, los registros están preconfigurados para utilizar la salida de la consola, junto con la salida de archivos opcional.

Si usa starters, Logback se utilizará de forma predeterminada para los logs. También se incluye el enrutamiento Logback adecuado para garantizar que funcionen correctamente las librerías dependientes que utilizan Java Util Logging, Commons Logging, Log4J o SLF4J.

Tenemos a nuestra disposición los niveles de log clásicos FATAL (excepto para Logback), ERROR, WARN, INFO, DEBUG y TRACE.

logging.pattern.console=%d{dd-MM-yyyy HH:mm:ss.SSS} 
%magenta([%thread]) %highlight(%-5level) %logger.%M - %msg%n 

LOGGER.trace("Pruebas de los logs:trace"); 
LOGGER.debug("Pruebas de los logs:debug"); 
LOGGER.info("Pruebas de los logs:info"); 
LOGGER.warn("Pruebas de los logs:warn"); 
LOGGER.error("Pruebas de los logs:error"); 

02-03-2018 12:42:27.545 [main] TRACE 
fr.eni.spring5.logs.Ex1Logs.run - Pruebas de los logs:trace 
02-03-2018 12:42:27.545 [main] DEBUG 
fr.eni.spring5.logs.Ex1Logs.run - Pruebas de los logs:debug 
02-03-2018 12:42:27.545 [main] INFO 
fr.eni.spring5.logs.Ex1Logs.run - Pruebas de los logs:info 
02-03-2018 12:42:27.545 [main] WARN 
fr.eni.spring5.logs.Ex1Logs.run - Pruebas de los logs:warn 
02-03-2018 12:42:27.545 [main] ERROR 
fr.eni.spring5.logs.Ex1Logs.run - Pruebas de los logs:error 

Gestión de sesiones

Intentamos ser stateless porque la gestión de sesiones dificulta la agrupación en clústeres de servidores debido al uso compartido de sesiones. Por lo tanto, «emulamos» la sesión a través de una caché compartida.

En algunos casos no tenemos otra opción; estamos obligados a gestionar sesiones. Las sesiones se pueden administrar en el proyecto Spring Session, que tiene dos versiones en paralelo. El objetivo del proyecto es ofrecer una alternativa a las sesiones de contenedores Tomcat, Jetty, etc.

El módulo Spring Session gestiona las sesiones.

Existen diferencias entre las dos implementaciones.

En esta tabla, Spring 4 y 5 se corresponden con las versiones 1.5 y 2.6 de Spring Boot.

HttpSession (Spring): sustituye a HttpSession en un contenedor (Tomcat) de forma neutral añadiendo las siguientes funcionalidades:

WebSocket: conserva la sesión HttpSession cuando recibimos mensajes WebSocket.

WebSession: permite sustituir los WebSession de una aplicación en contenedores Spring WebFlux.

Para la sesión...

Guía de migración de la versión 1.5 a la versión 2.x

En términos de migración de Spring Boot 1.5 a la versión 2.x, la documentación de Spring enumera una serie de puntos.

<dependency> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-properties-migrator</artifactId> 
</dependency> 

Descripción avanzada de Spring Boot

En este apartado se describe cómo iniciar un programa Spring Boot. Sirve para desmitificar una vez más la aparente «magia» del sistema que, en realidad, es el resultado de un trabajo interesante y concienzudo. Spring utiliza los mecanismos de Spring Boot que pone a nuestra disposición.

Las fuentes de Spring Boot se pueden ver en https://github.com/spring-projects/spring-boot. Podemos estudiar el comportamiento de Spring Boot durante el arranque a partir de estas fuentes. Una aplicación Spring Boot se caracteriza por dos elementos: la anotación @SpringBootConfiguration y el método estático RUN dentro de un programa Java estándar:

@SpringBootApplication 
public class Application { 
public static void main(String[] args) {  
 SpringApplication.run(Application.class, args); 
 } 
} 

La anotación @SpringBootApplication es una composición de las anotaciones @SpringBootConfiguration, @EnableAutoConfiguration y @ComponentScan con sus atributos predeterminados.

Como hemos visto, la anotación @SpringBootConfiguration es un alias para la anotación @Configuration y la anotación @EnableAutoConfiguration indica que tenemos la configuración incorporada o incrustada en el código. La anotación @ComponentScan indica que el paquete que contiene la clase principal sirve como...

Configuración de los listeners

Spring Boot usa la interfaz SpringApplicationRunListener que tiene EventPublishingRunListener como implementación.

Este es el listener que va a enviar los eventos durante la fase de inicialización:

Ya hemos presentado algunos de estos eventos.

class MiListener implements ApplicationListener<ApplicationStartingEvent> { 
 void onApplicationEvent(ApplicationStartingEvent event {...} 
} 

EnableAutoConfiguration

La anotación EnableAutoConfiguration es de tipo Import.

@Target(ElementType.TYPE) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Inherited 
@AutoConfigurationPackage  
@Import(AutoConfigurationImportSelector.class) 
public @interface EnableAutoConfiguration { 
 
        /** 
        * Environment property that can be used to override 
when auto-configuration is 
        * enabled. 
        */ 
        String ENABLED_OVERRIDE_PROPERTY = 
"spring.boot.enableautoconfiguration"; 
 
        /** 
        * Exclude specific auto-configuration classes such that  
they will never be applied. 
        * @return the classes to exclude 
        */ 
        Class<?>[] exclude() default {}; 
 
        /** 
        * Exclude specific auto-configuration class names such that 
they will never be 
        *...