Repository: separar el dominio de la base de datos
- Lección 29 de 32
- 10 min
- Intermedio
- 12 pasos
Una regla de negocio con SQL dentro solo se puede probar con una base de datos en marcha. Vas a poner el acceso a datos detrás de una interfaz que se usa como una colección, con una versión en SQL y otra en memoria para los tests.
- Consultas SQL en la regla
- 0
- Lo que pide el test
- un Map
- petición
- respuesta
Paso 1 de 12
Problema
La regla de negocio lleva SQL dentro
Tu tienda cierra pedidos con closeOrder(db, id). La regla es una sola: solo se cierra un pedido abierto. Pero para aplicarla, la función arma un SELECT, lee la fila y después arma un UPDATE.
La regla y el acceso a datos están mezclados en las mismas líneas. Cambiar una tabla, una columna o la base de datos obliga a abrir el código que decide qué es un pedido cerrado.
Qué cambió
- closeOrder() con 2 consultas SQL
Paso 2 de 12
Problema
Probar un if exige una base de datos
Quieres un test para esa regla: un pedido abierto se cierra y uno cerrado lanza un error. Como la función habla con PostgreSQL, el test también: necesitas la base en marcha, la tabla creada y un pedido insertado antes de empezar.
El test es más lento y más frágil que la regla que prueba. Si la base no arranca en CI, falla un test que no tiene nada que ver con la base.
Qué cambió
- un test que necesita PostgreSQL
Paso 3 de 12
Concepto
Una colección de pedidos
La idea de Repository: el dominio no habla con la base, habla con algo que se usa como una colección de pedidos. Le pides uno por su id con findById y le das uno para guardar con save. Cómo se guarda no es asunto del dominio.
Martin Fowler lo recoge en el catálogo de su libro Patterns of Enterprise Application Architecture: media entre el dominio y la capa que mapea los datos, y lo atribuye a Edward Hieatt y Rob Mee. No es un patrón GoF: no está en el libro de 1994.
Qué cambió
- interface OrderRepository
Paso 4 de 12
Solución
La regla solo conoce la interfaz
Ahora closeOrder recibe un OrderRepository en vez de la conexión. Busca el pedido con findById, aplica la regla y lo guarda con save. En la función ya no queda ninguna consulta SQL.
La interfaz vive junto al dominio y habla en sus términos: pedidos, no filas. El dominio dice lo que necesita, y es el código de la base de datos el que tiene que adaptarse a eso.
Qué cambió
- SELECT y UPDATE en closeOrder()
- repo.findById y repo.save
Paso 5 de 12
Técnica
El SQL se muda a una clase
El SQL no desaparece: se muda a PgOrderRepository, una clase que implementa OrderRepository. Su findById hace el SELECT y su save hace el UPDATE.
Mira el diagrama: closeOrder() y la interfaz quedan en el dominio; la clase y PostgreSQL, en infraestructura. Si mañana cambias de base o de librería, reescribes esa clase y la regla no se entera.
Qué cambió
- PgOrderRepository implements OrderRepository
Paso 6 de 12
Técnica
Alguien elige cuál usar
closeOrder no crea su repositorio: lo recibe. Lo crea el punto de arranque, main(), que construye PgOrderRepository con la conexión y se lo pasa a cada llamada.
Es la inyección de dependencias de su propia lección: la elección se hace una vez, en el borde, y el resto del código solo ve la interfaz.
Qué cambió
- main() crea PgOrderRepository
Paso 7 de 12
Técnica
Un repositorio falso para los tests
Como closeOrder solo conoce la interfaz, puedes darle otra implementación. InMemoryOrderRepository guarda los pedidos en un Map: findById lee del mapa y save escribe en él.
Es un fake: funciona de verdad, pero sin base de datos. Guarda una copia con { ...o } para que cambiar el objeto fuera del repositorio no cambie lo guardado, igual que pasa con una base.
Qué cambió
- InMemoryOrderRepository con un Map
Paso 8 de 12
Solución
El test de la regla, sin base
El test crea el repositorio en memoria, guarda un pedido abierto, llama a closeOrder y lee el resultado. Dentro de closeOrder hay dos viajes al repositorio: findById y save.
No hay que levantar ni limpiar nada: cada test crea su propio Map. Y es la misma función que corre en producción con PgOrderRepository. Lo que este test no prueba es tu SQL: para eso, unos pocos tests de PgOrderRepository contra una base real.
Qué cambió
- PostgreSQL en el test de la regla
- test con InMemoryOrderRepository
Paso 9 de 12
Concepto
Ya lo usas: Spring Data
En Java, Spring Data lleva la idea más lejos. Declaras una interfaz que extiende CrudRepository<Order, Long> y Spring aporta la implementación: no escribes la clase con el SQL.
Esa interfaz ya trae save, findById, findAll, count, delete y existsById. Tu servicio recibe OrderRepository, como antes closeOrder, y no sabe cómo se hacen las consultas.
Qué cambió
- PgOrderRepository → la aporta Spring
Paso 10 de 12
Compromiso
La interfaz crece y las consultas siguen ahí
Cada pantalla nueva pide su consulta: los pedidos de un cliente, los abiertos hace más de 30 días, una página de resultados, el conteo por estado. Si cada una se vuelve un método, la interfaz crece, y con ella cada implementación, también el fake.
Y el repositorio no vuelve rápida una consulta lenta. Si lees 100 pedidos y después pides el cliente de cada uno, siguen siendo 1 + 100 = 101 consultas (el problema N+1), solo que ahora quedan escondidas detrás de un método.
Qué cambió
- 4 métodos de consulta
- el fake crece con ellos
Paso 11 de 12
Compromiso
Cuándo no hace falta
Si la app es un CRUD sin reglas, como un listOrders() que solo lee filas y las devuelve, no hay lógica que proteger: el repositorio sería una capa que solo reenvía llamadas.
Tampoco hace falta si tu ORM ya te da una abstracción que puedes probar y te sirve. Úsalo cuando haya reglas de dominio que quieras probar sin base o cuando de verdad vayas a cambiar de almacenamiento.
Qué cambió
- OrderRepository en un CRUD simple
Paso 12 de 12
Resumen
El dominio pide, la infraestructura resuelve
Repository pone el acceso a datos detrás de una interfaz que se usa como una colección: findById, save. La regla queda sin SQL, el SQL vive en una clase de infraestructura y los tests usan un fake en memoria.
No es GoF: viene del catálogo de Fowler, y lo ves en CrudRepository de Spring Data. Cuesta una capa más y una interfaz que crece con las consultas; en un CRUD sin reglas, sáltalo.
← → paso · R repetir · Espacio pausa
Aprenderás
- Ver por qué el SQL dentro de una regla complica probarla. (visto)
- Poner el acceso a datos detrás de una interfaz tipo colección. (visto)
- Implementarla con SQL y con un fake en memoria para los tests. (visto)
- Reconocer el patrón en `CrudRepository` de Spring Data. (visto)
- Saber cuándo no usarlo y qué cuesta. (visto)