Crea Objetos de Forma Flexible con el Patrón Factory
Cómo usar factory methods, abstract factories e inyección de dependencias para desacoplar la creación de objetos de su uso y facilitar las pruebas.
Descripción general
No hay nada más simple que new DatabaseConnection("postgres://...") — ni nada que te ate más. Quien invoca ese constructor conoce la clase exacta, su firma y cada dependencia que necesita. Cambia el driver de la base de datos y estarás editando cada punto de llamada. Si la conexión pasa a usar un pool en vez de una conexión directa, se rompe cada new. Y si quieres probar el llamador con una base de datos de mentira, no puedes: el new deja la clase concreta grabada a fuego.
El patrón factory traslada la creación de objetos a un método o clase pensada solo para eso. Quien necesita un objeto se lo pide a la factory, no al constructor. Es la factory la que decide qué clase concreta instanciar, cómo conectar las dependencias y qué configuración aplicar por defecto. El llamador depende de una abstracción — una interfaz o clase abstracta —, no de una implementación concreta. Abajo tienes implementaciones que funcionan de las tres variantes habituales — factory method, abstract factory y simple factory — en TypeScript, Java y Python, además de a qué se pasa cuando una factory manual se queda corta.
Cuándo usarlo
Usa esta receta cuando:
- La clase exacta del objeto se decide en tiempo de ejecución a partir de configuración o de la entrada: un canal de notificación leído de
NOTIFY_BY, un proveedor de pago elegido por tenant. - Crear el objeto implica lógica de inicialización compleja, como pools de conexiones, cachés o listeners de eventos. Consulta el Patrón Singleton para gestionar instancias compartidas.
- Las pruebas necesitan sustituir implementaciones reales por mocks o stubs. Consulta Unit Testing con Mocks para ver cómo.
- Crear objetos directamente violaría la inversión de dependencias: los módulos de alto nivel dependerían de detalles de bajo nivel. Consulta Arquitectura Hexagonal para ver cómo los puertos y adaptadores lo formalizan.
- Estás construyendo un framework o una biblioteca donde los usuarios enchufan sus propias implementaciones.
Hay una forma fácil de saber si te conviene: si las llamadas a new están repartidas por la lógica de negocio y retocar la firma de un constructor te obliga a editar una docena de archivos, una factory se paga sola. Si un constructor tiene dos argumentos y nunca cambia, new está bien — no añadas indirección que no necesitas.
Solución
Factory Method (TypeScript)
interface Notifier {
send(message: string, recipient: string): Promise<void>;
}
class EmailNotifier implements Notifier {
constructor(private smtpHost: string, private from: string) {}
async send(message: string, recipient: string): Promise<void> {
// Implementación SMTP
console.log(`Email a ${recipient}: ${message}`);
}
}
class SmsNotifier implements Notifier {
constructor(private twilioSid: string) {}
async send(message: string, recipient: string): Promise<void> {
// Implementación Twilio
console.log(`SMS a ${recipient}: ${message}`);
}
}
abstract class NotificationFactory {
abstract createNotifier(): Notifier;
async notifyUser(message: string, recipient: string): Promise<void> {
const notifier = this.createNotifier();
await notifier.send(message, recipient);
}
}
class EmailNotificationFactory extends NotificationFactory {
createNotifier(): Notifier {
return new EmailNotifier(process.env.SMTP_HOST!, 'noreply@example.com');
}
}
class SmsNotificationFactory extends NotificationFactory {
createNotifier(): Notifier {
return new SmsNotifier(process.env.TWILIO_SID!);
}
}
// Uso
const factory: NotificationFactory = process.env.NOTIFY_BY === 'sms'
? new SmsNotificationFactory()
: new EmailNotificationFactory();
await factory.notifyUser('¡Tu pedido ha sido enviado!', 'user@example.com');
Abstract Factory (Java)
// Interfaces de producto abstractas
interface Button {
void render();
}
interface Checkbox {
void check();
}
// Productos concretos para Windows
class WindowsButton implements Button {
public void render() { System.out.println("Rendering Windows button"); }
}
class WindowsCheckbox implements Checkbox {
public void check() { System.out.println("Checking Windows checkbox"); }
}
// Productos concretos para macOS
class MacButton implements Button {
public void render() { System.out.println("Rendering Mac button"); }
}
class MacCheckbox implements Checkbox {
public void check() { System.out.println("Checking Mac checkbox"); }
}
// Factory abstracta
interface UIFactory {
Button createButton();
Checkbox createCheckbox();
}
// Factories concretas
class WindowsUIFactory implements UIFactory {
public Button createButton() { return new WindowsButton(); }
public Checkbox createCheckbox() { return new WindowsCheckbox(); }
}
class MacUIFactory implements UIFactory {
public Button createButton() { return new MacButton(); }
public Checkbox createCheckbox() { return new MacCheckbox(); }
}
// Aplicación
class Application {
private final Button button;
private final Checkbox checkbox;
Application(UIFactory factory) {
this.button = factory.createButton();
this.checkbox = factory.createCheckbox();
}
void renderUI() {
button.render();
checkbox.check();
}
}
// Uso
UIFactory factory = System.getProperty("os.name").contains("Windows")
? new WindowsUIFactory()
: new MacUIFactory();
new Application(factory).renderUI();
Simple Factory (Python)
import os
from typing import Protocol
class PaymentProcessor(Protocol):
def charge(self, amount: float, currency: str) -> dict:
...
class StripeProcessor:
def __init__(self, api_key: str):
self.api_key = api_key
def charge(self, amount: float, currency: str) -> dict:
return {"provider": "stripe", "status": "success", "amount": amount}
class PayPalProcessor:
def __init__(self, client_id: str, secret: str):
self.client_id = client_id
self.secret = secret
def charge(self, amount: float, currency: str) -> dict:
return {"provider": "paypal", "status": "success", "amount": amount}
class PaymentProcessorFactory:
def create(self, provider: str) -> PaymentProcessor:
if provider == "stripe":
return StripeProcessor(api_key=os.environ["STRIPE_API_KEY"])
elif provider == "paypal":
return PayPalProcessor(
client_id=os.environ["PAYPAL_CLIENT_ID"],
secret=os.environ["PAYPAL_SECRET"],
)
else:
raise ValueError(f"Proveedor desconocido: {provider}")
# Uso
factory = PaymentProcessorFactory()
processor = factory.create("stripe")
result = processor.charge(99.99, "USD")
Explicación
- Factory method: un método que las subclases sobrescriben para decidir qué objeto se instancia. La clase base tiene el algoritmo (
notifyUser); la subclase tiene la decisión de creación. La clase base depende de la interfazNotifier, nunca deEmailNotifierni deSmsNotifier. - Abstract factory: un conjunto coordinado de factories para productos relacionados.
WindowsUIFactoryentrega unWindowsButtony unWindowsCheckboxconstruidos bajo el mismo tema. Cambiar de tema es cambiar una factory, no perseguir instanciaciones sueltas. La coherencia entre productos relacionados es la garantía por la que pagas. - Simple factory: una función o clase que construye objetos a partir de un parámetro. Estrictamente no es un patrón GoF, aunque es lo que la mayoría de las “factories” del código de producción son de verdad: la lógica de creación reunida en un sitio, sin la inversión de dependencias profunda de las otras dos.
- Inyección de dependencias: a escala, son los contenedores DI (Spring, Angular, InversifyJS) los que crean hasta las propias factories. Declaras los bindings —
Notifier→EmailNotifier— en un solo sitio y el contenedor resuelve el grafo de dependencias. Las factories pasan a ser configuración, no código de aplicación.
El intercambio es siempre el mismo: compras desacoplamiento y facilidad de prueba a cambio de una capa extra de indirección. Merece la pena cuando las implementaciones cambian, se multiplican o hay que simularlas en tests — y es peso muerto cuando no.
Variantes
| Patrón | Nivel de abstracción | Mejor para | Complejidad |
|---|---|---|---|
| Simple factory | Bajo | Un creador con tipo en runtime | Baja |
| Factory method | Medio | Template method con creación personalizable | Media |
| Abstract factory | Alto | Familias de objetos relacionados | Media-Alta |
| Builder | Alto | Objetos complejos con muchos parámetros opcionales | Media |
| Contenedor DI | Máximo | Aplicaciones empresariales con grafos de dependencias profundos | Alta |
Elegir entre ellas es sobre todo una cuestión de qué varía. Si solo varía la clase concreta, una simple factory basta. Si varía el proceso de creación por subclase — cada subclase elige su propio producto — usa factory method. Si son familias enteras de objetos las que deben mantenerse coherentes (un tema Windows no puede mezclarse con widgets de macOS), eso es territorio de abstract factory. Y cuando ya no eliges implementaciones en código sino que las declaras en configuración, las factories manuales se te han quedado pequeñas: quieres un contenedor DI.
Variantes avanzadas
Contenedor DI con Factory Providers (TypeScript)
interface Container {
bind<T>(token: string, factory: () => T): void;
resolve<T>(token: string): T;
}
class SimpleContainer implements Container {
private bindings: Map<string, () => unknown> = new Map();
private instances: Map<string, unknown> = new Map();
bind<T>(token: string, factory: () => T): void {
this.bindings.set(token, factory);
}
resolve<T>(token: string): T {
if (this.instances.has(token)) {
return this.instances.get(token) as T;
}
const factory = this.bindings.get(token);
if (!factory) throw new Error(`Sin binding para ${token}`);
const instance = factory() as T;
this.instances.set(token, instance);
return instance;
}
}
// Configuración
const container = new SimpleContainer();
container.bind('Logger', () => new ConsoleLogger());
container.bind('Database', () => new PostgresConnection(process.env.DATABASE_URL));
container.bind('UserRepository', () => {
const db = container.resolve<PostgresConnection>('Database');
const logger = container.resolve<ConsoleLogger>('Logger');
return new UserRepository(db, logger);
});
container.bind('UserService', () => {
const repo = container.resolve<UserRepository>('UserRepository');
return new UserService(repo);
});
// Uso — resuelve dependencias en cualquier sitio
const userService = container.resolve<UserService>('UserService');
await userService.createUser({ email: 'user@example.com', name: 'Alice' });
Factory + Builder (TypeScript)
class PushNotifier implements Notifier {
constructor(private fcmKey: string) {}
async send(message: string, recipient: string): Promise<void> {
console.log(`Push a ${recipient}: ${message}`);
}
}
// Envuelve cualquier Notifier con políticas de timeout, reintento y prioridad
class ResilientNotifier implements Notifier {
constructor(
private inner: Notifier,
private timeout: number,
private retries: number,
private priority: string,
) {}
async send(message: string, recipient: string): Promise<void> {
for (let attempt = 0; attempt <= this.retries; attempt++) {
try {
return await this.inner.send(message, recipient);
} catch {
if (attempt === this.retries) throw new Error('Envío fallido');
}
}
}
}
class NotificationBuilder {
private channel: 'email' | 'sms' | 'push' = 'email';
private timeout: number = 30;
private retries: number = 3;
private priority: 'low' | 'normal' | 'high' = 'normal';
withChannel(channel: 'email' | 'sms' | 'push'): this {
this.channel = channel;
return this;
}
withTimeout(seconds: number): this {
this.timeout = seconds;
return this;
}
withRetries(count: number): this {
this.retries = count;
return this;
}
withPriority(priority: 'low' | 'normal' | 'high'): this {
this.priority = priority;
return this;
}
build(): Notifier {
const base = this.channel === 'email'
? new EmailNotifier(process.env.SMTP_HOST!, 'noreply@example.com')
: this.channel === 'sms'
? new SmsNotifier(process.env.TWILIO_SID!)
: new PushNotifier(process.env.FCM_KEY!);
return new ResilientNotifier(base, this.timeout, this.retries, this.priority);
}
}
// Uso — la factory decide la clase, el builder la configura
const notifier = new NotificationBuilder()
.withChannel('sms')
.withTimeout(10)
.withRetries(5)
.withPriority('high')
.build();
await notifier.send('¡Servidor caído!', 'admin@example.com');
Async Factory con Pool de Conexiones (Python)
import asyncio
import asyncpg
from typing import Optional
class DatabaseConnectionFactory:
_pool: Optional[asyncpg.Pool] = None
_lock = asyncio.Lock()
@classmethod
async def create(cls, config: dict) -> 'DatabaseConnection':
if cls._pool is None:
async with cls._lock:
if cls._pool is None:
cls._pool = await asyncpg.create_pool(
dsn=config['url'],
min_size=config.get('min_pool', 5),
max_size=config.get('max_pool', 20),
command_timeout=config.get('timeout', 30),
)
return DatabaseConnection(await cls._pool.acquire())
@classmethod
async def close(cls) -> None:
if cls._pool:
await cls._pool.close()
cls._pool = None
class DatabaseConnection:
def __init__(self, conn):
self._conn = conn
async def query(self, sql: str, *args) -> list:
return await self._conn.fetch(sql, *args)
async def __aenter__(self):
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
await self._conn.close()
# Uso — factory async con pool de conexiones
async def main():
config = {'url': 'postgresql://localhost/mydb', 'max_pool': 10}
async with await DatabaseConnectionFactory.create(config) as db:
users = await db.query('SELECT * FROM users WHERE active = $1', True)
await DatabaseConnectionFactory.close()
Lo que funciona
- Devuelve abstracciones, no concreciones: un factory method debería devolver
Notifier, noEmailNotifier. Así el llamador trata todos los productos igual y puede cambiar de implementación cuando quiera. Si devuelves un tipo concreto, la factory solo añade ceremonia. - Mantén las factories sin estado: una factory crea y devuelve objetos; no debería guardar estado de aplicación. Las factories con estado son incómodas de probar y ocultan el ciclo de vida de los objetos. Pasa la configuración como parámetros.
- Usa contenedores DI para grafos complejos: cuando un servicio necesita un repositorio, que necesita un pool de conexiones, que necesita un cargador de configuración, cablear factories a mano se vuelve tedioso rápido. Declara los bindings una vez y deja que el contenedor resuelva las dependencias transitivas.
- No las uses para objetos triviales: una factory para un
Dateo unPointde dos coordenadas es sobre-ingeniería.newestá bien para value objects simples. Reserva las factories para cosas con dependencias, configuración o polimorfismo en runtime. - Documenta el contrato, no la factory: quien consume la factory necesita saber qué hace el objeto devuelto — sus métodos, invariantes, seguridad en hilos — no cómo se construyó. Documenta la interfaz y deja la factory como detalle de implementación.
Errores comunes
- God factory: esa única factory que acaba instanciando todos los objetos de la app. Crece hasta cientos de líneas y se salta la responsabilidad única. Divide las factories por dominio o capa:
NotificationFactory,PaymentFactory,RepositoryFactory. - Factory que hace lógica de negocio: una factory crea objetos; no valida reglas de negocio, dispara efectos secundarios ni orquesta flujos. Si tu factory comprueba permisos antes de crear un notifier, esa comprobación va en un servicio.
- Ignorar el ciclo de vida de destrucción: las factories crean objetos pero rara vez gestionan su destrucción. Si una factory guarda referencias a lo que crea, se convierte en una fuga de memoria. Usa ámbitos (singleton, request, transient) y limpia al apagar.
- Configuración incrustada en el código:
new DatabaseConnection("postgres://localhost")deja la configuración grabada a fuego. Inyéctala y la misma factory sirve en desarrollo, staging y producción sin tocarla.
Véase también
- Patrón Factory — la referencia GoF canónica con estructura UML y consecuencias.
- Patrón Abstract Factory — cuando familias de objetos relacionados deben mantenerse coherentes.
- Patrón Builder — para objetos con muchos parámetros opcionales.
- Repositorio companion — versiones ejecutables de todos los ejemplos de esta receta.
- Gamma et al., Design Patterns (1994) — los capítulos originales de Factory Method y Abstract Factory.
Preguntas frecuentes
¿Cuándo usar una factory y cuándo un contenedor DI?
Una factory cuando la creación de objetos es local a un módulo; un contenedor DI cuando las dependencias atraviesan toda la aplicación. Los frameworks modernos suelen hacer ambas cosas: el contenedor mismo usa factory providers por dentro.
¿Sigue siendo relevante el patrón factory con los frameworks de DI?
Sí — los frameworks de DI funcionan con factories internamente. Sigues escribiendo factory methods siempre que la creación necesite lógica propia, como elegir el shard de base de datos según el tenant. El DI se ocupa del cableado; las factories, de las decisiones de creación.
¿Cómo pruebo código que usa factories?
Simula la factory. Si OrderService recibe un PaymentProcessorFactory, pásale un stub que devuelva un procesador falso. O salta la factory por completo en los tests e inyecta el procesador directamente por el constructor.
¿Se puede combinar factory con builder?
Sí, y es una combinación habitual. La factory elige qué clase instanciar y el builder configura esa instancia después: factory.create("email").withTimeout(30).withRetries(3).
¿Qué diferencia hay entre factory method y abstract factory?
El factory method es un método sobrescribible que produce un objeto — la subclase decide cuál. La abstract factory es una interfaz entera de métodos que producen una familia de objetos relacionados. Si solo necesitas un tipo de producto, el factory method es más simple.
Recursos Relacionados
Patrón Factory
Crea objetos sin especificar la clase exacta a instanciar. Un patrón de diseño creacional para la creación flexible de objetos.
PatternPatrón Abstract Factory
Crea familias de objetos relacionados sin especificar sus clases concretas. Patrón de diseño creacional para familias de objetos consistentes.
PatternPatrón Builder: construcción de objetos paso a paso
Construye objetos complejos paso a paso. Patrón de diseño creacional para construcción de objetos legible y configurable.
PatternPatrón Singleton: Ejemplos en Java, Python y TypeScript
Garantiza que una clase tenga una única instancia y ofrece acceso global a ella — el patrón creacional para controlar la creación de objetos, con implementaciones listas para producción.
RecipeConstruir Apps Mantenibles con Arquitectura Hexagonal
Estructura aplicaciones con ports y adapters para aislar la lógica de negocio de frameworks, bases de datos y servicios externos y facilitar los tests.
RecipeEscribir Unit Tests con Mocks y Stubs
Cómo aislar código bajo test usando objetos mock, stubs y spies para reemplazar dependencias externas como bases de datos, APIs y sistemas de archivos.