Definición 🧬#

El patrón Prototype (Prototipo) es un patrón de diseño creacional que te permite crear nuevos objetos copiando una instancia existente, en lugar de crear el objeto desde cero. A esta instancia que se copia se le llama “prototipo”.

Funciona declarando un método de clonación en una interfaz común. Todas las clases que soportan la clonación pueden ser copiadas para crear nuevos objetos con el mismo estado inicial, que luego pueden ser modificados.

Problema#

Imagina que tienes un objeto que es muy costoso de crear. Su instanciación podría requerir consultas a la base de datos, llamadas a servicios de red, cálculos complejos o la lectura de archivos de configuración pesados.

Si necesitas crear muchas instancias de este objeto, o instancias que son muy similares entre sí, repetir este costoso proceso de creación una y otra vez es muy ineficiente. Por ejemplo, cargar la configuración de un objeto Reporte con su logo, pie de página y estilos corporativos cada vez que se genera un nuevo reporte.

Solución#

En lugar de construir el objeto desde cero, el patrón Prototype propone una solución más directa:

1. Crear un objeto prototipo: Se crea una instancia inicial del objeto con la configuración base (por ejemplo, el Reporte corporativo).
2. Clonar el prototipo: Cuando se necesita un nuevo objeto, en lugar de usar el operador new y reconfigurar todo, se le pide al prototipo que se clone a sí mismo.
3. Modificar el clon: El nuevo objeto es una copia exacta del prototipo, pero es una instancia completamente independiente. Ahora puedes modificar los detalles específicos (como el título o el contenido) del clon sin afectar al prototipo original.

Esto es especialmente útil cuando la mayoría de los objetos que necesitas son variaciones de un mismo “molde”.

Estructura (Mermaid UML)#

El diagrama es simple: un cliente pide a un prototipo que se clone, y recibe un nuevo objeto del mismo tipo.

1
classDiagram
2
    direction TB
3

4
    class Client
5
    note for Client "Pide un clon a un prototipo"
6

7
    class Prototype {
8
        <<Interface>>
9
        +clone(): Prototype
10
    }
11

12
    class ConcretePrototype1 {
13
        -field1
14
        +clone(): Prototype
15
    }
16

17
    class ConcretePrototype2 {
18
        -field2
19
        +clone(): Prototype
20
    }
21

22
    Client ..> Prototype : solicita clon
23
    Prototype <|.. ConcretePrototype1
24
    Prototype <|.. ConcretePrototype2

A menudo, se utiliza un Registro de Prototipos (Prototype Registry), que es una clase que gestiona un conjunto de prototipos listos para ser clonados bajo demanda.

Cuándo usar#

• Cuando la creación de un objeto es costosa y es más eficiente copiar uno existente.
• Cuando tu código no debe depender de las clases concretas de los objetos que necesitas copiar.
• Cuando quieres ofrecer un conjunto de “objetos predefinidos” que los clientes puedan configurar.

Cuándo no usar#

• Cuando los objetos son simples, no tienen un estado complicado y su creación no consume muchos recursos.
• Si tu objeto tiene muchas referencias circulares o una lógica de clonación muy compleja que podría generar errores.

Ejemplo en Spring Boot (Java)#

1
// Interfaz Prototype
2
public interface DocumentoPrototype extends Cloneable {
3
    DocumentoPrototype clonar();
4
    void setContenido(String contenido);
5
}
6

7
// Prototipo Concreto
8
public class Contrato implements DocumentoPrototype {
9
    private String tipo;
10
    private String contenidoBase; // Contenido costoso de cargar
11

12
    public Contrato() {
13
        this.tipo = "Contrato de Confidencialidad";
14
        // Imagina que esto se carga de un archivo o DB
15
        this.contenidoBase = "Este es el texto legal base...";
16
    }
17

18
    @Override
19
    public DocumentoPrototype clonar() {
20
        return new Contrato(); // Clonación simple en este caso
21
    }
22

23
    @Override
24
    public void setContenido(String contenido) { this.contenidoBase = contenido; }
25
}
26

27
// Cliente
28
@Service
29
public class GestorDocumentos {
30
    public void generarDocumentos() {
31
        Contrato prototipoContrato = new Contrato();
32

33
        // Creamos un nuevo contrato clonando el prototipo
34
        Contrato nuevoContrato = (Contrato) prototipoContrato.clonar();
35
        nuevoContrato.setContenido("...añadiendo cláusulas específicas para el empleado X.");
36

37
        // El prototipo original no ha cambiado
38
    }
39
}

Ejemplo en Django (Python)#

1
import copy
2

3
# Prototipo (puede ser una clase base o no)
4
class Documento:
5
    def __init__(self, titulo, contenido_base):
6
        self.titulo = titulo
7
        self.contenido = contenido_base
8
        # Imagina que contenido_base es costoso de generar
9

10
    def clonar(self):
11
        # deepcopy crea una copia completamente independiente
12
        return copy.deepcopy(self)
13

14
# Cliente (una vista de Django)
15
from django.http import JsonResponse
16

17
# Registro de Prototipos
18
PROTOTIPOS = {
19
    "contrato": Documento("Contrato de Empleado", "Texto legal base..."),
20
    "informe": Documento("Informe Mensual", "Estructura base del informe...")
21
}
22

23
def crear_documento_view(request, tipo: str):
24
    prototipo = PROTOTIPOS.get(tipo)
25
    if not prototipo:
26
        return JsonResponse({"error": "Tipo de documento no válido"}, status=400)
27

28
    # Clonamos el prototipo
29
    nuevo_documento = prototipo.clonar()
30

31
    # Modificamos el clon
32
    nuevo_documento.contenido += "\nSección añadida para el departamento de ventas."
33

34
    return JsonResponse(nuevo_documento.__dict__)

Resumen#

• El patrón Prototype se basa en clonar objetos existentes para crear otros nuevos.
• Es una alternativa a la creación de objetos mediante new cuando esta es computacionalmente costosa.
• Permite crear objetos sin acoplar el código cliente a sus clases concretas, ya que el cliente solo necesita saber cómo clonar.

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

1. Abre IntelliJ IDEA y ve a File > New > Project….
2. Selecciona Spring Initializr.
3. Configura los metadatos:
   • Name: prototype-ejemplo
   • Language: Java
   • Type: Gradle - Groovy
   • Group: com.example.solid
   • JDK: 17 o superior
4. Haz clic en Next.
5. Añade la dependencia Spring Web.
6. Haz clic en Create.

Paso 2: Estructura de Paquetes 📂#

Dentro de src/main/java/com/example/solid/prototypeejemplo, crea estos paquetes:

• model: Contendrá nuestras clases de documentos que actuarán como prototipos.
• registry: Contendrá una clase para gestionar y servir los prototipos.
• controller: Contendrá nuestro RestController que actuará como cliente.

Paso 3: Codificación del Patrón Prototype 🧬#

1
package com.example.solid.prototypeejemplo.model;
2

3
import lombok.Data;
4

5
@Data // De Lombok para getters/setters
6
public abstract class Documento implements Cloneable {
7
    private String titulo;
8
    private String contenido;
9
    private String firma;
10

11
    @Override
12
    public Documento clone() {
13
        try {
14
            return (Documento) super.clone();
15
        } catch (CloneNotSupportedException e) {
16
            // Esto no debería pasar, ya que implementamos Cloneable
17
            return null;
18
        }
19
    }
20
}

1
package com.example.solid.prototypeejemplo.model;
2

3
public class Contrato extends Documento {
4
    // Puedes añadir campos específicos del contrato si quieres
5
}

1
package com.example.solid.prototypeejemplo.model;
2

3
public class Informe extends Documento {
4
    // Puedes añadir campos específicos del informe si quieres
5
}

1
package com.example.solid.prototypeejemplo.registry;
2

3
import com.example.solid.prototypeejemplo.model.Contrato;
4
import com.example.solid.prototypeejemplo.model.Documento;
5
import com.example.solid.prototypeejemplo.model.Informe;
6
import jakarta.annotation.PostConstruct;
7
import org.springframework.stereotype.Component;
8

9
import java.util.HashMap;
10
import java.util.Map;
11

12
@Component
13
public class DocumentoRegistry {
14

15
    private final Map<String, Documento> prototipos = new HashMap<>();
16

17
    @PostConstruct // Este método se ejecuta cuando Spring crea el bean
18
    public void cargarPrototipos() {
19
        // Creamos y configuramos nuestros prototipos base una sola vez
20
        Contrato contratoBase = new Contrato();
21
        contratoBase.setTitulo("Contrato de Confidencialidad Estándar");
22
        contratoBase.setContenido("Texto legal base que es costoso de cargar...");
23
        contratoBase.setFirma("Firma Digital de la Empresa");
24

25
        Informe informeBase = new Informe();
26
        informeBase.setTitulo("Plantilla de Informe Mensual");
27
        informeBase.setContenido("Estructura base del informe...");
28
        informeBase.setFirma("Firma del Departamento de BI");
29

30
        prototipos.put("contrato", contratoBase);
31
        prototipos.put("informe", informeBase);
32
    }
33

34
    public Documento crearDocumento(String tipo) {
35
        Documento prototipo = prototipos.get(tipo);
36
        if (prototipo != null) {
37
            return prototipo.clone(); // ¡Devolvemos un clon, no el original!
38
        }
39
        return null;
40
    }
41
}

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

Dentro del paquete controller, crea el RestController.

DocumentoController.java

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

3
import com.example.solid.prototypeejemplo.model.Documento;
4
import com.example.solid.prototypeejemplo.registry.DocumentoRegistry;
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.RequestParam;
10
import org.springframework.web.bind.annotation.RestController;
11

12
@RestController
13
@RequestMapping("/api/documentos")
14
public class DocumentoController {
15

16
    private final DocumentoRegistry registry;
17

18
    public DocumentoController(DocumentoRegistry registry) {
19
        this.registry = registry;
20
    }
21

22
    @GetMapping("/crear/{tipo}")
23
    public ResponseEntity<Documento> crearDocumento(@PathVariable String tipo, @RequestParam String autor) {
24
        Documento nuevoDocumento = registry.crearDocumento(tipo);
25

26
        if (nuevoDocumento == null) {
27
            return ResponseEntity.badRequest().build();
28
        }
29

30
        // Modificamos el clon con datos específicos de la petición
31
        nuevoDocumento.setTitulo(nuevoDocumento.getTitulo() + " para " + autor);
32
        nuevoDocumento.setFirma(autor);
33

34
        return ResponseEntity.ok(nuevoDocumento);
35
    }
36
}

Paso 5: Probar la Aplicación ✅#

1. Ejecuta la aplicación desde PrototypeEjemploApplication.
2. Usa tu navegador o curl para probar los endpoints:

• Crear un contrato para “Ángel”: http://localhost:8080/api/documentos/crear/contrato?autor=Angel

  Respuesta esperada (JSON):

  1
  {
  2
      "titulo": "Contrato de Confidencialidad Estándar para Angel",
  3
      "contenido": "Texto legal base que es costoso de cargar...",
  4
      "firma": "Angel"
  5
  }
  

• Crear un informe para “Jesús”: http://localhost:8080/api/documentos/crear/informe?autor=Jesus

  Respuesta esperada (JSON):

  1
  {
  2
      "titulo": "Plantilla de Informe Mensual para Jesus",
  3
      "contenido": "Estructura base del informe...",
  4
      "firma": "Jesus"
  5
  }
  

Como puedes ver, cada petición genera un nuevo objeto basado en el prototipo, pero con sus propias modificaciones.

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

1. En PyCharm, ve a File > New Project… y selecciona Django.
2. Nombra el proyecto prototype_django y crea una app inicial core.

Paso 2: Estructura de la App Django 📂#

1. En la terminal, crea una nueva app:

   1
   python manage.py startapp documentos
   

2. Añade 'documentos' a INSTALLED_APPS en prototype_django/settings.py.

Paso 3: Codificación del Patrón Prototype 🧬#

1
import copy
2
from dataclasses import dataclass, field
3

4
@dataclass
5
class Documento:
6
    titulo: str = ""
7
    contenido: str = ""
8
    firma: str = ""
9

10
    def clonar(self):
11
        # deepcopy crea una copia recursiva y completamente independiente
12
        return copy.deepcopy(self)
13

14
@dataclass
15
class Contrato(Documento):
16
    pass
17

18
@dataclass
19
class Informe(Documento):
20
    pass

1
from .models import Contrato, Informe, Documento
2

3
class DocumentoRegistry:
4
    def __init__(self):
5
        self._prototipos = {}
6
        self._cargar_prototipos()
7

8
    def _cargar_prototipos(self):
9
        self._prototipos["contrato"] = Contrato(
10
            titulo="Contrato de Confidencialidad Estándar",
11
            contenido="Texto legal base que es costoso de cargar...",
12
            firma="Firma Digital de la Empresa"
13
        )
14
        self._prototipos["informe"] = Informe(
15
            titulo="Plantilla de Informe Mensual",
16
            contenido="Estructura base del informe...",
17
            firma="Firma del Departamento de BI"
18
        )
19

20
    def crear_documento(self, tipo: str) -> Documento | None:
21
        prototipo = self._prototipos.get(tipo)
22
        return prototipo.clonar() if prototipo else None
23

24
# Instanciamos el registro para que sea un Singleton de facto
25
registry_instance = DocumentoRegistry()

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

documentos/views.py

1
from django.http import JsonResponse
2
from .registry import registry_instance
3
import dataclasses
4

5
def crear_documento(request, tipo: str):
6
    autor = request.GET.get("autor", "Desconocido")
7

8
    # Usamos el registro para obtener un clon
9
    nuevo_documento = registry_instance.crear_documento(tipo)
10

11
    if not nuevo_documento:
12
        return JsonResponse({"error": "Tipo de documento no válido"}, status=400)
13

14
    # Modificamos el clon
15
    nuevo_documento.titulo += f" para {autor}"
16
    nuevo_documento.firma = autor
17

18
    # Convertimos el dataclass a dict para la respuesta JSON
19
    return JsonResponse(dataclasses.asdict(nuevo_documento))

Paso 5: Configurar las URLs y Probar ✅#

1. Crea documentos/urls.py:

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

2. Incluye estas URLs en prototype_django/urls.py:

   1
   from django.urls import path, include
   2
   urlpatterns = [path('api/documentos/', include('documentos.urls'))]
   

3. Ejecuta python manage.py runserver y prueba los endpoints:
   • http://127.0.0.1:8000/api/documentos/crear/contrato/?autor=Angel

     Respuesta: {"titulo": "Contrato de Confidencialencialidad Estándar para Angel", "contenido": "Texto legal base...", "firma": "Angel"}

   • http://127.0.0.1:8000/api/documentos/crear/informe/?autor=Jesus

     Respuesta: {"titulo": "Plantilla de Informe Mensual para Jesus", "contenido": "Estructura base del informe...", "firma": "Jesus"}