Definición#

El Factory Method (Método Fábrica o Constructor Virtual) es un patrón de diseño creacional que:

• Proporciona una interfaz común para crear objetos en una superclase.
• Permite que las subclases decidan qué clase concreta de objeto instanciar.
• Desacopla la lógica del cliente de la creación de objetos específicos.

Problema#

Si el código cliente está acoplado a clases concretas, cada vez que se quiera añadir un nuevo producto (por ejemplo, transporte terrestre, marítimo o aéreo), será necesario modificar varias partes del sistema. Esto genera código difícil de mantener y extender.

Solución#

• Definir una interfaz de producto común (ej. Transporte).
• Definir un método fábrica en una clase creadora (ej. Logistica) que devuelve productos de esa interfaz.
• Las subclases de la creadora implementan el método y devuelven un tipo específico (ej. Camion, Barco).

Estructura (Mermaid UML)#

1
classDiagram
2
    class Transporte {
3
        <<interface>>
4
        +entregar(): void
5
    }
6

7
    class Camion {
8
        +entregar(): void
9
    }
10

11
    class Barco {
12
        +entregar(): void
13
    }
14

15
    class Logistica {
16
        <<abstract>>
17
        +crearTransporte(): Transporte
18
    }
19

20
    class LogisticaTerrestre {
21
        +crearTransporte(): Transporte
22
    }
23

24
    class LogisticaMaritima {
25
        +crearTransporte(): Transporte
26
    }
27

28
    Transporte <|.. Camion
29
    Transporte <|.. Barco
30
    Logistica <|-- LogisticaTerrestre
31
    Logistica <|-- LogisticaMaritima
32
    Logistica --> Transporte

Cuándo usar#

• Cuando el código debe trabajar con una interfaz común y no con implementaciones concretas.
• Cuando se espera que la familia de productos crezca en el futuro.

Cuándo no usar#

• Cuando el número de productos es pequeño y estable (es más simple usar constructores directos).
• Cuando la herencia genera sobrecarga innecesaria.

Ejemplo en Spring Boot (Java)#

1
// Producto
2
public interface Transporte {
3
    void entregar();
4
}
5

6
// Productos concretos
7
public class Camion implements Transporte {
8
    @Override
9
    public void entregar() {
10
        System.out.println("Entrega por carretera en camión");
11
    }
12
}
13

14
public class Barco implements Transporte {
15
    @Override
16
    public void entregar() {
17
        System.out.println("Entrega por mar en barco");
18
    }
19
}
20

21
// Creador abstracto
22
public abstract class Logistica {
23
    public abstract Transporte crearTransporte();
24

25
    public void planEntrega() {
26
        Transporte transporte = crearTransporte();
27
        transporte.entregar();
28
    }
29
}
30

31
// Creadores concretos
32
public class LogisticaTerrestre extends Logistica {
33
    @Override
34
    public Transporte crearTransporte() {
35
        return new Camion();
36
    }
37
}
38

39
public class LogisticaMaritima extends Logistica {
40
    @Override
41
    public Transporte crearTransporte() {
42
        return new Barco();
43
    }
44
}
45

46
// Cliente (ejemplo de uso en un CommandLineRunner de Spring Boot)
47
@SpringBootApplication
48
public class FactoryMethodApp implements CommandLineRunner {
49
    public static void main(String[] args) {
50
        SpringApplication.run(FactoryMethodApp.class, args);
51
    }
52

53
    @Override
54
    public void run(String... args) {
55
        Logistica terrestre = new LogisticaTerrestre();
56
        terrestre.planEntrega();
57

58
        Logistica maritima = new LogisticaMaritima();
59
        maritima.planEntrega();
60
    }
61
}

Ejemplo en Django (Python)#

1
from abc import ABC, abstractmethod
2

3
# Producto
4
class Transporte(ABC):
5
    @abstractmethod
6
    def entregar(self):
7
        pass
8

9
# Productos concretos
10
class Camion(Transporte):
11
    def entregar(self):
12
        return "Entrega por carretera en camión"
13

14
class Barco(Transporte):
15
    def entregar(self):
16
        return "Entrega por mar en barco"
17

18
# Creador abstracto
19
class Logistica(ABC):
20
    @abstractmethod
21
    def crear_transporte(self) -> Transporte:
22
        pass
23

24
    def plan_entrega(self):
25
        transporte = self.crear_transporte()
26
        return transporte.entregar()
27

28
# Creadores concretos
29
class LogisticaTerrestre(Logistica):
30
    def crear_transporte(self) -> Transporte:
31
        return Camion()
32

33
class LogisticaMaritima(Logistica):
34
    def crear_transporte(self) -> Transporte:
35
        return Barco()
36

37
# Uso en una vista de Django
38
from django.http import JsonResponse
39

40
def entrega_view(request, tipo):
41
    if tipo == "tierra":
42
        logistica = LogisticaTerrestre()
43
    elif tipo == "mar":
44
        logistica = LogisticaMaritima()
45
    else:
46
        return JsonResponse({"error": "Tipo de transporte no válido"}, status=400)
47

48
    return JsonResponse({"resultado": logistica.plan_entrega()})

Resumen#

• El Factory Method permite crear objetos sin acoplar el código cliente a clases concretas.
• Sigue los principios de abierto/cerrado y responsabilidad única.
• Es aplicable en frameworks como Spring Boot o Django para encapsular la creación de objetos dependientes del negocio.

Paso 1: Creación del Proyecto en IntelliJ IDEA 🚀#

Primero, vamos a recrear el proyecto desde cero para tener una guía completa.

1. Abre IntelliJ IDEA y ve a File > New > Project….
2. En la ventana que aparece, selecciona Spring Initializr en el panel izquierdo.
3. Configura los metadatos de tu proyecto.
   • Name: Factory-Method-Ejemplo
   • Location: La carpeta donde quieras guardarlo.
   • Language: Java
   • Type: Gradle - Groovy
   • Group: com.example.solid
   • Artifact: factorymethodejemplo
   • JDK: Asegúrate de seleccionar la versión 17 (o superior).
   • Packaging: Jar
4. Haz clic en Next.
5. Ahora, elige las dependencias. Para este proyecto, solo necesitas Spring Web.
6. Haz clic en Create. IntelliJ generará la estructura del proyecto.

Paso 2: Estructura de Paquetes 📂#

Una buena organización es clave. Dentro de src/main/java/com/example/solid/factorymethodejemplo, crearemos los siguientes paquetes para mantener nuestro código ordenado:

• transport: Contendrá la interfaz del producto (Transporte) y sus implementaciones concretas (Camion, Barco).
• factory: Contendrá la clase creadora abstracta (Logistica) y sus implementaciones concretas (LogisticaTerrestre, LogisticaMaritima).
• controller: Contendrá nuestro RestController, que actuará como el cliente del patrón.

Paso 3: Codificación del Patrón Factory Method 🏭#

Ahora vamos a escribir el código, siguiendo la estructura que definimos.

1
package com.example.solid.factorymethodejemplo.transport;
2

3
public interface Transporte {
4
    String entregar();
5
}

1
package com.example.solid.factorymethodejemplo.transport;
2

3
import org.springframework.stereotype.Component;
4

5
@Component
6
public class Camion implements Transporte {
7
    @Override
8
    public String entregar() {
9
        return "Entrega por carretera en un camión.";
10
    }
11
}

1
package com.example.solid.factorymethodejemplo.transport;
2

3
import org.springframework.stereotype.Component;
4

5
@Component
6
public class Barco implements Transporte {
7
    @Override
8
    public String entregar() {
9
        return "Entrega por mar en un barco.";
10
    }
11
}

1
package com.example.solid.factorymethodejemplo.factory;
2

3
import com.example.solid.factorymethodejemplo.transport.Transporte;
4

5
public abstract class Logistica {
6

7
    // Este es el "Factory Method" que las subclases deben implementar
8
    public abstract Transporte crearTransporte();
9

10
    public String planificarEntrega() {
11
        Transporte transporte = crearTransporte();
12
        return transporte.entregar();
13
    }
14
}

1
package com.example.solid.factorymethodejemplo.factory;
2

3
import com.example.solid.factorymethodejemplo.transport.Camion;
4
import com.example.solid.factorymethodejemplo.transport.Transporte;
5
import org.springframework.stereotype.Component;
6

7
@Component("terrestre") // Nombre clave para identificar esta fábrica
8
public class LogisticaTerrestre extends Logistica {
9
    @Override
10
    public Transporte crearTransporte() {
11
        return new Camion();
12
    }
13
}

1
package com.example.solid.factorymethodejemplo.factory;
2

3
import com.example.solid.factorymethodejemplo.transport.Barco;
4
import com.example.solid.factorymethodejemplo.transport.Transporte;
5
import org.springframework.stereotype.Component;
6

7
@Component("maritima") // Nombre clave para esta otra fábrica
8
public class LogisticaMaritima extends Logistica {
9
    @Override
10
    public Transporte crearTransporte() {
11
        return new Barco();
12
    }
13
}

Paso 4: Crear el Cliente (Controlador REST) 🌐#

Finalmente, en el paquete controller, crearemos la clase que utiliza las fábricas para construir los productos. Usaremos la inyección de dependencias de Spring para que elija la fábrica correcta por nosotros.

LogisticaController.java

1
package com.example.solid.factorymethodejemplo.controller;
2

3
import com.example.solid.factorymethodejemplo.factory.Logistica;
4
import org.springframework.beans.factory.annotation.Autowired;
5
import org.springframework.http.ResponseEntity;
6
import org.springframework.web.bind.annotation.GetMapping;
7
import org.springframework.web.bind.annotation.PathVariable;
8
import org.springframework.web.bind.annotation.RequestMapping;
9
import org.springframework.web.bind.annotation.RestController;
10

11
import java.util.Map;
12
import java.util.Optional;
13

14
@RestController
15
@RequestMapping("/api/logistica")
16
public class LogisticaController {
17

18
    // Spring inyecta un mapa con todas las fábricas. La clave es el nombre
19
    // que pusimos en @Component ("terrestre", "maritima").
20
    private final Map<String, Logistica> logisticaMap;
21

22
    @Autowired
23
    public LogisticaController(Map<String, Logistica> logisticaMap) {
24
        this.logisticaMap = logisticaMap;
25
    }
26

27
    @GetMapping("/entrega/{tipo}")
28
    public ResponseEntity<String> realizarEntrega(@PathVariable String tipo) {
29
        // Buscamos la fábrica correcta según el "tipo" de la URL.
30
        return Optional.ofNullable(logisticaMap.get(tipo))
31
                .map(logistica -> {
32
                    // Si la encontramos, planificamos la entrega.
33
                    // El controlador no sabe qué tipo de transporte se está creando.
34
                    String resultado = logistica.planificarEntrega();
35
                    return ResponseEntity.ok(resultado);
36
                })
37
                .orElse(ResponseEntity.badRequest().body("Tipo de logística no válido: " + tipo));
38
    }
39
}

Paso 5: Probar la Aplicación ✅#

¡Todo está listo!

1. Ejecuta tu aplicación desde la clase principal FactoryMethodEjemploApplication.
2. Usa un navegador para probar los siguientes endpoints:

• Para la entrega terrestre: http://localhost:8080/api/logistica/entrega/terrestre

  Respuesta esperada:

  1
  Entrega por carretera en un camión.
  

• Para la entrega marítima: http://localhost:8080/api/logistica/entrega/maritima

  Respuesta esperada:

  1
  Entrega por mar en un barco.
  

• Para un tipo no existente: http://localhost:8080/api/logistica/entrega/aerea

  Respuesta esperada:

  1
  Tipo de logística no válido: aerea
  

Paso 1: Creación del Proyecto en PyCharm 🚀#

Primero, vamos a crear un proyecto Django nuevo y limpio.

1. Abre PyCharm (la versión Professional es ideal para esto) y ve a File > New > Project….
2. En la ventana que aparece, selecciona Django en el panel izquierdo.
3. Configura tu proyecto:
   • Location: Elige una carpeta y nombra el proyecto, por ejemplo, factory_method_django.
   • New environment using: Selecciona Virtualenv. Esto creará un entorno virtual aislado para tu proyecto, lo cual es una práctica recomendada en Python.
   • Application name: Puedes nombrar tu primera aplicación, por ejemplo, core.
4. Haz clic en Create. PyCharm configurará el entorno, instalará Django y generará la estructura básica del proyecto.

Paso 2: Estructura de Archivos y Aplicación Django 📂#

En Django, la lógica se organiza en “apps”. Crearemos una app específica para nuestra funcionalidad de logística.

Antes te recomiendo instalar en una terminal

1
pip install django
2
pip lis

1. Abre la terminal dentro de PyCharm (View > Tool Windows > Terminal).
2. Ejecuta el siguiente comando para crear una nueva app llamada logistica:

   1
   python manage.py startapp logistica
   

3. Ahora, debemos registrar esta nueva app en nuestro proyecto. Abre el archivo factory_method_django/settings.py y añade 'logistica' a la lista de INSTALLED_APPS:

   1
   INSTALLED_APPS = [
   2
       # ... otras apps
   3
       'django.contrib.staticfiles',
   4
       'logistica', # Añade tu app aquí
   5
   ]
   

Dentro de la carpeta logistica, organizaremos nuestro patrón en diferentes archivos para mayor claridad: products.py, factories.py, y modificaremos views.py.

Paso 3: Codificación del Patrón Factory Method 🏭#

Ahora vamos a escribir el código Python. Usaremos el módulo abc para crear clases abstractas, el equivalente a las interfaces de Java para este caso.

1
from abc import ABC, abstractmethod
2

3
# La clase abstracta base (equivalente a la interfaz)
4
class Transporte(ABC):
5
    @abstractmethod
6
    def entregar(self) -> str:
7
        pass
8

9
# Producto Concreto
10
class Camion(Transporte):
11
    def entregar(self) -> str:
12
        return "Entrega por carretera en un camión."
13

14
# Producto Concreto
15
class Barco(Transporte):
16
    def entregar(self) -> str:
17
        return "Entrega por mar en un barco."

1
from abc import ABC, abstractmethod
2
from .products import Transporte, Camion, Barco
3

4
# El Creador Abstracto
5
class Logistica(ABC):
6
    # Este es el "Factory Method"
7
    @abstractmethod
8
    def crear_transporte(self) -> Transporte:
9
        pass
10

11
    def planificar_entrega(self) -> str:
12
        transporte = self.crear_transporte()
13
        return transporte.entregar()
14

15
# Creador Concreto
16
class LogisticaTerrestre(Logistica):
17
    def crear_transporte(self) -> Transporte:
18
        return Camion()
19

20
# Creador Concreto
21
class LogisticaMaritima(Logistica):
22
    def crear_transporte(self) -> Transporte:
23
        return Barco()

Paso 4: Crear el Cliente (La Vista de Django) 🌐#

El “cliente” en Django será una vista que recibe la petición HTTP, elige la fábrica correcta y devuelve una respuesta.

Modifica el archivo logistica/views.py que se creó automáticamente.

logistica/views.py

1
from django.http import JsonResponse
2
from .factories import Logistica, LogisticaTerrestre, LogisticaMaritima
3

4
# Un mapa para registrar nuestras fábricas.
5
# Esto nos permite añadir nuevas fábricas sin tocar esta vista.
6
FABRICAS_DISPONIBLES = {
7
    "terrestre": LogisticaTerrestre,
8
    "maritima": LogisticaMaritima,
9
}
10

11
def realizar_entrega(request, tipo: str):
12
    """
13
    Esta vista actúa como el cliente del patrón Factory Method.
14
    """
15
    # 1. Busca la clase de la fábrica correcta en nuestro mapa.
16
    fabrica_class = FABRICAS_DISPONIBLES.get(tipo)
17

18
    if not fabrica_class:
19
        return JsonResponse({"error": f"Tipo de logística no válido: {tipo}"}, status=400)
20

21
    # 2. Instancia la fábrica seleccionada.
22
    fabrica: Logistica = fabrica_class()
23

24
    # 3. Usa la fábrica para planificar la entrega, sin saber qué producto se crea.
25
    resultado = fabrica.planificar_entrega()
26

27
    return JsonResponse({"mensaje": resultado})

Paso 5: Configurar las URLs 🔗#

Necesitamos decirle a Django qué URL debe activar nuestra vista.

1. Dentro de la carpeta logistica, crea un nuevo archivo urls.py. logistica/urls.py

   1
   from django.urls import path
   2
   from . import views
   3
   
   4
   urlpatterns = [
   5
       path('entrega/<str:tipo>/', views.realizar_entrega, name='realizar_entrega'),
   6
   ]
   

2. Ahora, incluye estas URLs en el archivo principal de URLs del proyecto. factory_method_django/urls.py

   1
   from django.contrib import admin
   2
   from django.urls import path, include # Asegúrate de importar "include"
   3
   
   4
   urlpatterns = [
   5
       path('admin/', admin.site.urls),
   6
       # Añade esta línea para conectar las URLs de tu app
   7
       path('api/logistica/', include('logistica.urls')),
   8
   ]
   

Paso 6: Probar la Aplicación ✅#

¡Todo está configurado!

1. En la terminal de PyCharm, ejecuta el servidor de desarrollo de Django:

   1
   python manage.py runserver
   

2. Usa un navegador o curl para probar los siguientes endpoints:

• Para la entrega terrestre: http://127.0.0.1:8000/api/logistica/entrega/terrestre/

  Respuesta esperada (JSON):

  1
  {
  2
      "mensaje": "Entrega por carretera en un camión."
  3
  }
  

• Para la entrega marítima: http://127.0.0.1:8000/api/logistica/entrega/maritima/

  Respuesta esperada (JSON):

  1
  {
  2
      "mensaje": "Entrega por mar en un barco."
  3
  }
  

• Para un tipo no existente: http://127.0.0.1:8000/api/logistica/entrega/aerea/

  Respuesta esperada (JSON con código 400):

  1
  {
  2
      "error": "Tipo de logística no válido: aerea"
  3
  }
  

Con estos pasos, has implementado exitosamente el patrón Factory Method en un proyecto Django, manteniendo tu código desacoplado y listo para expandirse con nuevos tipos de transporte sin necesidad de modificar la lógica del cliente.