Spring Boot 4 y Spring Framework 7: La Nueva Era de Java para Microservicios Rápidos y Seguros

Modularidad: Desempacando la Maleta

Antes, el módulo spring-boot-autoconfigure era un artefacto gigante que contenía lógica de configuración para casi todo, incluso si no lo utilizabas. Esto generaba lo que se conoce como "classpath noise" (ruido en el classpath).

La Solución: Spring Boot 4 ha dividido este módulo masivo en artefactos más pequeños y enfocados. Ahora, la autoconfiguración se distribuye en módulos especializados que solo se cargan cuando son necesarios.

Beneficios concretos:

1. Arranque más rápido: Menos código que escanear significa tiempos de inicio reducidos.
2. Menor consumo de memoria: Solo cargas lo que realmente necesitas.
3. Mejor experiencia de desarrollo: Tu IDE te dará sugerencias más precisas, sin mostrar clases y propiedades irrelevantes.
4. Imágenes nativas optimizadas: La generación de imágenes nativas con GraalVM es más eficiente.

Compilación AOT y GraalVM

Spring Boot 4 está totalmente alineado con GraalVM 24 o superior. El procesamiento AOT (Ahead-of-Time) se ha optimizado significativamente:

• Tiempos de compilación más rápidos
• Huella de memoria reducida al inicio
• Mejor análisis estático para eliminar código muerto
• Compatibilidad mejorada con reflection hints

La nueva anotación @ConfigurationPropertiesSource permite una modularización aún más granular, facilitando que solo se procesen las propiedades de configuración relevantes para tu aplicación.

¿Qué es JSpecify?

JSpecify es un estándar colaborativo respaldado por Google, JetBrains, Meta, Oracle y otros gigantes tecnológicos. Proporciona anotaciones explícitas para indicar si un valor puede ser nulo o no.

El Cambio de Juego: @NullMarked

Puedes marcar un paquete entero como seguro contra nulos creando un archivo package-info.java:

// src/main/java/com/tuempresa/servicio/package-info.java
@org.jspecify.annotations.NullMarked
package com.tuempresa.servicio;

Con esto, tu IDE (como IntelliJ IDEA 2025.3+ que lo soporta nativamente) te alertará mientras escribes el código si intentas utilizar un valor que podría ser nulo en un contexto que espera un valor no nulo.

Ejemplo práctico:

@NullMarked
package com.ejemplo.usuarios;

public class UsuarioService {

    // El IDE advertirá si intentas pasar null
    public Usuario crearUsuario(@NonNull String nombre, @Nullable String apellido) {
        // nombre nunca es null - seguro de usar directamente
        String nombreCompleto = nombre.toUpperCase();

        // apellido puede ser null - debes verificar
        if (apellido != null) {
            nombreCompleto += " " + apellido.toUpperCase();
        }

        return new Usuario(nombreCompleto);
    }
}

Esto reduce drásticamente el riesgo de un NullPointerException en producción, detectando problemas en tiempo de desarrollo.

Adiós a RestTemplate

RestTemplate ha sido oficialmente deprecado en Spring Framework 7 y será removido en versiones futuras. El código era verboso, difícil de probar y no aprovechaba las características modernas de Java.

La Nueva Era: RestClient y @HttpExchange

RestClient es el reemplazo moderno de RestTemplate, con una API fluida y estilo builder. Pero lo más revolucionario es la capacidad de crear clientes HTTP declarativos usando @HttpExchange.

Ejemplo de Cliente Declarativo:

package com.tuempresa.clients;

import org.springframework.web.service.annotation.GetExchange;
import org.springframework.web.service.annotation.PostExchange;
import org.springframework.web.service.annotation.HttpExchange;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;

@HttpExchange("/api/productos")
public interface ProductoClient {

    @GetExchange("/{id}")
    Producto obtenerProducto(@PathVariable("id") String id);

    @GetExchange
    List<Producto> listarProductos();

    @PostExchange
    Producto crearProducto(@RequestBody Producto producto);
}

Configuración del Cliente:

@Configuration
public class ClientConfig {

    @Bean
    public ProductoClient productoClient(RestClient.Builder builder) {
        RestClient restClient = builder
            .baseUrl("https://api.ejemplo.com")
            .build();

        HttpServiceProxyFactory factory = HttpServiceProxyFactory
            .builderFor(RestClientAdapter.create(restClient))
            .build();

        return factory.createClient(ProductoClient.class);
    }
}

Ventajas:

• Cero boilerplate: Defines qué llamar, no cómo llamar
• Más fácil de probar: Puedes mockear fácilmente la interfaz
• Type-safe: Aprovecha el sistema de tipos de Java
• Integración nativa: No necesitas dependencias adicionales

Spring Boot 4 también introduce mejoras en la configuración automática de estos clientes, con el atributo clientType que permite cambiar entre RestClient (por defecto) y WebClient (para casos reactivos) sin modificar el código del cliente.

Resiliencia Nativa

Las anotaciones de resiliencia, antes dependientes del proyecto externo Spring Retry, ahora están incorporadas en Spring Framework 7:

• @Retryable: Aplica lógica de reintento si un método falla
• @ConcurrencyLimit: Limita las llamadas concurrentes a un método
• @EnableResilientMethods: Activa estas anotaciones en tus beans

Ejemplo de Resiliencia:

@Service
@EnableResilientMethods
public class PagoService {

    @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public PagoRespuesta procesarPago(PagoRequest request) {
        // Si falla, se reintenta hasta 3 veces con 1 segundo de espera
        return pagoGateway.procesar(request);
    }

    @ConcurrencyLimit(maxConcurrency = 10)
    public Report generarReporte() {
        // Máximo 10 llamadas concurrentes
        return reportService.generar();
    }
}

Versionamiento Nativo de APIs

Spring Framework 7 resuelve la "pesadilla" del versionamiento de APIs REST. Ahora puedes usar el atributo version en @RequestMapping y sus variantes:

Ejemplo de Controller con Versionamiento:

@RestController
@RequestMapping("/api/pedidos")
public class PedidoController {

    // Versión 1: Respuesta simple
    @GetMapping(version = "1", produces = MediaType.APPLICATION_JSON_VALUE)
    public List<PedidoV1> getPedidosV1() {
        return pedidoService.obtenerPedidosSimples();
    }

    // Versión 2: Respuesta enriquecida con metadatos
    @GetMapping(version = "2", produces = MediaType.APPLICATION_JSON_VALUE)
    public PedidoResponseV2 getPedidosV2() {
        return pedidoService.obtenerPedidosCompletos();
    }
}

Configuración Centralizada:

@Configuration
public class ApiVersioningConfig implements WebMvcConfigurer {

    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
        // Estrategia por header
        configurer.apiVersioning(builder -> builder
            .strategy(VersionStrategy.HEADER)
            .headerName("API-Version")
        );

        // O por path: /v1/pedidos, /v2/pedidos
        // O por parámetro de query: /pedidos?version=1
    }
}

La estrategia de versionamiento se define de forma centralizada, lo que te permite cambiar de estrategia (path, header, query parameter) sin reescribir tus controllers.

Integración con OpenTelemetry

• Micrometer 2.0: Actualizado con mejoras de rendimiento
• OpenTelemetry nativo: Starter oficial incluido en Spring Boot 4
• Correlación automática: Logs, métricas y trazas correlacionadas automáticamente

La Anotación @Observed

Crea métricas y trazas automáticamente para cualquier método:

@Service
public class InventarioService {

    @Observed(name = "inventario.verificar", contextualName = "verificarDisponibilidad")
    public boolean verificarDisponibilidad(String productoId) {
        // Automáticamente genera métricas de:
        // - Tiempo de ejecución
        // - Número de llamadas
        // - Tasa de errores
        return inventarioRepository.existeStock(productoId);
    }
}

Monitoreo de Salud SSL

El Actuator ahora realiza monitoreo automático de certificados SSL. Si un certificado está a punto de expirar (por defecto, dentro de 14-30 días), el endpoint /actuator/health lo reporta explícitamente:

{
  "status": "UP",
  "components": {
    "ssl": {
      "status": "WARNING",
      "details": {
        "certificate": "api.ejemplo.com",
        "expiresIn": "12 days",
        "expiryDate": "2025-12-05"
      }
    }
  }
}

Esto es un "salvavidas" para evitar pánico en producción cuando los certificados expiran inesperadamente.

JdbcClient: Código Más Limpio

El nuevo JdbcClient elimina la verbosidad, adoptando un patrón builder que es más intuitivo y fácil de leer:

Antes (JdbcTemplate):

public List<Persona> findAll() {
    return jdbcTemplate.query(
        "SELECT id, nombre, edad FROM persona",
        new RowMapper<Persona>() {
            @Override
            public Persona mapRow(ResultSet rs, int rowNum) throws SQLException {
                Persona p = new Persona();
                p.setId(rs.getLong("id"));
                p.setNombre(rs.getString("nombre"));
                p.setEdad(rs.getInt("edad"));
                return p;
            }
        }
    );
}

Ahora (JdbcClient):

public List<Persona> findAll() {
    return jdbcClient.sql("SELECT id, nombre, edad FROM persona")
        .query((rs, rowNum) -> new Persona(
            rs.getLong("id"),
            rs.getString("nombre"),
            rs.getInt("edad")
        ))
        .list();
}

// O incluso más simple con mapeo automático
public List<Persona> findAll() {
    return jdbcClient.sql("SELECT * FROM persona")
        .query(Persona.class)
        .list();
}

Consultas con parámetros:

public Optional<Persona> findById(Long id) {
    return jdbcClient.sql("SELECT * FROM persona WHERE id = :id")
        .param("id", id)
        .query(Persona.class)
        .optional();
}

Operaciones de escritura:

public int actualizarEdad(Long id, int nuevaEdad) {
    return jdbcClient.sql("UPDATE persona SET edad = :edad WHERE id = :id")
        .param("edad", nuevaEdad)
        .param("id", id)
        .update();
}

Este nuevo enfoque:

• Es más conciso y legible
• Aprovecha lambdas y referencias de métodos
• Se integra mejor con Optional para manejo seguro de nulos
• Mejora el soporte para AOT y GraalVM

Test Slices Más Granulares

Nuevos test slices para probar componentes específicos sin cargar todo el contexto de la aplicación:

@HttpServiceClientTest
class ProductoClientTest {

    @Autowired
    private ProductoClient productoClient;

    @Test
    void deberiaObtenerProducto() {
        // Solo carga la configuración necesaria para clientes HTTP
        Producto producto = productoClient.obtenerProducto("123");
        assertThat(producto).isNotNull();
    }
}

TestRestTemplate Mejorado

Mejor integración con el nuevo RestClient y soporte para respuestas tipadas:

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class IntegrationTest {

    @Autowired
    private TestRestClient restClient;

    @Test
    void deberiaCrearUsuario() {
        Usuario nuevoUsuario = new Usuario("Juan", "Pérez");

        Usuario creado = restClient.post()
            .uri("/api/usuarios")
            .body(nuevoUsuario)
            .exchange()
            .expectStatus().isCreated()
            .expectBody(Usuario.class)
            .returnResult();

        assertThat(creado.getId()).isNotNull();
    }
}

Cambios Obligatorios

1. Jackson 3.x: Actualización de Jackson de 2.x a 3.x
2. Namespace Jakarta: Migración completa de javax.* a jakarta.*
3. Java 17 mínimo: Aunque se recomienda Java 21+
4. Kotlin 2.2+: Si usas Kotlin

Deprecaciones Importantes

• RestTemplate → RestClient o clientes declarativos
• Configuraciones con lambdas son obligatorias en Spring Security
• Varias propiedades de configuración han cambiado de nombre

Herramientas de Migración

Spring recomienda usar OpenRewrite para automatizar gran parte de la migración:

<plugin>
    <groupId>org.openrewrite.maven</groupId>
    <artifactId>rewrite-maven-plugin</artifactId>
    <version>5.42.0</version>
    <configuration>
        <activeRecipes>
            <recipe>org.openrewrite.java.spring.boot4.UpgradeSpringBoot_4_0</recipe>
        </activeRecipes>
    </configuration>
</plugin>

Este plugin puede automatizar:

• Actualización de dependencias
• Cambios de namespace javax → jakarta
• Migración de APIs deprecadas
• Actualización de archivos de configuración