Abstract Factory: familias de objetos que encajan
- Lección 6 de 32
- 12 min
- Intermedio
- 11 pasos
Mezcla piezas de dos bases de datos y la consulta se rompe. Aquí verás cómo un kit te entrega siempre piezas de la misma familia.
- Familias
- 3
- Quién elige la familia
- main.ts
- petición
- respuesta
- petición fallida
Paso 1 de 11
Problema
Dos bases de datos, piezas que no encajan
findUser crea a mano una conexión de PostgreSQL y arma la consulta con el marcador de parámetro de MySQL.
Cada base escribe los parámetros a su manera: PostgreSQL los numera como $1, $2; MySQL usa ?. Con un ?, la consulta que llega a PostgreSQL no encaja.
Qué cambió
- PgConn y el marcador de MySQL en el mismo código
- Consulta fallida
Paso 2 de 11
Concepto
Una familia: piezas hechas para ir juntas
Una familia es un grupo de objetos que dependen unos de otros: la conexión de PostgreSQL espera parámetros al estilo de PostgreSQL.
Elegir pieza por pieza es justo lo que permite el error. Lo que conviene elegir es la familia completa, una sola vez.
Qué cambió
- Familia PostgreSQL: PgConn + PgParam
- Familia MySQL: MyConn + MyParam
Paso 3 de 11
Concepto
Un objeto que crea la familia entera
Una Abstract Factory es una interfaz con un método de creación por producto: aquí placeholder() y connect(). Llamémosla kit: SqlKit.
Una Factory responde «¿qué clase creo?». Una Abstract Factory responde «¿de qué familia creo todo?». No es «una Factory con clase abstracta»: lo que importa son los varios productos.
Qué cambió
- Interfaz SqlKit
- findUser pide al kit en vez de crear
Paso 4 de 11
Técnica
Un kit concreto por familia
PgKit implementa SqlKit y solo crea piezas de PostgreSQL: su placeholder(1) devuelve $1 y su connect() devuelve una PgConn.
No hace falta herencia: en TypeScript un objeto literal con esas funciones ya es un kit válido.
Qué cambió
- PgKit implements SqlKit
- PgKit crea PgConn y PgParam
Paso 5 de 11
Solución
findUser solo conoce SqlKit
Ahora findUser pide el marcador y la conexión al mismo kit. Con PgKit la consulta sale con $1 y la conexión es de PostgreSQL: encajan.
El código de negocio no nombra ninguna clase concreta. Solo depende de la interfaz.
Qué cambió
- findUser(kit, id)
- Consulta con $1 a PostgreSQL
Paso 6 de 11
Solución
Cambiar de familia es cambiar un objeto
Para usar MySQL pasas mysqlKit en lugar de pgKit. findUser no cambia: ahora recibe ? y una conexión de MySQL.
La decisión no desaparece: se muda a un solo sitio, normalmente el punto donde arranca la app (main.ts).
Qué cambió
- MySqlKit implements SqlKit
- main.ts: kit = mysqlKit
- findUser: 0 cambios
Paso 7 de 11
Técnica
Dónde te lo cruzas: DbProviderFactory
En .NET, DbProviderFactory es una clase abstracta con métodos como CreateConnection(), CreateCommand() y CreateParameter(). SqlClientFactory y OdbcFactory, entre otras, derivan de ella.
El código escrito contra las clases base funciona con el proveedor cuya fábrica le pases. En Java, DocumentBuilderFactory.newInstance() aplica una idea cercana: busca la implementación en tiempo de ejecución y tu código nunca nombra la clase del parser.
Qué cambió
- SqlKit → DbProviderFactory
- Kits → SqlClientFactory, OdbcFactory
Paso 8 de 11
Técnica
Una familia en memoria para tus tests
Una familia nueva no tiene por qué ser otra base de datos. memKit entrega una conexión falsa que lee filas de un array.
Tu test llama a findUser(memKit, 7) y prueba la lógica sin levantar una base real. Agregar esta familia fue un kit nuevo y cero cambios en findUser.
Qué cambió
- MemKit implements SqlKit
- Familias: 2 → 3
Paso 9 de 11
Compromiso
Un producto nuevo toca todos los kits
Ahora quieres transacciones: agregas begin() a SqlKit. Cada kit que la implementa tiene que cambiar: en el ejemplo, 3 kits.
Ese es el trato: agregar una familia es barato (un kit), agregar un tipo de producto es caro (todos los kits).
Qué cambió
- SqlKit.begin(): Transaction
- PgKit, MySqlKit, MemKit: los 3 cambian
Paso 10 de 11
Compromiso
Cuándo no usarla
Si solo existe una familia y no hay planes de una segunda, el kit es una capa de sobra: new PgConn(url) se lee mejor.
Si los productos no dependen entre sí, tampoco hace falta: fábricas separadas o inyección de dependencias simple son más sencillas.
Qué cambió
- MySqlKit y MemKit
- Familias: 3 → 1
Paso 11 de 11
Resumen
Elige la familia una vez
Una Abstract Factory crea varios productos que deben encajar y deja que el código de negocio dependa solo de la interfaz.
Cambiar de familia es una línea en main.ts y una familia nueva es un kit nuevo. El precio: cada producto nuevo toca todos los kits.
← → paso · R repetir · Espacio pausa
Aprenderás
- Por qué mezclar piezas de dos familias rompe el código (visto)
- Qué es una Abstract Factory y en qué se diferencia de una Factory (visto)
- Cómo el código de negocio deja de nombrar clases concretas (visto)
- Dónde te la cruzas: .NET y tus propios tests (visto)
- Qué cuesta y cuándo no usarla (visto)