Componentes principales de Spring Boot

Spring Boot no es querido por los desarrolladores por nada — ofrece un montón de componentes prácticos que hacen la vida del programador más sencilla (y, quizá, más divertida). Vamos a ver tres piezas clave:

1. Dependencias Starters (Starters)
2. Autoconfiguración (Auto-Configuration)
3. Servidores embebidos

1. Dependencias Starters (Starters) — paquetes con todo lo necesario

¿Recuerdas cuando en el Spring clásico tenías que buscar y añadir librerías una por una? Spring Boot soluciona eso con los starters (Starters). Son conjuntos listos de librerías para distintas tareas.

¿Quieres crear una aplicación web? Simplemente añade spring-boot-starter-web, y Spring Boot conectará todo lo necesario: Tomcat para ejecutar, librerías para REST API y manejo de peticiones.

¿Por qué es cómodo?

Imagina que haces una pizza. En vez de andar buscando masa, queso, salsa y especias por separado, coges un kit "Todo para pizza". Los starters funcionan igual — traen todos los componentes necesarios para una tarea concreta.

¡Vamos a probar! Añadamos el starter para una app web:

Maven

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Gradle

implementation 'org.springframework.boot:spring-boot-starter-web'

¡Listo! Spring Boot añadirá todas las librerías necesarias y puedes empezar a desarrollar de inmediato.

Starters útiles

Estos son los que verás más a menudo:

• spring-boot-starter-web — para aplicaciones web y REST API.
• spring-boot-starter-data-jpa — para trabajar con bases de datos usando JPA.
• spring-boot-starter-security — para añadir funcionalidades de seguridad.
• spring-boot-starter-test — para escribir tests.

Spring Boot incluso se ocupa de las situaciones extremas y añade spring-boot-starter-logging por defecto. Porque, ¿a quién no le gusta leer logs en producción, verdad?

2. Autoconfiguración (Auto-Configuration)

En los viejos y no tan buenos tiempos, cada proyecto Spring empezaba con horas de configuración XML.
Solo pensar en esos interminables <bean> da escalofríos. Por suerte, la autoconfiguración en Spring Boot cambió el juego: ahora Spring analiza tus dependencias y configura lo necesario automáticamente. ¿Añadiste H2 en el pom.xml? ¡Bam! Ya tienes la conexión a la base de datos lista.

¿Cómo funciona?

La autoconfiguración es un conjunto de reglas predeterminadas. Por ejemplo, si en tu classpath está la librería spring-web, Spring Boot configurará el servidor web. Si detecta spring-data-jpa, configurará automáticamente JPA y el EntityManager.

La anotación @EnableAutoConfiguration

Fijémonos en nuestra querida anotación @SpringBootApplication, que agrupa:

• @Configuration — indica que es una clase de configuración.
• @EnableAutoConfiguration — activa la magia de la autoconfiguración.
• @ComponentScan — escanea las clases de nuestra aplicación.

La autoconfiguración funciona por defecto. Pero, ¿y si necesitas desactivarla para algún componente específico?

Añádelo en la clase principal de la aplicación:

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

Ahora no habrá configuración automática para DataSource (la conexión a la base de datos): tú eliges qué y cómo configurar.

3. Servidores embebidos

Spring Boot viene con servidores embebidos, como Tomcat, Jetty o Undertow. Eso significa que ya no tienes que configurar y desplegar manualmente en un servidor externo. Ejecutas la aplicación y el servidor arranca junto con ella.

Ahora el servidor está "embebido", como el módulo Wi‑Fi en una nevera moderna.

Ventajas de los servidores embebidos

1. Facilidad de arranque: menos preocupaciones por la configuración de servidores externos.
2. Portabilidad: la aplicación funciona en cualquier sitio — localmente, en entornos de prueba o en la nube.
3. Soporte a DevOps: facilita la automatización y CI/CD. No necesitas instalar servidores por separado en cada etapa.

Cambiar la configuración del servidor

Puedes cambiar la configuración en application.properties o application.yml.

Por ejemplo, para cambiar el puerto:

server.port=8081

Ahora tu servidor escuchará en el puerto 8081. ¿Quieres cambiar de Tomcat a Jetty? Simplemente añade la dependencia:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

Y elimina Tomcat:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-tomcat</artifactId>
  <scope>provided</scope>
</dependency>

Cambia la dependencia y el servidor está listo.

Práctica: tu primera configuración mágica

Ahora que hemos repasado los fundamentos de los componentes de Spring Boot, vamos a montar una aplicación sencilla usando starters, autoconfiguración y un servidor embebido juntos.

Paso 1. Crea el proyecto

Ve a Spring Initializr y crea un proyecto nuevo con la dependencia spring-boot-starter-web.

Paso 2. Añade un controlador

Crea un REST-controller para saludar:

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "¡Hola, Spring Boot!";
    }
}

Paso 3. Configura el servidor

En application.properties añade esto:

server.port=8082

Ahora el servidor escuchará en el puerto 8082.

Paso 4. Ejecuta

Arranca la aplicación — y la magia de Spring Boot empezará a funcionar. Abre el navegador en http://localhost:8082/hello, y verás el amable "¡Hola, Spring Boot!"

Todo esto es solo el comienzo de tu aventura con Spring Boot. Dependencias Starters, autoconfiguración y servidores embebidos son la base sobre la que se construyen aplicaciones rápidas, cómodas y potentes. El siguiente paso es bucear en la configuración de la autoconfiguración para que tu magia sea realmente personalizada.