StackPractices
beginner Por Mathias Paulenko

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.

Temas: design

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

Flujo del patrón Factory: el llamador pide un objeto a la fábrica, que instancia EmailNotifier o SmsNotifier; ambos implementan la interfaz Notifier de la que depende el llamador.
  • 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 interfaz Notifier, nunca de EmailNotifier ni de SmsNotifier.
  • Abstract factory: un conjunto coordinado de factories para productos relacionados. WindowsUIFactory entrega un WindowsButton y un WindowsCheckbox construidos 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ónNivel de abstracciónMejor paraComplejidad
Simple factoryBajoUn creador con tipo en runtimeBaja
Factory methodMedioTemplate method con creación personalizableMedia
Abstract factoryAltoFamilias de objetos relacionadosMedia-Alta
BuilderAltoObjetos complejos con muchos parámetros opcionalesMedia
Contenedor DIMáximoAplicaciones empresariales con grafos de dependencias profundosAlta

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, no EmailNotifier. 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 Date o un Point de dos coordenadas es sobre-ingeniería. new está 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.