Rarezas de Spring Boot: 12 comportamientos que sorprenden

Spring Boot hace mucho por ti, y por eso a veces hace cosas que no esperabas: transacciones que no se deshacen, clases que no encuentra, acentos que se rompen o un 403 con la contraseña correcta. Aquí tienes doce comportamientos que hacen perder horas, cada uno con su salida real, el porqué y cómo evitarlo.

Cada rareza de esta página es un proyecto completo de Spring Boot 4.2 que se compiló, se arrancó y se probó con curl; lo que ves es lo que respondió. Ninguna es un error de Spring: son decisiones de diseño con buenas razones, que se vuelven trampas cuando no las conoces. Casi todas aparecen en preguntas de entrevistas de trabajo.

  1. Una clase en otro paquete no existe para Spring
  2. Los acentos de application.properties salen rotos
  3. @Transactional no deshace con una excepción verificada
  4. @Transactional se ignora si el método se llama desde la misma clase
  5. LazyInitializationException: los datos que no se cargaron
  6. Un bean hecho con new llega sin sus dependencias
  7. Un atributo de un controlador lo comparten todos los usuarios
  8. Un campo mal escrito en el JSON se ignora en silencio
  9. /productos y /productos/ no son la misma dirección
  10. data.sql se ejecuta antes de que exista la tabla
  11. Con Spring Security, el POST con la contraseña correcta responde 401
  12. Dos clases con el mismo nombre, en paquetes distintos, chocan

Una clase en otro paquete no existe para Spring

La aplicación está en com.ejemplo.tienda. Hay dos controladores casi iguales: uno en com.ejemplo.tienda.web y otro en com.ejemplo.reportes. Los dos compilan sin un solo aviso:

package com.ejemplo.reportes;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ReporteController {

    @GetMapping("/reportes")
    public String reportes() {
        return "reporte de ventas";
    }
}
terminal$ curl -s localhost:8080/productos
lista de productos
$ curl -s -o /dev/null -w "%{http_code}\n" localhost:8080/reportes
404

El de reportes responde 404, como si no existiera. @SpringBootApplication escanea su propio paquete y los que cuelgan de él (com.ejemplo.tienda.web sí, com.ejemplo.reportes no). Si la clase fuera un servicio que otro bean necesita, el síntoma sería el error de arranque de la lección 2, «required a bean … that could not be found». La solución es mover la clase debajo del paquete de la aplicación; ampliar el escaneo con @SpringBootApplication(scanBasePackages = …) también funciona, pero esconde el problema de organización.

Los acentos de application.properties salen rotos

El nombre de la tienda está en application.properties, y el lema, en application.yaml. Los dos archivos están guardados en UTF-8, como cualquier archivo de un editor moderno:

tienda.nombre=Panadería La Ñapa
tienda:
  lema: Pan de muerto todo el año, ¡y café!
terminal$ curl -s localhost:8080/
Panadería La Ñapa - Pan de muerto todo el año, ¡y café!

El nombre salió destrozado y el lema, perfecto. Spring Boot lee los .properties con la codificación ISO-8859-1, la tradicional de los archivos de propiedades de Java, y cada letra acentuada en UTF-8 ocupa dos bytes que se leen como dos caracteres. YAML siempre se lee en UTF-8. Las salidas: usar YAML, escribir los caracteres como \u00ed (la «í») o, mejor todavía, sacar los textos para el usuario de la configuración y ponerlos en archivos de mensajes.

@Transactional no deshace con una excepción verificada

Un servicio guarda un cargo y después descubre que la transferencia no puede terminar. Lanza una excepción para que se deshaga todo. Es una excepción verificada, de las que extienden Exception:

package com.ejemplo.banco;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class Transferencias {

    private final MovimientoRepository repo;

    public Transferencias(MovimientoRepository repo) {
        this.repo = repo;
    }

    public static class SaldoInsuficiente extends Exception {
        public SaldoInsuficiente() { super("saldo insuficiente"); }
    }

    @Transactional
    public void transferir() throws SaldoInsuficiente {
        repo.save(new Movimiento("cargo de $500 a la cuenta A"));
        throw new SaldoInsuficiente();   // la cuenta B no existe: hay que deshacer el cargo
    }

    @Transactional(rollbackFor = Exception.class)
    public void transferirBien() throws SaldoInsuficiente {
        repo.save(new Movimiento("cargo de $500 a la cuenta A"));
        throw new SaldoInsuficiente();
    }
}
terminal$ curl -s -X POST localhost:8080/transferir; echo
falló: saldo insuficiente
$ curl -s localhost:8080/movimientos; echo
1
$ curl -s -X POST localhost:8080/transferir-bien; echo
falló: saldo insuficiente
$ curl -s localhost:8080/movimientos; echo
1

Con transferir, la excepción llegó, el método falló… y el cargo se quedó guardado: hay 1 movimiento. Spring, por omisión, solo deshace la transacción con excepciones no verificadas (RuntimeException y Error), una regla heredada del viejo estándar EJB. Con rollbackFor = Exception.class, la segunda llamada sí se deshizo y el conteo siguió en 1. Elige una de dos: que tus excepciones de negocio extiendan RuntimeException, o pon rollbackFor siempre que el método declare throws.

@Transactional se ignora si el método se llama desde la misma clase

Ahora la excepción sí es una RuntimeException. El mismo método transferir se llama de dos formas: directamente desde el controlador, y a través de procesarLote, otro método del mismo servicio:

package com.ejemplo.banco;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class Transferencias {

    private final MovimientoRepository repo;

    public Transferencias(MovimientoRepository repo) {
        this.repo = repo;
    }

    public void procesarLote() {
        transferir();                    // llamada a un método de la misma clase
    }

    @Transactional
    public void transferir() {
        repo.save(new Movimiento("cargo de $500 a la cuenta A"));
        throw new IllegalStateException("la cuenta B no existe");
    }
}
terminal$ curl -s -X POST localhost:8080/directo; echo
falló
$ curl -s localhost:8080/movimientos; echo
0
$ curl -s -X POST localhost:8080/lote; echo
falló
$ curl -s localhost:8080/movimientos; echo
1

Llamado desde afuera, el cargo se deshizo (0 movimientos). Llamado desde procesarLote, se quedó guardado (1). La razón es cómo funciona @Transactional: Spring no le da al controlador tu objeto, sino un proxy, un intermediario que abre la transacción y luego llama a tu método. Cuando un método llama a otro de la misma clase con this, la llamada no pasa por el proxy y la anotación no hace nada; repo.save usó su propia transacción y la confirmó. Pasa lo mismo con @Cacheable, @Async y las demás anotaciones de este tipo, y también si el método es private. La solución: pon @Transactional en el método que llaman desde afuera (procesarLote), o mueve el otro a un bean distinto.

LazyInitializationException: los datos que no se cargaron

Un pedido tiene una lista de artículos guardada en otra tabla. El controlador lee el pedido y cuenta sus artículos. Con spring.jpa.open-in-view=false, como recomendamos en la lección 5:

package com.ejemplo.pedidos;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PedidoController {

    private final PedidoRepository repo;

    public PedidoController(PedidoRepository repo) {
        this.repo = repo;
    }

    @GetMapping("/pedidos/{id}/articulos")
    public int cuantos(@PathVariable long id) {
        Pedido p = repo.findById(id).orElseThrow();
        return p.getArticulos().size();
    }
}
terminal$ curl -s localhost:8080/pedidos/1/articulos; echo
{"timestamp":"2026-11-22T16:24:20.910Z","status":500,"error":"Internal Server Error","path":"/pedidos/1/articulos"}
registro de la aplicación2026-11-22T10:24:20.900-06:00 ERROR 93 --- [pedidos] [nio-8080-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed: org.hibernate.LazyInitializationException: Cannot lazily initialize collection of role 'com.ejemplo.pedidos.Pedido.articulos' with key '1' (no session)] with root cause

Las colecciones de JPA son perezosas (lazy): Hibernate no las lee hasta que alguien las usa, para no traer datos que quizá nadie necesita. Pero para leerlas necesita la sesión con la base, y esa sesión se cerró al terminar findById. Con open-in-view encendido, el valor de fábrica, la misma petición funciona:

terminal$ curl -s localhost:8080/pedidos/1/articulos; echo
3
registro de la aplicación: el aviso de Spring Boot2026-11-22T10:24:12.825-06:00  INFO 94 --- [pedidos] [           main] com.ejemplo.pedidos.PedidosApplication   : Starting PedidosApplication v0.0.1-SNAPSHOT using Java 25.0.5.1 with PID 94 (/tmp/lazy-open-in-view/target/lazy-open-in-view-0.0.1-SNAPSHOT.jar started by ubuntu in /tmp/lazy-open-in-view)
2026-11-22T10:24:17.009-06:00  WARN 94 --- [pedidos] [           main] JpaBaseConfiguration$JpaWebConfiguration : spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning

Funciona porque la sesión queda abierta durante toda la petición, incluida la escritura del JSON. Spring Boot mismo advierte que eso permite consultas a la base en cualquier parte de la petición, lo que esconde consultas de más y alarga el uso de las conexiones. La forma correcta: leer lo que necesitas dentro de un método @Transactional del servicio, o pedirlo de una vez en la consulta (join fetch en JPQL o @EntityGraph).

Un bean hecho con new llega sin sus dependencias

Este servicio usa la inyección en un atributo con @Autowired, la forma que aparece en muchos tutoriales viejos. El runner lo usa dos veces: el que le da Spring y uno creado con new:

package com.ejemplo.avisos;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class Avisos {

    @Autowired
    private Reloj reloj;

    public String recordatorio() {
        return "Hoy es " + reloj.hoy() + ": revisa tus pedidos";
    }
}
package com.ejemplo.avisos;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class AvisosApplication {

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

    @Bean
    CommandLineRunner probar(Avisos delContenedor) {
        return args -> {
            System.out.println("Del contenedor: " + delContenedor.recordatorio());
            Avisos hechoAMano = new Avisos();
            System.out.println("Hecho con new: " + hechoAMano.recordatorio());
        };
    }
}
salidaDel contenedor: Hoy es 2026-11-22: revisa tus pedidos
java.lang.NullPointerException: Cannot invoke "com.ejemplo.avisos.Reloj.hoy()" because "this.reloj" is null

El primero funciona; el segundo truena. Spring solo inyecta en los objetos que él crea. Un objeto hecho con new es un objeto normal de Java, y su atributo reloj se queda en null. Con inyección por constructor, este error ni siquiera compila: new Avisos() te obligaría a pasar un Reloj. Es la razón principal para preferirla.

Un atributo de un controlador lo comparten todos los usuarios

Un carrito de compras guardado en un atributo del controlador. Parece razonable, y funciona perfecto mientras lo pruebas tú solo:

package com.ejemplo.carrito;

import java.util.ArrayList;
import java.util.List;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/carrito")
public class CarritoController {

    private final List<String> articulos = new ArrayList<>();   // un solo carrito... para todos

    @PostMapping
    public List<String> agregar(@RequestParam String articulo) {
        articulos.add(articulo);
        return articulos;
    }

    @GetMapping
    public List<String> ver() {
        return articulos;
    }
}
terminal# Ana agrega dos cosas desde su celular
$ curl -s -X POST localhost:8080/carrito -d articulo=café; echo
["café"]
$ curl -s -X POST localhost:8080/carrito -d "articulo=pan dulce"; echo
["café","pan dulce"]
# Luis abre la tienda desde su computadora, por primera vez
$ curl -s localhost:8080/carrito; echo
["café","pan dulce"]

Luis ve el café y el pan de Ana. Los beans son únicos (singletons): hay un solo CarritoController para todas las peticiones de todos los usuarios, así que su atributo es de todos. Además, ArrayList no aguanta que dos peticiones lo cambien al mismo tiempo. Los datos de cada usuario van en la base de datos, con el usuario como llave, o en la sesión; un bean solo debe guardar en sus atributos cosas que no cambian, como otros beans o la configuración.

Un campo mal escrito en el JSON se ignora en silencio

El cliente escribió precioo, con doble o:

terminal$ curl -s -X POST localhost:8080/productos -H "Content-Type: application/json" -d '{"nombre":"Mouse","precioo":349.50}'; echo
{"nombre":"Mouse","precio":null}

Ni error ni aviso: el campo desconocido se descartó y el precio llegó como null. Spring Boot configura Jackson para que ignore los campos que no conoce, lo cual es útil para que un cliente con una versión más nueva de tu API no rompa a uno viejo, pero esconde los errores de dedo. Hay dos defensas. La buena: validar, con @NotNull en el precio y @Valid (lección 6). La estricta: pedirle a Jackson que falle con cualquier campo desconocido:

spring.jackson.deserialization.fail-on-unknown-properties=true
terminal$ curl -s -X POST localhost:8080/productos -H "Content-Type: application/json" -d '{"nombre":"Mouse","precioo":349.50}'; echo
{"timestamp":"2026-11-22T16:23:54.981Z","status":400,"error":"Bad Request","path":"/productos"}

/productos y /productos/ no son la misma dirección

Un controlador con @GetMapping("/productos") y dos peticiones que solo se distinguen por la diagonal del final:

terminal$ curl -s localhost:8080/productos; echo
lista de productos
$ curl -s localhost:8080/productos/; echo
{"timestamp":"2026-11-22T16:23:54.790Z","status":404,"error":"Not Found","path":"/productos/"}

Con la diagonal, 404. Hasta Spring Framework 5, las dos direcciones se trataban igual; desde la versión 6 (Spring Boot 3), ya no, porque esa equivalencia automática podía causar problemas de seguridad cuando una regla protegía una forma y no la otra. Si de verdad necesitas aceptar las dos, declara las dos rutas: @GetMapping({"/productos", "/productos/"}). Lo más sano es que tu API documente una sola y los clientes la usen tal cual.

data.sql se ejecuta antes de que exista la tabla

Para cargar datos de ejemplo, un archivo src/main/resources/data.sql con dos insert, y la entidad Producto. La aplicación no arranca:

insert into producto (id, nombre) values (1, 'Teclado mecánico');
insert into producto (id, nombre) values (2, 'Mouse inalámbrico');
registro: la aplicación no arranca (fragmento)…Table "PRODUCTO" not found (this database is empty);

Spring Boot ejecuta data.sql en cuanto tiene la conexión, y Hibernate crea las tablas de las entidades después. Primero el insert, luego el create table. Una línea cambia el orden:

spring.jpa.defer-datasource-initialization=true
terminal$ curl -s localhost:8080/productos; echo
[{"id":1,"nombre":"Teclado mecánico"},{"id":2,"nombre":"Mouse inalámbrico"}]

Con una base de datos real, no uses ni data.sql ni la creación automática de Hibernate: los cambios de estructura y los datos iniciales van en migraciones versionadas de Flyway, como en el ejemplo de Flyway.

Con Spring Security, el POST con la contraseña correcta responde 401

Basta con agregar la dependencia spring-boot-starter-security a un proyecto que funcionaba, sin escribir nada más. Al arrancar, el registro dice:

registro de la aplicaciónUsing generated security password: ae890091-36c3-4a35-95c0-5f1229650908
This generated password is for development use only. Your security configuration must be updated before running your application in production.

Spring Security protege todas las rutas de fábrica, con un usuario user y esa contraseña, que cambia en cada arranque. Probamos sin contraseña, con ella en un GET y con ella en un POST:

terminal$ curl -s -o /dev/null -w "%{http_code}\n" localhost:8080/productos
401
$ curl -s -u user:$CLAVE localhost:8080/productos
lista de productos
$ curl -s -o /dev/null -w "%{http_code}\n" -u user:$CLAVE -X POST localhost:8080/productos
401

El GET con contraseña funciona, pero el POST responde 401, «no autorizado», con el usuario y la contraseña correctos. El código engaña. Con el registro de seguridad en modo DEBUG se ve qué pasó de verdad:

registro con logging.level.org.springframework.security=DEBUG (solo el POST)2026-11-22T10:26:42.870-06:00 DEBUG 96 --- [seguridad-csrf] [nio-8080-exec-2] o.s.security.web.FilterChainProxy        : Securing POST /productos
2026-11-22T10:26:42.872-06:00 DEBUG 96 --- [seguridad-csrf] [nio-8080-exec-2] o.s.security.web.csrf.CsrfFilter         : Invalid CSRF token found for http://localhost:8080/productos
2026-11-22T10:26:42.872-06:00 DEBUG 96 --- [seguridad-csrf] [nio-8080-exec-2] o.s.s.w.access.AccessDeniedHandlerImpl   : Responding with 403 status code
2026-11-22T10:26:42.873-06:00 DEBUG 96 --- [seguridad-csrf] [nio-8080-exec-2] o.s.security.web.FilterChainProxy        : Securing GET /error

El filtro de CSRF rechazó la petición con un 403 antes de revisar la contraseña. CSRF es un ataque en el que una página maliciosa usa la sesión de tu navegador para mandar formularios a tu sitio, y Spring Security exige un código especial en cada POST, PUT y DELETE. Después, Spring intentó mostrar la página de error, /error; como esa petición también pasa por la seguridad y todavía no había usuario, terminó en 401. Para un sitio con formularios y sesión, la protección CSRF es justo lo que quieres. Para una API que solo usan programas, con las credenciales en cada petición, se configura distinto; lo verás en el ejemplo de seguridad básica. Y cuando un 401 o un 403 no tenga sentido, enciende ese DEBUG: dice qué filtro respondió.

Dos clases con el mismo nombre, en paquetes distintos, chocan

Dos equipos crearon cada uno su ReporteService: uno en com.ejemplo.tienda.ventas y otro en com.ejemplo.tienda.inventario. Para Java son clases distintas, y compila sin problema. Spring no arranca:

registro: la aplicación no arranca (fragmento)ConflictingBeanDefinitionException: Annotation-specified bean name 'reporteService' for bean class [com.ejemplo.tienda.ventas.ReporteService] conflicts with existing, non-compatible bean definition of same name and class [com.ejemplo.tienda.inventario.ReporteService]

Cada bean tiene un nombre, y por omisión es el de la clase con la primera letra en minúscula, sin el paquete: los dos se llaman reporteService. La solución es darle un nombre explícito a uno, como @Service("reporteInventario"), o, mejor, nombres de clase que digan qué reporte hace cada uno: ReporteVentas y ReporteInventario.

¿Te topaste con otra rareza? Todas las de esta página se comprobaron con Spring Boot 4.2.0 y Java 25 en un contenedor sin red. Para aprender Spring Boot desde el principio, empieza por el curso, y para ponerte a prueba, el test de 24 preguntas.

Cada rareza es un proyecto Maven completo, compilado con Spring Boot 4.2.0, Java 25 (Temurin 25.0.5.1) y Maven 3.10.1 en un contenedor limpio y sin red; las respuestas y los registros están copiados de esa ejecución.