Lección 179: Autoconfiguración de Spring Boot para microservicios

Uno de los principios clave de Spring Boot es "convention over configuration" (las convenciones priman sobre la configuración). Spring Boot ofrece un potente mecanismo de autoconfiguración: permite evitar la mayor parte de la configuración rutinaria y centrarte en la lógica de negocio del microservicio.

Imagina que añades al proyecto la dependencia para trabajar con bases de datos — spring-boot-starter-data-jpa. Spring Boot detectará automáticamente esa dependencia y configurará todos los componentes necesarios: el pool de conexiones, Hibernate como JPA provider, las transacciones.
Y esto es solo un ejemplo de las muchas autoconfiguraciones que Spring Boot proporciona listos para usar.

En esta lección analizaremos en detalle cómo funciona el mecanismo de autoconfiguración, cuándo usarlo y cómo, si hace falta, ajustarlo a tus necesidades.

Cómo funciona "bajo el capó"

La autoconfiguración se basa en la anotación @EnableAutoConfiguration, que Spring Boot usa activamente entre bastidores.

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

La anotación @SpringBootApplication incluye @EnableAutoConfiguration. Esto significa que Spring Boot escaneará todas las autoconfiguraciones disponibles y aplicará aquellas que encajen con las dependencias en tu classpath.

Principio "Opinionated Configuration" (Configuración por defecto)

Spring Boot tiene una opinión sobre cómo deberían funcionar las cosas. Los desarrolladores suelen decirlo así: "strong opinions, but weakly held" — postura clara, pero dispuesta a ceder. Esto supone dos reglas sencillas:

1. Spring Boot ofrece ajustes razonables por defecto nada más instalarlo
2. Puedes cambiar cualquier ajuste fácilmente para adaptarlo a tus necesidades

Veamos un ejemplo. Cuando añades spring-boot-starter-web, Spring Boot configurará por sí mismo:

• Un servidor embebido (Tomcat, Jetty o Undertow)
• Puertos HTTP
• Todos los beans necesarios para el REST API

Y tu aplicación estará lista para funcionar. Pero si quieres cambiar la configuración de Tomcat — ningún problema, Spring Boot no se opondrá.

Para qué sirve la autoconfiguración en microservicios

La autoconfiguración es especialmente útil en arquitecturas de microservicios, donde cada servicio tiene un conjunto mínimo de responsabilidades:

1. Manejar peticiones REST API.
2. Almacenar datos.
3. Proveer monitoring y logging.

Con la autoconfiguración puedes librarte de la rutina. Por ejemplo:

• Configuración de la base de datos.
• Configuración de un broker de mensajes, por ejemplo Kafka.
• Activación del monitoring (Spring Boot Actuator).
• Configuración de caches, seguridad y gestión de transacciones.

Así puedes concentrarte en desarrollar la funcionalidad de tu microservicio, y Spring Boot se ocupará del resto.

¿Cómo desactivar la autoconfiguración?

Claro, la automatización está bien, pero a veces quieres control total. Por ejemplo, si no quieres que Spring Boot configure Hibernate automáticamente, puedes excluir ese componente de la autoconfiguración.

Usa la anotación @SpringBootApplication con el parámetro exclude:

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

O, si necesitas desactivar la configuración solo parcialmente:

@SpringBootApplication
public class MyMicroserviceApplication {

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

    @Bean
    public SomeSpecificBean customBean() {
        return new SomeSpecificBean();
    }
}

Configurar la autoconfiguración a tu manera

Puedes sobrescribir las configuraciones por defecto de la autoconfiguración mediante los archivos application.yml o application.properties.

Por ejemplo, configuración de la base de datos:

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: user
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver

Configuración del servidor embebido:

server:
  port: 8081
  servlet:
    context-path: /api

Configuración del logging:

logging:
  level:
    org.springframework: DEBUG

Práctica: Crear un microservicio usando la autoconfiguración

Paso 1: Crear un nuevo proyecto con Spring Initializr

1. Elige las opciones:
   • Maven o Gradle.
   • Java 11 o 17.
   • Dependencies: Spring Web, Spring Data JPA, H2 Database (o PostgreSQL/MySQL).
2. Descarga el proyecto y ábrelo en tu IDE.

Paso 2: Configurar application.yml

Crea el archivo application.yml en src/main/resources y añade la configuración mínima para H2 Database:

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

server:
  port: 8080

Paso 3: Crear la entidad y el repositorio

Añade una entidad, por ejemplo, Product:

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

@Entity
public class Product {
    @Id
    @GeneratedValue
    private Long id;

    private String name;
    private double price;

    // Getters y setters
}

Y el repositorio:

import org.springframework.data.jpa.repository.JpaRepository;
public interface ProductRepository extends JpaRepository<Product, Long> {}

Paso 4: Implementar el REST API

Crea un controlador para manejar productos:

import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/products")
public class ProductController {

    private final ProductRepository productRepository;

    public ProductController(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    @GetMapping
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productRepository.save(product);
    }
}

Paso 5: Arranca la aplicación

Ejecuta tu microservicio y prueba los endpoints con Postman o curl. En este punto ya estás aprovechando la autoconfiguración para la base de datos, JPA y el REST API.

Recomendaciones para usar la autoconfiguración

• No te compliques: la autoconfiguración cubre el 90% de los casos típicos, así que no pierdas tiempo intentando "ganarle" a Spring.
• Evita duplicar: la configuración manual en código y la configuración vía application.yml pueden entrar en conflicto. Elige una sola manera.
• Lee la documentación con atención: cada spring-boot-starter viene con una descripción detallada de lo que configura exactamente.

Puedes aprender más sobre la autoconfiguración en la documentación oficial de Spring Boot.