Teoría#

Definición#

El patrón Abstract Factory (Fábrica abstracta) es un patrón creacional que permite crear familias de objetos relacionados sin especificar sus clases concretas. La clave es encapsular el código de creación en fábricas, de manera que el cliente trabaje solo con interfaces abstractas, manteniendo compatibilidad y flexibilidad.

Cuándo usarlo#

Cuando necesitamos grupos de productos relacionados (botones, menús, muebles, etc.) que deben funcionar juntos.
Cuando queremos evitar acoplamiento con clases concretas.
Cuando el sistema debe cambiar de variantes fácilmente (ej. estilos moderno/victoriano, Windows/Linux).

Cuándo no usarlo#

Si solo necesitamos una familia de objetos o un único producto.
Si la creación de objetos no cambia o no hay variantes.
Cuando el patrón añade complejidad innecesaria para casos simples.

Estructura (Mermaid)#

1
classDiagram
2
    class AbstractFactory {
3
        <<interface>>
4
        +createChair(): Chair
5
        +createSofa(): Sofa
6
    }
7

8
    class ModernFurnitureFactory {
9
        +createChair(): Chair
10
        +createSofa(): Sofa
11
    }
12

13
    class VictorianFurnitureFactory {
14
        +createChair(): Chair
15
        +createSofa(): Sofa
16
    }
17

18
    class Chair {
19
        <<interface>>
20
        +sit()
21
    }
22

23
    class Sofa {
24
        <<interface>>
25
        +lieDown()
26
    }
27

28
    class ModernChair {
29
        +sit()
30
    }
31

32
    class VictorianChair {
33
        +sit()
34
    }
35

36
    class ModernSofa {
37
        +lieDown()
38
    }
39

40
    class VictorianSofa {
41
        +lieDown()
42
    }
43

44
    AbstractFactory <|.. ModernFurnitureFactory
45
    AbstractFactory <|.. VictorianFurnitureFactory
46
    Chair <|.. ModernChair
47
    Chair <|.. VictorianChair
48
    Sofa <|.. ModernSofa
49
    Sofa <|.. VictorianSofa

Ejemplo en Spring Boot (Java)#

1
// Interfaces de productos
2
public interface Chair {
3
    void sit();
4
}
5

6
public interface Sofa {
7
    void lieDown();
8
}
9

10
// Implementaciones concretas
11
public class ModernChair implements Chair {
12
    public void sit() { System.out.println("Sentado en una silla moderna."); }
13
}
14

15
public class VictorianChair implements Chair {
16
    public void sit() { System.out.println("Sentado en una silla victoriana."); }
17
}
18

19
public class ModernSofa implements Sofa {
20
    public void lieDown() { System.out.println("Acostado en un sofá moderno."); }
21
}
22

23
public class VictorianSofa implements Sofa {
24
    public void lieDown() { System.out.println("Acostado en un sofá victoriano."); }
25
}
26

27
// Abstract Factory
28
public interface FurnitureFactory {
29
    Chair createChair();
30
    Sofa createSofa();
31
}
32

33
// Fábricas concretas
34
public class ModernFurnitureFactory implements FurnitureFactory {
35
    public Chair createChair() { return new ModernChair(); }
36
    public Sofa createSofa() { return new ModernSofa(); }
37
}
38

39
public class VictorianFurnitureFactory implements FurnitureFactory {
40
    public Chair createChair() { return new VictorianChair(); }
41
    public Sofa createSofa() { return new VictorianSofa(); }
42
}
43

44
// Cliente (Spring Boot Service)
45
@Service
46
public class FurnitureService {
47
    private final FurnitureFactory factory;
48

49
    public FurnitureService() {
50
        // Aquí podría decidirse por configuración
51
        this.factory = new ModernFurnitureFactory();
52
    }
53

54
    public void demo() {
55
        Chair chair = factory.createChair();
56
        Sofa sofa = factory.createSofa();
57
        chair.sit();
58
        sofa.lieDown();
59
    }
60
}

Ejemplo en Django (Python)#

1
from abc import ABC, abstractmethod
2

3
# Interfaces
4
class Chair(ABC):
5
    @abstractmethod
6
    def sit(self): pass
7

8
class Sofa(ABC):
9
    @abstractmethod
10
    def lie_down(self): pass
11

12
# Implementaciones concretas
13
class ModernChair(Chair):
14
    def sit(self):
15
        return "Sentado en una silla moderna"
16

17
class VictorianChair(Chair):
18
    def sit(self):
19
        return "Sentado en una silla victoriana"
20

21
class ModernSofa(Sofa):
22
    def lie_down(self):
23
        return "Acostado en un sofá moderno"
24

25
class VictorianSofa(Sofa):
26
    def lie_down(self):
27
        return "Acostado en un sofá victoriano"
28

29
# Abstract Factory
30
class FurnitureFactory(ABC):
31
    @abstractmethod
32
    def create_chair(self) -> Chair: pass
33

34
    @abstractmethod
35
    def create_sofa(self) -> Sofa: pass
36

37
# Fábricas concretas
38
class ModernFurnitureFactory(FurnitureFactory):
39
    def create_chair(self): return ModernChair()
40
    def create_sofa(self): return ModernSofa()
41

42
class VictorianFurnitureFactory(FurnitureFactory):
43
    def create_chair(self): return VictorianChair()
44
    def create_sofa(self): return VictorianSofa()
45

46
# Cliente en Django (ejemplo en views.py)
47
from django.http import JsonResponse
48

49
def furniture_demo(request):
50
    factory = ModernFurnitureFactory()  # Podría cambiarse dinámicamente
51
    chair = factory.create_chair()
52
    sofa = factory.create_sofa()
53
    return JsonResponse({
54
        "chair": chair.sit(),
55
        "sofa": sofa.lie_down()
56
    })

Resumen#

Abstract Factory permite crear familias de productos consistentes sin acoplar el código a implementaciones concretas.
Es útil en aplicaciones que necesitan variantes intercambiables (ej. estilos, SO, catálogos).
Se aplica tanto en Java (Spring Boot) como en Python (Django) con interfaces y fábricas concretas.

Práctica con Spring Boot#

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

Primero, vamos a crear un proyecto nuevo y limpio.

Abre IntelliJ IDEA y ve a File > New > Project….
En la ventana que aparece, selecciona Spring Initializr en el panel izquierdo.
Configura los metadatos de tu proyecto. Puedes usar estos valores:
- Name: abstract-factory-ejemplo
- Location: La carpeta donde quieras guardarlo.
- Language: Java
- Type: Gradle - Groovy (o Maven si lo prefieres, ambos funcionarán).
- Group: com.example.solid
- Artifact: abstract-factory-ejemplo
- JDK: Asegúrate de seleccionar la versión 17 (o superior).
- Packaging: Jar
Haz clic en Next.
Ahora, elige las dependencias. Para este proyecto, solo necesitas una:
- Busca y selecciona Spring Web.
Haz clic en Create. IntelliJ generará la estructura del proyecto y descargará las dependencias.

Paso 2: Estructura de Paquetes 📂#

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

products: Contendrá las interfaces de los productos (ej. Silla) y sus implementaciones concretas (ej. SillaModerna).
factory: Contendrá la interfaz de la fábrica abstracta (MuebleriaFactory) y sus implementaciones concretas (MuebleriaModernaFactory).
controller: Contendrá nuestro RestController, que actuará como el cliente del patrón.

Paso 3: Codificación del Patrón Abstract Factory 🛋️#

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

3.1. Productos Abstractos (Interfaces)#

Dentro del paquete products, crea estas dos interfaces. Serán el contrato para nuestras familias de objetos.

Silla.java

1
package com.example.solid.abstractfactoryejemplo.products;
2

3
public interface Silla {
4
    String sentarse();
5
}

Sofa.java

1
package com.example.solid.abstractfactoryejemplo.products;
2

3
public interface Sofa {
4
    String recostarse();
5
}

3.2. Productos Concretos (Implementaciones)#

En el mismo paquete products, crea las cuatro clases que implementan las interfaces anteriores. Estos son los objetos reales que construiremos.

SillaModerna.java

1
package com.example.solid.abstractfactoryejemplo.products;
2

3
public class SillaModerna implements Silla {
4
    @Override
5
    public String sentarse() {
6
        return "Sentado cómodamente en una silla moderna.";
7
    }
8
}

SillaVictoriana.java

1
package com.example.solid.abstractfactoryejemplo.products;
2

3
public class SillaVictoriana implements Silla {
4
    @Override
5
    public String sentarse() {
6
        return "Sentado con elegancia en una silla victoriana.";
7
    }
8
}

SofaModerno.java

1
package com.example.solid.abstractfactoryejemplo.products;
2

3
public class SofaModerno implements Sofa {
4
    @Override
5
    public String recostarse() {
6
        return "Recostado en un sofá de diseño minimalista.";
7
    }
8
}

SofaVictoriano.java

1
package com.example.solid.abstractfactoryejemplo.products;
2

3
public class SofaVictoriano implements Sofa {
4
    @Override
5
    public String recostarse() {
6
        return "Descansando sobre un sofá victoriano de terciopelo.";
7
    }
8
}

3.3. Fábrica Abstracta (Interfaz)#

Ahora, en el paquete factory, crea la interfaz que define qué productos pueden crear nuestras fábricas.

MuebleriaFactory.java

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

3
import com.example.solid.abstractfactoryejemplo.products.Silla;
4
import com.example.solid.abstractfactoryejemplo.products.Sofa;
5

6
public interface MuebleriaFactory {
7
    Silla crearSilla();
8
    Sofa crearSofa();
9
}

3.4. Fábricas Concretas (Implementaciones)#

En el mismo paquete factory, crea las fábricas que saben cómo construir una familia de productos específica (moderna o victoriana). Las anotamos como @Component de Spring para que el sistema las reconozca y las podamos inyectar después.

MuebleriaModernaFactory.java

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

3
import com.example.solid.abstractfactoryejemplo.products.*;
4
import org.springframework.stereotype.Component;
5

6
@Component("moderna") // Nombre clave para identificar esta fábrica
7
public class MuebleriaModernaFactory implements MuebleriaFactory {
8
    @Override
9
    public Silla crearSilla() {
10
        return new SillaModerna();
11
    }
12

13
    @Override
14
    public Sofa crearSofa() {
15
        return new SofaModerno();
16
    }
17
}

MuebleriaVictorianaFactory.java

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

3
import com.example.solid.abstractfactoryejemplo.products.*;
4
import org.springframework.stereotype.Component;
5

6
@Component("victoriana") // Nombre clave para esta otra fábrica
7
public class MuebleriaVictorianaFactory implements MuebleriaFactory {
8
    @Override
9
    public Silla crearSilla() {
10
        return new SillaVictoriana();
11
    }
12

13
    @Override
14
    public Sofa crearSofa() {
15
        return new SofaVictoriano();
16
    }
17
}

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 misma técnica elegante del ejemplo anterior para que Spring nos inyecte todas las fábricas disponibles.

MuebleriaController.java

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

3
import com.example.solid.abstractfactoryejemplo.factory.MuebleriaFactory;
4
import com.example.solid.abstractfactoryejemplo.products.Silla;
5
import com.example.solid.abstractfactoryejemplo.products.Sofa;
6
import org.springframework.beans.factory.annotation.Autowired;
7
import org.springframework.http.ResponseEntity;
8
import org.springframework.web.bind.annotation.GetMapping;
9
import org.springframework.web.bind.annotation.PathVariable;
10
import org.springframework.web.bind.annotation.RequestMapping;
11
import org.springframework.web.bind.annotation.RestController;
12

13
import java.util.Map;
14
import java.util.Optional;
15

16
@RestController
17
@RequestMapping("/api/muebles")
18
public class MuebleriaController {
19

20
    // Spring inyecta un mapa con todas las fábricas. La clave es el nombre
21
    // que pusimos en @Component ("moderna", "victoriana").
22
    private final Map<String, MuebleriaFactory> factories;
23

24
    @Autowired
25
    public MuebleriaController(Map<String, MuebleriaFactory> factories) {
26
        this.factories = factories;
27
    }
28

29
    @GetMapping("/crear/{estilo}")
30
    public ResponseEntity<?> crearMuebles(@PathVariable String estilo) {
31
        // Buscamos la fábrica correcta según el "estilo" de la URL.
32
        MuebleriaFactory factory = factories.get(estilo);
33

34
        if (factory == null) {
35
            return ResponseEntity.badRequest().body("Estilo de mueblería no disponible: " + estilo);
36
        }
37

38
        // Usamos la fábrica para crear la familia de productos.
39
        Silla silla = factory.crearSilla();
40
        Sofa sofa = factory.crearSofa();
41

42
        // Creamos una respuesta con los mensajes de los productos creados.
43
        Map<String, String> response = Map.of(
44
            "silla", silla.sentarse(),
45
            "sofa", sofa.recostarse(),
46
            "fabrica_usada", factory.getClass().getSimpleName()
47
        );
48

49
        return ResponseEntity.ok(response);
50
    }
51
}

Paso 5: Probar la Aplicación ✅#

¡Todo está listo!

Ejecuta tu aplicación desde la clase principal AbstractFactoryEjemploApplication.
Usa un navegador o una herramienta como Postman para probar los siguientes endpoints:

Para obtener muebles modernos: http://localhost:8080/api/muebles/crear/moderna

Respuesta esperada (JSON):

1
{
2
    "silla": "Sentado cómodamente en una silla moderna.",
3
    "sofa": "Recostado en un sofá de diseño minimalista.",
4
    "fabrica_usada": "MuebleriaModernaFactory"
5
}

Para obtener muebles victorianos: http://localhost:8080/api/muebles/crear/victoriana

Respuesta esperada (JSON):

1
{
2
    "silla": "Sentado con elegancia en una silla victoriana.",
3
    "sofa": "Descansando sobre un sofá victoriano de terciopelo.",
4
    "fabrica_usada": "MuebleriaVictorianaFactory"
5
}

Para un estilo no existente: http://localhost:8080/api/muebles/crear/rustica

Respuesta esperada: Estilo de mueblería no disponible: rustica

Práctica con Django#

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

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

Abre PyCharm (versión Professional) y ve a File > New > Project….
En la ventana que aparece, selecciona Django en el panel izquierdo.
Configura tu proyecto:
- Location: Elige una carpeta y nombra el proyecto, por ejemplo, abstract_factory_django.
- New environment using: Selecciona Virtualenv. Esto creará un entorno virtual aislado para tu proyecto.
- Application name: Puedes nombrar tu primera aplicación core.
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 mueblería.

Abre la Terminal dentro de PyCharm (View > Tool Windows > Terminal).
Ejecuta el siguiente comando para crear una nueva app llamada muebleria:
Terminal window
```
1
python manage.py startapp muebleria
```
Ahora, registra esta nueva app en tu proyecto. Abre el archivo abstract_factory_django/settings.py y añade 'muebleria' a la lista de INSTALLED_APPS:
abstract_factory_django/settings.py
```
1
INSTALLED_APPS = [
2
    # ... otras apps
3
    'django.contrib.staticfiles',
4
    'muebleria', # Añade tu app aquí
5
]
```

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

Paso 3: Codificación del Patrón Abstract Factory 🛋️#

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

3.1. Productos Abstractos#

Dentro de la carpeta muebleria, crea un nuevo archivo llamado products.py.

Añade el siguiente código con las clases base para nuestros productos:

muebleria/products.py

1
from abc import ABC, abstractmethod
2

3
# Producto Abstracto 1
4
class Silla(ABC):
5
    @abstractmethod
6
    def sentarse(self) -> str:
7
        pass
8

9
# Producto Abstracto 2
10
class Sofa(ABC):
11
    @abstractmethod
12
    def recostarse(self) -> str:
13
        pass
14

15
# --- Implementaciones de la familia Moderna ---
16

17
class SillaModerna(Silla):
18
    def sentarse(self) -> str:
19
        return "Sentado cómodamente en una silla moderna."
20

21
class SofaModerno(Sofa):
22
    def recostarse(self) -> str:
23
        return "Recostado en un sofá de diseño minimalista."
24

25
# --- Implementaciones de la familia Victoriana ---
26

27
class SillaVictoriana(Silla):
28
    def sentarse(self) -> str:
29
        return "Sentado con elegancia en una silla victoriana."
30

31
class SofaVictoriano(Sofa):
32
    def recostarse(self) -> str:
33
        return "Descansando sobre un sofá victoriano de terciopelo."

3.2. Fábricas (Abstracta y Concretas)#

Dentro de la carpeta muebleria, crea otro archivo nuevo llamado factories.py.

Añade el siguiente código para definir las fábricas:

muebleria/factories.py

1
from abc import ABC, abstractmethod
2
from .products import (
3
    Silla, Sofa,
4
    SillaModerna, SofaModerno,
5
    SillaVictoriana, SofaVictoriano
6
)
7

8
# La Fábrica Abstracta
9
class MuebleriaFactory(ABC):
10
    @abstractmethod
11
    def crear_silla(self) -> Silla:
12
        pass
13

14
    @abstractmethod
15
    def crear_sofa(self) -> Sofa:
16
        pass
17

18
# Fábrica Concreta 1: para muebles modernos
19
class MuebleriaModernaFactory(MuebleriaFactory):
20
    def crear_silla(self) -> Silla:
21
        return SillaModerna()
22

23
    def crear_sofa(self) -> Sofa:
24
        return SofaModerno()
25

26
# Fábrica Concreta 2: para muebles victorianos
27
class MuebleriaVictorianaFactory(MuebleriaFactory):
28
    def crear_silla(self) -> Silla:
29
        return SillaVictoriana()
30

31
    def crear_sofa(self) -> Sofa:
32
        return SofaVictoriano()

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 JSON.

Modifica el archivo muebleria/views.py.

muebleria/views.py

1
from django.http import JsonResponse
2
from .factories import MuebleriaModernaFactory, MuebleriaVictorianaFactory
3

4
# Un mapa para registrar nuestras fábricas disponibles.
5
FABRICAS = {
6
    "moderna": MuebleriaModernaFactory,
7
    "victoriana": MuebleriaVictorianaFactory,
8
}
9

10
def crear_muebles(request, estilo: str):
11
    """
12
    Esta vista actúa como el cliente del patrón Abstract Factory.
13
    """
14
    # 1. Busca la clase de la fábrica correcta.
15
    fabrica_class = FABRICAS.get(estilo)
16

17
    if not fabrica_class:
18
        return JsonResponse({"error": f"Estilo de mueblería no disponible: {estilo}"}, status=400)
19

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

23
    # 3. Usa la fábrica para crear la familia de productos.
24
    silla = fabrica.crear_silla()
25
    sofa = fabrica.crear_sofa()
26

27
    # 4. Construye y devuelve la respuesta.
28
    response_data = {
29
        "silla": silla.sentarse(),
30
        "sofa": sofa.recostarse(),
31
        "fabrica_usada": fabrica.__class__.__name__
32
    }
33
    return JsonResponse(response_data)

Paso 5: Configurar las URLs 🔗#

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

Dentro de la carpeta muebleria, crea un nuevo archivo urls.py.

muebleria/urls.py

1
from django.urls import path
2
from . import views
3

4
urlpatterns = [
5
    path('crear/<str:estilo>/', views.crear_muebles, name='crear_muebles'),
6
]

Ahora, incluye estas URLs en el archivo principal del proyecto.

abstract_factory_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
    path('api/muebles/', include('muebleria.urls')), # Conecta las URLs de tu app
7
]

Paso 6: Probar la Aplicación ✅#

¡Todo está configurado!

En la terminal de PyCharm, ejecuta el servidor de desarrollo de Django:
Terminal window
```
1
python manage.py runserver
```
Usa un navegador o curl para probar los siguientes endpoints:

Para obtener muebles modernos: http://127.0.0.1:8000/api/muebles/crear/moderna/

Respuesta esperada (JSON):

1
{
2
    "silla": "Sentado cómodamente en una silla moderna.",
3
    "sofa": "Recostado en un sofá de diseño minimalista.",
4
    "fabrica_usada": "MuebleriaModernaFactory"
5
}

Para obtener muebles victorianos: http://127.0.0.1:8000/api/muebles/crear/victoriana/

Respuesta esperada (JSON):

1
{
2
    "silla": "Sentado con elegancia en una silla victoriana.",
3
    "sofa": "Descansando sobre un sofá victoriano de terciopelo.",
4
    "fabrica_usada": "MuebleriaVictorianaFactory"
5
}

Para un estilo no existente: http://127.0.0.1:8000/api/muebles/crear/rustica/

Respuesta esperada (JSON con código 400):
```
1
{
2
    "error": "Estilo de mueblería no disponible: rustica"
3
}
```