Índice

1. Descripción general

SpringApplication es la clase responsable de inicializar y lanzar una aplicación Spring desde un método main. Al invocarse, ejecuta los siguientes pasos por defecto:

  1. Crea una instancia de ApplicationContext apropiada según el classpath.
  2. Registra un CommandLinePropertySource para exponer los argumentos de línea de comandos como propiedades de Spring.
  3. Refresca el ApplicationContext, cargando todos los beans singleton.
  4. Ejecuta los beans que implementen CommandLineRunner.

2. Fuentes de beans

SpringApplication puede cargar beans desde distintas fuentes. Si bien lo más habitual es usar una clase anotada con @Configuration, la clase soporta:

  • Nombre de clase completamente calificado, cargado por AnnotatedBeanDefinitionReader.
  • Ubicación de un recurso XML, cargado por XmlBeanDefinitionReader.
  • Script Groovy, cargado por GroovyBeanDefinitionReader.
  • Nombre de un paquete, escaneado por ClassPathBeanDefinitionScanner.

Las fuentes adicionales pueden configurarse mediante setSources(Set) o a través de la propiedad spring.main.sources (lista separada por comas).

3. Formas de uso

Método estático

La forma más directa: delega internamente en una instancia de SpringApplication con configuración por defecto.

@Configuration
@EnableAutoConfiguration
public class MyApplication {

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

También acepta múltiples fuentes como array:

SpringApplication.run(new Class<?>[] { A.class, B.class }, args);

Instancia configurada

Cuando se necesita ajustar el comportamiento antes del arranque, se instancia SpringApplication directamente:

public static void main(String[] args) {
    SpringApplication application = new SpringApplication(MyApplication.class);
    // configuración personalizada
    application.run(args);
}

Ambos constructores disponibles son:

SpringApplication(Class<?>... primarySources)
SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources)

El segundo permite proveer un ResourceLoader propio, que será utilizado dentro del ApplicationContext.

Configuración por propiedades

Algunas opciones también pueden controlarse sin código, a través de propiedades de entorno o application.properties:

Propiedad Efecto
spring.main.sources Fuentes adicionales (CSV)
spring.main.web-application-type=none Desactiva el entorno web
spring.main.banner-mode=off Desactiva el banner
spring.main.lazy-initialization=true Activa inicialización lazy

4. Configuración disponible

Al usar una instancia, los métodos más relevantes para configurar el arranque son:

Tipo de aplicación web

app.setWebApplicationType(WebApplicationType.NONE);

Si no se configura explícitamente, Spring Boot lo deduce del classpath. Los valores posibles son SERVLET, REACTIVE y NONE.

Inicialización lazy

app.setLazyInitialization(true);

Por defecto es false. Al activarlo, los beans se instancian solo cuando se solicitan por primera vez, lo que puede reducir el tiempo de arranque.

Referencias circulares y sobreescritura de beans

app.setAllowCircularReferences(true);    // default: false (desde 2.6)
app.setAllowBeanDefinitionOverriding(true); // default: false (desde 2.1)

Ambas están desactivadas por defecto. Habilitarlas puede enmascarar problemas de diseño; se recomienda resolver la causa raíz antes de recurrir a estas opciones.

app.setBannerMode(Banner.Mode.OFF);      // desactiva el banner
app.setBanner(myBannerInstance);         // banner personalizado

Shutdown hook

app.setRegisterShutdownHook(false); // default: true

Por defecto Spring registra un shutdown hook para que el cierre de la JVM sea manejado de forma ordenada.

Listeners

Los ApplicationListener registrados aquí reciben eventos tanto del SpringApplication como del ApplicationContext:

app.addListeners(new MyListener());

Esto es relevante para eventos que se publican antes de que el contexto esté disponible, como ApplicationStartingEvent o ApplicationEnvironmentPreparedEvent, que no pueden capturarse con @EventListener.

Inicializadores de contexto

app.addInitializers(new MyContextInitializer());

Los ApplicationContextInitializer se aplican al contexto antes de que sea refrescado.

Prefijo de entorno

app.setEnvironmentPrefix("myapp");

Permite que las propiedades del sistema con prefijo myapp.* se vinculen automáticamente al SpringApplication.

5. El ApplicationContext

SpringApplication crea el ApplicationContext a través de un ApplicationContextFactory. Por defecto, la implementación se elige según el tipo de aplicación detectado:

Tipo Implementación
SERVLET AnnotationConfigServletWebServerApplicationContext
REACTIVE AnnotationConfigReactiveWebServerApplicationContext
NONE AnnotationConfigApplicationContext

Para usar una implementación propia:

app.setApplicationContextFactory(ApplicationContextFactory.of(MyCustomContext.class));

6. SpringApplicationBuilder

SpringApplicationBuilder expone la misma API a través de una interfaz fluida, útil cuando se encadenan varias opciones:

new SpringApplicationBuilder(MyApplication.class)
    .web(WebApplicationType.NONE)
    .bannerMode(Banner.Mode.OFF)
    .profiles("prod")
    .run(args);

7. Conclusión

SpringApplication ofrece un modelo de arranque con valores por defecto razonables y múltiples puntos de extensión. El método estático run() es suficiente para la mayoría de los casos. La instancia directa cobra relevancia cuando se necesita intervenir en el proceso antes del arranque: ajustar el tipo de aplicación, registrar listeners tempranos, controlar la inicialización de beans o proveer fuentes de configuración adicionales.