Inversión de control (IoC) en Spring: cómo funciona el contenedor
Qué es la inversión de control y la inyección de dependencias en Spring: el contenedor IoC, beans, @Primary, @Qualifier y scopes, con un ejemplo probado.
En resumen: con inversión de control (IoC) tus clases no crean sus dependencias con
new: las declaran en el constructor y es el contenedor de Spring (elApplicationContext) quien las crea, decide qué implementación pasar y gestiona su ciclo de vida. Eso es la inyección de dependencias. El resultado son clases desacopladas que puedes probar sin Spring pasándoles dobles a mano. Probado con Spring Boot 4.1.2 y Java 21.
Vídeo explicativo
Sin IoC y con IoC
// Sin IoC: la clase decide y crea su dependencia
class RegistroService {
private final EmailNotificador notificador = new EmailNotificador();
}
RegistroService queda atada a EmailNotificador: para enviar SMS o para probarla sin enviar emails hay que cambiar su código. Con IoC, el control de qué se crea se invierte: pasa de la clase al contenedor.
Ejemplo completo
interface Notificador {
String enviar(String destinatario, String mensaje);
}
@Component
@Primary // si alguien pide un Notificador sin más detalle, recibe este
class EmailNotificador implements Notificador {
@Override
public String enviar(String destinatario, String mensaje) {
return "EMAIL a " + destinatario + ": " + mensaje;
}
}
@Component("sms")
class SmsNotificador implements Notificador {
@Override
public String enviar(String destinatario, String mensaje) {
return "SMS a " + destinatario + ": " + mensaje;
}
}
// Con IoC: las recibe por constructor y es Spring quien decide qué instancia pasar.
@Service
class RegistroService {
private final Notificador principal;
private final Notificador urgente;
RegistroService(Notificador principal, @Qualifier("sms") Notificador urgente) {
this.principal = principal;
this.urgente = urgente;
}
String registrar(String usuario) {
return principal.enviar(usuario, "bienvenido") + " | " + urgente.enviar(usuario, "código 1234");
}
}
class Carrito {
private int articulos;
int anadir() {
return ++articulos;
}
}
@Configuration
class AppConfig {
@Bean
@Scope("prototype") // una instancia nueva cada vez que se pide
Carrito carrito() {
return new Carrito();
}
}
Lo comprobamos con un test que pide los beans al contenedor:
RegistroService servicio = contexto.getBean(RegistroService.class);
System.out.println(servicio.registrar("ana"));
System.out.println("Mismo RegistroService: " + (servicio == contexto.getBean(RegistroService.class)));
Carrito c1 = contexto.getBean(Carrito.class);
Carrito c2 = contexto.getBean(Carrito.class);
c1.anadir();
c1.anadir();
System.out.println("Mismo Carrito: " + (c1 == c2) + ", c1 tiene " + c1.anadir() + ", c2 tiene " + c2.anadir());
System.out.println("Beans de tipo Notificador: " + String.join(", ", contexto.getBeanNamesForType(Notificador.class)));
EMAIL a ana: bienvenido | SMS a ana: código 1234
Mismo RegistroService: true
Mismo Carrito: false, c1 tiene 3, c2 tiene 1
Beans de tipo Notificador: emailNotificador, sms
Y la misma clase, probada sin Spring:
RegistroService servicio = new RegistroService(
(d, m) -> "FALSO-1 " + d, (d, m) -> "FALSO-2 " + d);
System.out.println(servicio.registrar("luis"));
FALSO-1 luis | FALSO-2 luis
Esto es lo que de verdad aporta la inyección por constructor: la clase no sabe nada del contenedor.
Qué hace el contenedor
- Escanea el paquete de la clase
@SpringBootApplicationy sus subpaquetes buscando@Component,@Service,@Repository,@Controllery@Configuration. - Registra también los métodos
@Beande las clases@Configuration, útiles para clases que no son tuyas (un cliente HTTP, unObjectMapper). - Resuelve dependencias: para cada constructor busca un bean del tipo pedido. Si hay varios, usa el
@Primaryo el@Qualifier; si no puede decidir, la aplicación no arranca y te dice qué falta. - Gestiona el ciclo de vida: crea, inyecta, llama a
@PostConstructy, al cerrar, a@PreDestroy.
Tienes el detalle de los estereotipos en @Component, @Service y @Repository y de los @Bean en @Configuration y @Bean.
Scopes
| Scope | Instancias | Uso típico |
|---|---|---|
singleton (por defecto) | Una por contenedor | Servicios sin estado: casi todo |
prototype | Una cada vez que se pide | Objetos con estado de corta duración |
request | Una por petición HTTP | Datos de la petición actual |
session | Una por sesión HTTP | Datos del usuario en aplicaciones con sesión |
Como los singleton se comparten entre todos los hilos, no deben guardar estado mutable en sus campos.
Formas de inyectar
| Forma | ¿Recomendada? | Por qué |
|---|---|---|
| Constructor | Sí | Dependencias obligatorias, campos final, se prueba sin Spring |
| Setter | Para dependencias opcionales | Permite cambiarlas después |
Campo con @Autowired | No | Oculta dependencias e impide final; obliga a usar reflexión en los tests |
Con un único constructor no hace falta @Autowired. Más en @Autowired en Spring Boot.
Preguntas frecuentes
¿IoC e inyección de dependencias son lo mismo?
IoC es el principio (otro decide por ti); la inyección de dependencias es la forma concreta de aplicarlo que usa Spring.
¿Qué pasa si hay dos beans del mismo tipo?
Spring falla al arrancar con NoUniqueBeanDefinitionException, salvo que uno sea @Primary o que el punto de inyección use @Qualifier.
¿Y las dependencias circulares?
Desde Spring Boot 2.6 están prohibidas por defecto. Si A necesita a B y B a A, normalmente falta una tercera clase o un evento.
¿Puedo tener un núcleo de negocio sin anotaciones de Spring?
Sí: registra tus clases con métodos @Bean en una clase de configuración y tus servicios quedan como clases Java normales. Es la base de la arquitectura hexagonal.
Sigue aprendiendo
El contenedor, los beans, sus scopes y su ciclo de vida son el tema del curso de Spring Boot Core. Para la base, qué es Spring Boot y cómo funciona.
Newsletter Semanal de Java
Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.
Sin spam. Cancela cuando quieras.