Skip to main content

Patrón Factory Method en TypeScript

Guía Completa con Ejemplo Práctico

Updated 6 min readMarkdown
Patrón Factory Method en TypeScript

¿Qué es el Patrón Factory Method?

El Factory Method (Método de Fábrica) es un patrón de diseño creacional que proporciona una interfaz para crear objetos en una superclase, pero permite que las subclases decidan qué clase de objeto instanciar. En lugar de llamar directamente al constructor con el operador new, delegamos la creación de objetos a métodos especializados.

El Problema que Resuelve

Imagina que estás desarrollando un sistema de notificaciones para tu aplicación. Inicialmente solo envías notificaciones por Email, así que todo tu código está acoplado a la clase EmailNotification. Pero luego necesitas agregar notificaciones por SMS y Push.

¿Cómo lo harías? Podrías llenar tu código de condicionales if-else o switch, pero esto viola el principio Open/Closed y hace que tu código sea difícil de mantener y extender.

// Código sin patrón
function sendNotification(type: string, message: string) {
  if (type === 'email') {
    // Crear y enviar email
  } else if (type === 'sms') {
    // Crear y enviar SMS
  } else if (type === 'push') {
    // Crear y enviar push
  }
}

La Solución: Factory Method

El patrón Factory Method resuelve este problema definiendo un método abstracto para crear objetos, permitiendo que las subclases concretas decidan qué tipo específico crear.

Componentes del Patrón

1. Product (Producto)

Es la interfaz común para todos los objetos que la fábrica puede crear. Define las operaciones que todos los productos concretos deben implementar.

2. ConcreteProduct (Producto Concreto)

Son las implementaciones específicas de la interfaz Product. Cada una proporciona su propia versión de las operaciones definidas.

3. Creator (Creador)

Es la clase abstracta que declara el Factory Method. Puede contener lógica de negocio que utiliza los productos creados por el Factory Method.

4. ConcreteCreator (Creador Concreto)

Son las subclases que implementan el Factory Method para crear instancias específicas de productos concretos.

Diagrama UML

Ejemplo Práctico: Sistema de Notificaciones

Vamos a implementar un sistema de notificaciones que puede enviar mensajes por diferentes canales: Email, SMS y Push Notifications.

Paso 1: Definir la interfaz Product

// notification.interface.ts
export interface Notification {
  send(recipient: string, message: string): string;
  getIcon(): string;
}

Paso 2: Implementar los Productos Concretos

// email-notification.ts
export class EmailNotification implements Notification {
  send(recipient: string, message: string): string {
    return `📧 Email enviado a ${recipient}: "${message}"`;
  }

  getIcon(): string {
    return '📧';
  }
}

// sms-notification.ts
export class SMSNotification implements Notification {
  send(recipient: string, message: string): string {
    return `📱 SMS enviado a ${recipient}: "${message}"`;
  }

  getIcon(): string {
    return '📱';
  }
}

// push-notification.ts
export class PushNotification implements Notification {
  send(recipient: string, message: string): string {
    return `🔔 Notificación Push enviada a ${recipient}: "${message}"`;
  }

  getIcon(): string {
    return '🔔';
  }
}

Paso 3: Crear el Creator Abstracto

// notification-sender.ts
export abstract class NotificationSender {
  // Factory Method - debe ser implementado por las subclases
  abstract createNotification(): Notification;

  // Método que utiliza el producto creado por el Factory Method
  public notify(recipient: string, message: string): string {
    const notification = this.createNotification();
    return notification.send(recipient, message);
  }

  public getNotificationType(): string {
    const notification = this.createNotification();
    return `Tipo: ${notification.getIcon()}`;
  }
}

Paso 4: Implementar los Creadores Concretos

// email-sender.ts
export class EmailSender extends NotificationSender {
  createNotification(): Notification {
    return new EmailNotification();
  }
}

// sms-sender.ts
export class SMSSender extends NotificationSender {
  createNotification(): Notification {
    return new SMSNotification();
  }
}

// push-sender.ts
export class PushSender extends NotificationSender {
  createNotification(): Notification {
    return new PushNotification();
  }
}

Paso 5: Código Cliente

// main.ts
function sendNotificationToUser(sender: NotificationSender, recipient: string, message: string) {
  console.log(sender.getNotificationType());
  console.log(sender.notify(recipient, message));
}

// Uso
const emailSender = new EmailSender();
sendNotificationToUser(emailSender, 'usuario@example.com', '¡Bienvenido!');

const smsSender = new SMSSender();
sendNotificationToUser(smsSender, '+1234567890', 'Código de verificación: 1234');

const pushSender = new PushSender();
sendNotificationToUser(pushSender, 'device_token_123', 'Nueva actualización disponible');

Ventajas del Patrón Factory Method

Desacoplamiento

El código cliente trabaja con la interfaz abstracta, no con clases concretas. No necesita conocer los detalles de implementación.

Principio Open/Closed

Puedes agregar nuevos tipos de productos sin modificar el código existente. Solo necesitas crear nuevas subclases.

Single Responsibility Principle

La lógica de creación está separada de la lógica de negocio. Cada clase tiene una única responsabilidad.

Flexibilidad

Es fácil cambiar o extender el comportamiento del sistema agregando nuevas fábricas.

Desventajas

Complejidad

Puede aumentar la complejidad del código al requerir múltiples clases para implementar el patrón.

Overhead

Para sistemas simples, puede ser excesivo. No lo uses si solo tienes un tipo de producto.

Cuándo Usar Factory Method

Cuando el tipo exacto de objeto a crear se decide en tiempo de ejecución, según una condición, una configuración o el resultado de otra operación, y no querés que esa decisión esté esparcida en condicionales por todo el código.

Cuando quieres proporcionar a los usuarios de tu biblioteca o framework una forma de extender sus componentes internos, dejando que sobrescriban qué clase concreta se instancia sin tocar el código interno.

Cuando anticipás que la lista de tipos de producto va a crecer con el tiempo, y no querés modificar el código existente cada vez que se agregue un tipo nuevo — solo sumar una subclase más.

Diferencias con Otros Patrones

Factory Method vs Abstract Factory

  • Factory Method: Usa herencia para delegar la creación de un tipo de producto

  • Abstract Factory: Usa composición y crea familias completas de objetos relacionados que deben usarse juntos

Factory Method vs Builder

  • Factory Method: Crea objetos en un solo paso

  • Builder: Construye objetos complejos paso a paso

Factory Method vs Prototype

  • Factory Method: Crea objetos mediante subclases

  • Prototype: Crea objetos clonando un prototipo existente

Casos de Uso Reales

  1. Frameworks de UI: Crear botones, ventanas y componentes específicos de cada plataforma (Windows, macOS, Linux)

  2. Conectores de Base de Datos: Crear conexiones específicas (MySQL, PostgreSQL, MongoDB)

  3. Parsers de Documentos: Crear parsers para diferentes formatos (JSON, XML, CSV)

  4. Sistemas de Logging: Crear loggers para diferentes destinos (archivo, consola, servicios remotos)

  5. Proveedores de Pago: Crear procesadores de pago para diferentes servicios (PayPal, Stripe, MercadoPago)

Conclusión

El patrón Factory Method es una herramienta poderosa para escribir código flexible y mantenible. Te permite crear objetos sin acoplar tu código a clases concretas, facilitando la extensión y modificación de tu sistema.

Recuerda: úsalo cuando realmente lo necesites. No todos los problemas requieren este nivel de abstracción. Pero cuando tu código necesita decidir en tiempo de ejecución qué tipo concreto instanciar dentro de una misma jerarquía, Factory Method es tu mejor aliado.


¿Te gustó este artículo? Compártelo con otros desarrolladores que puedan beneficiarse de entender este patrón de diseño fundamental.

About the author

  • Desarrollador apasionado por convertir bugs en funcionalidades (y café en productividad) Amante del código limpio, aunque mi historial de commits podría decir otra cosa. Siempre aprendiendo, siempre depurando, y ocasionalmente negociando con mi teclado para que coopere.

More from this blog