Características principales

Las propiedades ${application.version} y ${application.formatted-version} están disponibles solo en caso de que esté utilizando lanzadores Spring Boot. Los valores no se resolverán si se ejecuta el archivo jar descomprimido y se ejecuta mediante java -cp <classpath> <mainclass>.

Es por eso que recomendamos que siempre ejecute archivos jar descomprimidos a través de java org.springframework.boot.loader.JarLauncher. Esto inicializa las variables de banner application.* antes de crear el classpath y ejecutar su aplicación.

Configuración de SpringApplication

Si el los valores predeterminados de SpringApplication settings no coinciden con sus preferencias, puede crear una instancia local y personalizarla. Por ejemplo, para desactivar el banner, puedes escribir:

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(MyApplication.class);
        application.setBannerMode(Banner.Mode.OFF);
        application.run(args);
    }
}

import org.springframework.boot.Banner
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
    runApplication<MyApplication>(*args) {
        setBannerMode(Banner.Mode.OFF)
    }
}

También puedes configurar SpringApplication usando el archivo application.properties.

API Fluent Builder

Si necesitas compilar una jerarquía de ApplicationContext (múltiples contextos con relaciones padre/hijo) o si prefiere usar la API de creación "fluida", puede usar SpringApplicationBuilder.

SpringApplicationBuilder le permite encadenar múltiples llamadas a métodos e incluye métodos parent y child que le permiten crear una jerarquía, como se muestra en el siguiente ejemplo. :

new SpringApplicationBuilder()
        .sources(Parent.class)
        .child(Application.class)
        .bannerMode(Banner.Mode.OFF)
        .run(args);

SpringApplicationBuilder()
        .sources(Parent::class.java)
        .child(Application:: class.java)
        .bannerMode(Banner.Mode.OFF)
        .run(*args)

Disponibilidad de la aplicación

Cuando se implementan en plataformas, las aplicaciones pueden comunicar su disponibilidad a la plataforma utilizando infraestructura como sondas de Kubernetes. Spring Boot tiene soporte integrado para los estados de disponibilidad "vivos" y "preparados" comúnmente utilizados. Si utiliza el soporte del actuador Spring Boot, estos estados se exponen como grupos de puntos finales de estado de la aplicación.

Alternativamente, puede obtener datos del estado de preparación implementando la interfaz ApplicationAvailability en su propia beans.

Estado de vida

El estado de “vida” de una aplicación le indica si su estado interno le permite funcionar correctamente o recuperarse por sí sola si no lo hace. Un estado de "vida" interrumpido significa que la aplicación se encuentra en un estado del que no se puede recuperar y el marco debe reiniciar la aplicación.

El estado interno de las aplicaciones Spring Boot está representado principalmente por el ApplicationContext para Spring. Si el contexto de la aplicación se inició correctamente, Spring Boot supone que la aplicación se encuentra en un estado válido. Se considera que una aplicación se está ejecutando inmediatamente después de que se actualiza el contexto.

Preparación

El estado de "preparación" de una aplicación indica si la aplicación está lista para procesar el tráfico. El estado defectuoso de "Preparación" le indica a la plataforma que aún no reenvíe el tráfico a la aplicación. Esto suele ocurrir al inicio, mientras los componentes CommandLineRunner y ApplicationRunner se están procesando, o en cualquier otro momento si la aplicación decide que está demasiado ocupada para manejar tráfico adicional.

La aplicación se considera lista tan pronto como se invocan la aplicación y las herramientas de ejecución de la línea de comandos.

Administrar el estado de disponibilidad de la aplicación

Los componentes de la aplicación pueden obtener el estado de disponibilidad actual en cualquier momento implementando la interfaz ApplicationAvailability y llamando a sus métodos. En la mayoría de los casos, las aplicaciones necesitan escuchar las actualizaciones de estado o actualice el estado de la aplicación.

Por ejemplo, puede exportar el estado de "preparación" de la aplicación a un archivo para que la "sonda ejecutiva" de Kubernetes pueda "sondear" el archivo:

import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.ReadinessState;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
@Component
public class MyReadinessStateExporter {
    @EventListener
    public void onStateChange(AvailabilityChangeEvent<ReadinessState> event) {
        switch (event.getState()) {
            case ACCEPTING_TRAFFIC:
                // crear un archivo /tmp/healthy
                break;
            case REFUSING_TRAFFIC:
                // eliminar el archivo /tmp/healthy
                break;
        }
    }
}

import org.springframework.boot.availability.AvailabilityChangeEvent
import org.springframework.boot.availability.ReadinessState
import org.springframework.context.event.EventListener
import org.springframework.stereotype.Component
@Component
class MyReadinessStateExporter {
    @EventListener
    fun onStateChange(event: AvailabilityChangeEvent<ReadinessState?>) {
        when (event.state) {
            ReadinessState.ACCEPTING_TRAFFIC -> {
                // crear un archivo /tmp/healthy
            }
            ReadinessState.REFUSING_TRAFFIC -> {
                // eliminar el archivo /tmp/healthy
            }
            else -> {
                // ...
            }
        }
    }
}

También podemos actualizar el estado de la aplicación si la aplicación falla y no puede recuperarse:

import org.springframework.boot.availability.AvailabilityChangeEvent;
import org.springframework.boot.availability.LivenessState;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;
@Component
public class MyLocalCacheVerifier {
    private final ApplicationEventPublisher eventPublisher;
    public MyLocalCacheVerifier(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    public void checkLocalCache() {
        try {
            // ...
        }
        catch (CacheCompletelyBrokenException ex) {
            AvailabilityChangeEvent.publish(this.eventPublisher, ex, LivenessState.BROKEN);
        }
    }
}

import org.springframework.boot.availability.AvailabilityChangeEvent
import org.springframework.boot.availability.LivenessState
import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Component
@Component
class MyLocalCacheVerifier(private val eventPublisher: ApplicationEventPublisher) {
    fun checkLocalCache() {
        try {
            // ...
        } catch (ex: CacheCompletelyBrokenException) {
            AvailabilityChangeEvent.publish(eventPublisher, ex, LivenessState.BROKEN)
        }
    }
}

Spring Boot proporciona sondas HTTP de Kubernetes para verificar los estados de actividad y preparación utilizando el actuador del punto final del estado de la aplicación.