Inyección de dependencias
- Lección 10 de 32
- 10 min
- Intermedio
- 11 pasos
Si una clase hace `new` de su base de datos y lee la hora del sistema, no puedes probarla sin esa base de datos ni sin esperar al día correcto. La inyección de dependencias le da esas piezas desde afuera.
- Dependencias creadas dentro
- 0
- Resultado del test
- pasa siempre
- Duración del test
- 2 ms
- petición
- respuesta
- petición lenta
- petición fallida
Paso 1 de 11
Problema
Una clase que se fabrica sus propias piezas
TrialService responde una pregunta simple: ¿ya venció la prueba gratis de este usuario? Para eso busca al usuario en PostgreSQL y compara su fecha de fin con la hora actual.
El problema está en cómo consigue esas piezas: hace new PgUserRepo() en su propio código y llama a new Date() dentro del método. Quien use la clase no puede elegir otra cosa.
Escribes un test y en tu máquina, o en el servidor de CI, no hay base de datos: el test falla antes de comprobar nada.
Paso 2 de 11
Problema
Aunque haya base de datos, el resultado cambia cada día
Supón que levantas un PostgreSQL para los tests. Ahora el test corre, pero es lento (cada llamada viaja a la base de datos) y depende de los datos que haya ahí.
Peor: new Date() devuelve la hora real. Un usuario cuya prueba termina el 1 de enero «no vencido» hoy y «vencido» mañana. El mismo test pasa un día y falla al siguiente sin que nadie toque el código.
La duración que ves en el panel, 900 ms, es un valor de ejemplo para comparar más adelante.
Qué cambió
- PostgreSQL de prueba
- El test ya corre, pero lento y según el día
Paso 3 de 11
Concepto
La idea: recibir las piezas en vez de crearlas
Cambias una sola cosa: TrialService pide lo que necesita en su constructor, como parámetros. Ya no sabe qué base de datos hay detrás ni de dónde sale la hora.
Los parámetros tienen como tipo dos interfaces pequeñas: UserRepo, con find(id), y Clock, con now(). PgUserRepo y SystemClock las implementan; en el diagrama las flechas punteadas con triángulo salen de cada clase y apuntan a su interfaz.
Eso es la inyección de dependencias: alguien de afuera entrega las dependencias ya construidas. La lógica de isExpired no cambia, solo deja de usar new.
Qué cambió
- `new PgUserRepo()` y `new Date()` dentro de la clase
- Constructor con `UserRepo` y `Clock`
Paso 4 de 11
Técnica
Un solo lugar arma todo: la raíz de composición
Si nadie crea las dependencias dentro de las clases, alguien tiene que crearlas. Ese lugar es la raíz de composición: normalmente main.ts o el arranque de la app.
Ahí, y solo ahí, haces new PgUserRepo(pool) y new SystemClock(), y se los pasas a new TrialService(...). El resto del código recibe objetos listos.
Caso práctico: cambiar PostgreSQL por otro almacenamiento significa escribir otra clase que implemente UserRepo y cambiar una línea en la raíz, sin tocar TrialService.
Qué cambió
- `main.ts` crea y conecta las piezas
Paso 5 de 11
Solución
El test elige sus propias piezas
En el test haces lo mismo que main.ts, pero con piezas de mentira: un UserRepo que guarda un usuario en memoria y un Clock que siempre dice «1 de febrero de 2026».
Resultado: no hace falta base de datos, no depende del día y siempre da true. En el ejemplo, la duración baja de 900 ms a 2 ms (valores de ejemplo).
A esas piezas se les llama dobles de prueba (fakes o stubs). Sirven porque TrialService solo conoce las interfaces.
Qué cambió
- Repositorio en memoria y reloj fijo
- Base de datos en los tests unitarios
Paso 6 de 11
Técnica
Constructor, setter o interfaz
Martin Fowler le puso nombre a esta técnica en 2004. Prefirió «inyección de dependencias» porque «inversión de control» le parecía un término demasiado genérico, y describió tres formas de hacerla.
Por constructor: las dependencias entran al crear el objeto. Por setter: un método como setRepo(repo) las asigna después. Por interfaz: la clase implementa una interfaz cuyo método recibe la dependencia.
La de constructor tiene una ventaja práctica: el objeto nunca existe a medio armar, y la firma te dice de un vistazo qué necesita. Por eso es la que verás casi siempre.
Paso 7 de 11
Técnica
Un contenedor arma la raíz por ti
Con decenas de clases, escribir todos los new a mano en la raíz cansa. Un contenedor de DI hace ese trabajo: le dices qué clases existen y él las crea y las conecta.
Caso práctico, NestJS: listas los providers en un módulo y Nest resuelve cada parámetro del constructor por su tipo. Por defecto, cada provider es un singleton. Angular hace algo parecido: la clase pide sus dependencias con inject(), y providedIn: 'root' da una sola instancia para toda la app.
Ojo: el contenedor es opcional. La inyección funciona igual pasando parámetros a mano, como en los pasos anteriores.
Paso 8 de 11
Compromiso
La alternativa que esconde las piezas: Service Locator
Fowler comparó la inyección con otro enfoque, el Service Locator: un registro global al que la clase le pide sus piezas, con algo como Locator.get("repo").
También permite cambiar las piezas en los tests, pero la clase ahora depende del localizador, y su constructor ya no dice qué necesita. Para saberlo, tienes que leer todo el código.
En el diagrama la flecha cambia de sentido: TrialService sale a buscar, en vez de recibir.
Paso 9 de 11
Compromiso
Cuándo no inyectar
No todo es una dependencia. Una función pura como sumar(a, b) o un objeto de valor como un Email no tienen nada que cambiar en un test: créalos con new sin culpa.
Inyecta lo que habla con el mundo de afuera o lo que quieres cambiar: base de datos, red, reloj, archivos, aleatoriedad.
Y si un constructor pide seis o siete cosas, el problema no es la inyección: la clase hace demasiado. Divídela en vez de esconder la lista en un contenedor.
Paso 10 de 11
Concepto
Inyección de dependencias no es inversión de dependencias
Se parecen en el nombre, pero no son lo mismo. La inversión de dependencias (la D de SOLID) habla de hacia dónde apuntan las dependencias: hacia abstracciones como UserRepo, no hacia detalles como PostgreSQL.
La inyección es una técnica para entregar las dependencias. Puedes inyectar una clase concreta sin invertir nada, como en el ejemplo de NestJS.
Juntas funcionan mejor: en el diagrama todas las implementaciones, reales y de prueba, apuntan a las interfaces, y TrialService solo conoce las interfaces.
Paso 11 de 11
Resumen
Resumen
Una clase recibe sus dependencias en vez de crearlas con new.
La raíz de composición es el único lugar que construye y conecta las piezas.
Los tests pasan dobles: sin base de datos, sin reloj real, rápidos y estables.
El contenedor es opcional; el Service Locator esconde lo que la clase necesita.
No inyectes funciones puras ni objetos de valor, y un constructor enorme pide dividir la clase.
← → paso · R repetir · Espacio pausa
Aprenderás
- Por qué crear las dependencias dentro de una clase complica los tests (visto)
- Inyección por constructor y la raíz de composición (visto)
- Tests con dobles: sin base de datos ni reloj real (visto)
- Contenedores como los de NestJS y Angular, y el Service Locator (visto)
- Cuándo no inyectar y en qué se diferencia de la inversión de dependencias (visto)