Artículo

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 (el ApplicationContext) 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

  1. Escanea el paquete de la clase @SpringBootApplication y sus subpaquetes buscando @Component, @Service, @Repository, @Controller y @Configuration.
  2. Registra también los métodos @Bean de las clases @Configuration, útiles para clases que no son tuyas (un cliente HTTP, un ObjectMapper).
  3. Resuelve dependencias: para cada constructor busca un bean del tipo pedido. Si hay varios, usa el @Primary o el @Qualifier; si no puede decidir, la aplicación no arranca y te dice qué falta.
  4. Gestiona el ciclo de vida: crea, inyecta, llama a @PostConstruct y, al cerrar, a @PreDestroy.

Tienes el detalle de los estereotipos en @Component, @Service y @Repository y de los @Bean en @Configuration y @Bean.

Scopes

ScopeInstanciasUso típico
singleton (por defecto)Una por contenedorServicios sin estado: casi todo
prototypeUna cada vez que se pideObjetos con estado de corta duración
requestUna por petición HTTPDatos de la petición actual
sessionUna por sesión HTTPDatos 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é
ConstructorSíDependencias obligatorias, campos final, se prueba sin Spring
SetterPara dependencias opcionalesPermite cambiarlas después
Campo con @AutowiredNoOculta 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.

inversión de control ioc inyección de dependencias spring beans spring boot

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.

Compartir artículo