Patrón Factory

Parte de la sección Programación Orientada a Objetos del Journey de Dart de Coddy — lección 91 de 110.

El patrón Factory delega la creación de objetos a un método o clase independiente, permitiéndote crear objetos sin especificar su clase exacta. Esto es diferente del constructor factory que aprendiste anteriormente: el patrón Factory es un enfoque de diseño donde la lógica de creación está centralizada y puede devolver diferentes tipos según la entrada.

Considere un escenario en el que necesita crear diferentes tipos de notificaciones. En lugar de que el cliente decida qué clase instanciar, una fábrica se encarga de esa decisión:

abstract class Notification {
  void send(String message);
}

class EmailNotification implements Notification {
  @override
  void send(String message) => print('Email: $message');
}

class SMSNotification implements Notification {
  @override
  void send(String message) => print('SMS: $message');
}

class NotificationFactory {
  static Notification create(String type) {
    switch (type) {
      case 'email':
        return EmailNotification();
      case 'sms':
        return SMSNotification();
      default:
        return EmailNotification();
    }
  }
}

void main() {
  var notification = NotificationFactory.create('sms');
  notification.send('Hello!');  // SMS: Hello!
}

El código cliente no necesita saber sobre EmailNotification o SMSNotification —simplemente le pide a la fábrica una notificación de un tipo determinado. Esto facilita la adición de nuevos tipos de notificación: solo modificas la fábrica, no cada lugar que crea notificaciones.

Utilice el patrón Factory cuando la creación de objetos involucre una lógica compleja, cuando desee ocultar las clases de implementación a los clientes o cuando el tipo exacto a crear dependa de las condiciones de tiempo de ejecución.

Desafío

Fácil

¡Vamos a construir un generador de documentos utilizando el patrón Factory! Crearás un sistema que produce diferentes tipos de documentos (informes, facturas y cartas) a través de una fábrica centralizada, para que el código del cliente no necesite conocer las clases de documentos específicas.

Organizarás tu código en dos archivos:

document_factory.dart: Crea tu sistema de documentos aquí:
- Una clase abstracta Document con un método generate(String content) que devuelve un String
- Tres clases concretas que implementan Document:
  - Report - su método generate devuelve === REPORT ===\n[content]\n=============
  - Invoice - su método generate devuelve INVOICE\n--------\n[content]\nTotal Due
  - Letter - su método generate devuelve Dear Reader,\n[content]\nSincerely
- Una clase DocumentFactory con un método estático create(String type) que devuelve el Document apropiado basado en la cadena de tipo: "report", "invoice", o "letter". Para cualquier tipo desconocido, devuelve un Letter por defecto
main.dart: Importa tu fábrica de documentos y demuestra cómo la fábrica crea diferentes tipos de documentos sin que el cliente necesite conocer las clases concretas:
- Usa la fábrica para crear un informe e imprime el resultado de generarlo con el contenido Sales increased by 25%
- Imprime una línea vacía
- Usa la fábrica para crear una factura e imprime el resultado de generarlo con el contenido Widget x3 - $150
- Imprime una línea vacía
- Usa la fábrica para crear una carta e imprime el resultado de generarlo con el contenido Thank you for your order

¡Observa cómo tu archivo principal solo interactúa con la fábrica y el tipo abstracto Document; nunca crea directamente objetos Report, Invoice o Letter!

Salida esperada:

=== REPORT ===
Sales increased by 25%
=============

INVOICE
--------
Widget x3 - $150
Total Due

Dear Reader,
Thank you for your order
Sincerely

Hoja de referencia

El patrón Factory delega la creación de objetos a un método o clase independiente, lo que permite crear objetos sin especificar su clase exacta. La lógica de creación está centralizada y puede devolver diferentes tipos según la entrada.

Estructura básica del patrón Factory:

abstract class Notification {
  void send(String message);
}

class EmailNotification implements Notification {
  @override
  void send(String message) => print('Email: $message');
}

class SMSNotification implements Notification {
  @override
  void send(String message) => print('SMS: $message');
}

class NotificationFactory {
  static Notification create(String type) {
    switch (type) {
      case 'email':
        return EmailNotification();
      case 'sms':
        return SMSNotification();
      default:
        return EmailNotification();
    }
  }
}

void main() {
  var notification = NotificationFactory.create('sms');
  notification.send('Hello!');  // SMS: ¡Hola!
}

El código del cliente solo interactúa con la fábrica y el tipo abstracto, no con las clases de implementación concretas. Esto facilita la adición de nuevos tipos: solo hay que modificar la fábrica.

Utilice el patrón Factory cuando:

La creación de objetos implica una lógica compleja
Desea ocultar las clases de implementación a los clientes
El tipo exacto a crear depende de las condiciones de tiempo de ejecución

Pruébalo tú mismo

import 'document_factory.dart';

void main() {
  // TODO: Usa DocumentFactory.create() para crear un informe
  // Luego imprime el resultado de generarlo con el contenido: "Sales increased by 25%"
  
  // TODO: Imprime una línea vacía
  
  // TODO: Usa DocumentFactory.create() para crear una factura
  // Luego imprime el resultado de generarlo con el contenido: "Widget x3 - \$150"
  
  // TODO: Imprime una línea vacía
  
  // TODO: Usa DocumentFactory.create() para crear una carta
  // Luego imprime el resultado de generarlo con el contenido: "Thank you for your order"
}