Patrón de diseño: explicación detallada del patrón de prototipo

Prefacio

• Introducción a los patrones de diseño.
• Los patrones de diseño son soluciones a problemas comunes en el desarrollo de software. Son ideas y soluciones de diseño reutilizables resumidas a través de la práctica y la experiencia. Los patrones de diseño ayudan a los desarrolladores a escribir código de alta calidad de manera más eficiente al proporcionar estructuras, principios y orientación comunes.
  Los patrones de diseño se dividen en tres categorías principales:

1. Patrón de creación: se centra en el proceso de creación de objetos, incluido cómo crear instancias de objetos, ocultar los detalles de la creación de objetos y copiar y clonar objetos.
2. Patrones estructurales: céntrese en la forma en que se combinan los objetos y las clases para lograr el objetivo de una estructura más amplia, como las relaciones entre clases.
3. Patrones de comportamiento: céntrese en cómo las clases y los objetos interactúan y se comunican para lograr una mejor colaboración y control.

• Introducción al patrón prototipo
  El patrón prototipo es un tipo de patrón de creación que se centra en copiar y clonar objetos. En algunos casos, crear nuevos objetos mediante la creación de instancias tradicionales puede resultar prohibitivamente costoso o complejo. En este momento, el patrón prototipo proporciona un método alternativo para crear nuevos objetos clonando objetos existentes, evitando así el costoso proceso de inicialización.

El patrón prototipo puede ahorrar recursos y tiempo y mejorar la eficiencia de la creación de objetos mediante el uso del método de clonación para generar nuevos objetos. Es adecuado para escenarios donde es necesario crear una gran cantidad de objetos similares, también tiene buena escalabilidad y puede implementar una lógica de clonación personalizada heredando y anulando el método de clonación según sea necesario.

En resumen, el patrón prototipo es un patrón de diseño que crea nuevos objetos clonando objetos existentes. Proporciona una forma flexible y eficiente de crear objetos, lo que puede mejorar significativamente la reutilización y la capacidad de mantenimiento del código en ciertos escenarios.

Bases teóricas

1. Definición del patrón prototipo.

El patrón prototipo es un patrón de diseño creacional que permite crear nuevos objetos clonando objetos existentes sin depender del proceso de creación de instancias tradicional. Este patrón crea un nuevo objeto independiente copiando las propiedades y el estado de un objeto existente, y sus propiedades específicas se pueden modificar según sea necesario.

En el patrón prototipo, definimos una clase prototipo abstracta que contiene un método abstracto para clonar un objeto. La clase prototipo concreta hereda de la clase prototipo abstracta e implementa el método de clonación para devolver una copia clonada de sí misma. El código del cliente utiliza una instancia de la clase prototipo concreta y llama a su método de clonación para crear un nuevo objeto.

La idea clave del patrón prototipo es crear nuevos objetos a partir de objetos existentes en lugar de comenzar un nuevo proceso de creación de instancias desde cero. Al clonar objetos existentes, puede evitar el trabajo de inicialización repetido y el consumo de recursos, y mejorar la eficiencia de la creación de objetos. Al mismo tiempo, el modo prototipo también hace que la creación de objetos sea más flexible y puede modificarse y personalizarse según sea necesario.

2. Función de prototipo

• clase de prototipo abstracto
• clase de prototipo concreto
• cliente

3. Proceso de trabajo del modo prototipo.

4. Ventajas y desventajas del patrón prototipo

Aplicación práctica

1. Escenarios aplicables del modo prototipo.

• El proceso de inicialización del objeto lleva más tiempo.
• La inicialización de clases consume muchos recursos.
• Crear objetos a través de nuevos es más complicado.
• Es necesario evitar el uso de subclases de clases para la configuración inicial.

2. Pasos de implementación del patrón de prototipo

• Crear una clase de prototipo abstracto
• Crear una clase prototipo concreta
• Crear clase de cliente

3. La diferencia entre el patrón prototipo y el patrón singleton

Variaciones del patrón de prototipo

1. Patrón de prototipo con administrador de prototipos

• Patrón de prototipo con administrador de prototipos:
  El patrón de prototipo con administrador de prototipos es una extensión del patrón de prototipos. Introduce un administrador de prototipos (Prototype Manager) para administrar de forma centralizada los objetos prototipo. El administrador de prototipos actúa como un registro para almacenar y recuperar varios objetos prototipo.

Esta variante del patrón prototipo facilita la creación y gestión de múltiples objetos prototipo de diferentes tipos. El cliente puede obtener el objeto prototipo requerido a través del administrador de prototipos sin llamar explícitamente al método de clonación. El administrador de prototipos puede mantener internamente una colección de objetos prototipo, copiándolos y devolviéndolos según sea necesario.

• Implementación del código del patrón de prototipo con el administrador de prototipos:

import java.util.HashMap;
import java.util.Map;

// 原型接口
interface Prototype {
    
    
    Prototype clone();
}

// 具体原型类 A
class ConcretePrototypeA implements Prototype {
    
    
    private String name;

    public ConcretePrototypeA(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }

    @Override
    public Prototype clone() {
    
    
        return new ConcretePrototypeA(this.name);
    }
}

// 具体原型类 B
class ConcretePrototypeB implements Prototype {
    
    
    private int number;

    public ConcretePrototypeB(int number) {
    
    
        this.number = number;
    }

    public int getNumber() {
    
    
        return number;
    }

    @Override
    public Prototype clone() {
    
    
        return new ConcretePrototypeB(this.number);
    }
}

// 原型管理器
class PrototypeManager {
    
    
    private Map<String, Prototype> prototypes;

    public PrototypeManager() {
    
    
        prototypes = new HashMap<>();
    }

    public void registerPrototype(String key, Prototype prototype) {
    
    
        prototypes.put(key, prototype);
    }

    public Prototype getPrototype(String key) {
    
    
        Prototype prototype = prototypes.get(key);
        if (prototype != null) {
    
    
            return prototype.clone();
        }
        return null;
    }
}

// 客户端
public class Main {
    
    
    public static void main(String[] args) {
    
    
        PrototypeManager manager = new PrototypeManager();
        manager.registerPrototype("A", new ConcretePrototypeA("Prototype A"));
        manager.registerPrototype("B", new ConcretePrototypeB(10));

        Prototype prototypeA = manager.getPrototype("A");
        if (prototypeA != null) {
    
    
            System.out.println("Clone A: " + ((ConcretePrototypeA) prototypeA).getName());
        }

        Prototype prototypeB = manager.getPrototype("B");
        if (prototypeB != null) {
    
    
            System.out.println("Clone B: " + ((ConcretePrototypeB) prototypeB).getNumber());
        }
    }
}

2. Implementación del patrón prototipo del patrón singleton perezoso

• El patrón prototipo del patrón singleton diferido:
  el patrón singleton diferido es una forma común de implementar el patrón singleton, que retrasa la creación de instancias del objeto singleton hasta que se crea por primera vez. La combinación del patrón singleton diferido con el patrón prototipo puede lograr un patrón de carga diferida y reutilización de instancias.

En esta variante del patrón prototipo, el objeto singleton actúa como un objeto prototipo y cuando el cliente solicita una instancia por primera vez, se obtiene una copia del objeto mediante clonación y se devuelve como un objeto singleton. Después de eso, cada solicitud devolverá esta copia existente, evitando procesos repetidos de creación e inicialización.

Este método de implementación combina carga diferida y reutilización de objetos, y puede crear dinámicamente nuevos objetos y almacenarlos en caché cuando sea necesario, mejorando el rendimiento del sistema y la utilización de recursos.

• Implementación del código del patrón prototipo del patrón singleton diferido:

// 单例类
class Singleton {
    
    
    private static Singleton instance;

    // 私有构造函数
    private Singleton() {
    
    
        System.out.println("Singleton instance created.");
    }

    // 获取单例对象
    public static Singleton getInstance() {
    
    
        if (instance == null) {
    
    
            synchronized (Singleton.class) {
    
    
                if (instance == null) {
    
    
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // 克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
    
    
        throw new CloneNotSupportedException("Cannot clone a singleton object.");
    }
}

// 客户端
public class Main {
    
    
    public static void main(String[] args) {
    
    
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println("Singleton 1: " + singleton1);
        System.out.println("Singleton 2: " + singleton2);

        // 尝试克隆单例对象
        try {
    
    
            Singleton clone = (Singleton) singleton1.clone();
            System.out.println("Clone: " + clone);
        } catch (CloneNotSupportedException e) {
    
    
            System.out.println(e.getMessage());
        }
    }
}

3. Modo prototipo detallado

• Patrón de prototipo detallado:
  el patrón de prototipo detallado se refiere a dividir un objeto complejo en varias partes y crear objetos prototipo correspondientes para cada parte. De esta manera, cuando necesite utilizar una determinada parte, solo necesitará clonar el objeto prototipo de esa parte, en lugar de clonar todo el objeto complejo.

Los patrones de creación de prototipos detallados pueden mejorar la flexibilidad y la eficiencia del sistema. Permite al cliente seleccionar las partes requeridas para clonar sin clonar todo el objeto. Al mismo tiempo, cuando una determinada parte cambia, solo es necesario modificar el objeto prototipo correspondiente, sin volver a crear el objeto completo.

Este patrón es adecuado para objetos complejos que se componen de múltiples componentes o módulos. A través de objetos prototipo detallados, los componentes de objetos complejos se pueden construir y modificar de manera más flexible, reduciendo la duplicación y el acoplamiento de código.

• Código de patrón prototipo detallado

// 原型接口
interface Prototype {
    
    
    Prototype clone();
}

// 具体原型类 A
class ConcretePrototypeA implements Prototype {
    
    
    private String name;

    public ConcretePrototypeA(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }

    @Override
    public Prototype clone() {
    
    
        return new ConcretePrototypeA(this.name);
    }
}

// 具体原型类 B
class ConcretePrototypeB implements Prototype {
    
    
    private int number;

    public ConcretePrototypeB(int number) {
    
    
        this.number = number;
    }

    public int getNumber() {
    
    
        return number;
    }

    @Override
    public Prototype clone() {
    
    
        return new ConcretePrototypeB(this.number);
    }
}

// 客户端
public class Main {
    
    
    public static void main(String[] args) {
    
    
        Prototype prototypeA = new ConcretePrototypeA("Prototype A");
        Prototype cloneA = prototypeA.clone();
        if (cloneA instanceof ConcretePrototypeA) {
    
    
            System.out.println("Clone A: " + ((ConcretePrototypeA) cloneA).getName());
        }

        Prototype prototypeB = new ConcretePrototypeB(10);
        Prototype cloneB = prototypeB.clone();
        if (cloneB instanceof ConcretePrototypeB) {
    
    
            System.out.println("Clone B: " + ((ConcretePrototypeB) cloneB).getNumber());
        }
    }
}

Resumir

• Resumen del uso del modo prototipo
• La importancia del patrón prototipo para el desarrollo de software

// 抽象原型类
abstract class Prototype implements Cloneable {
    
    
    public abstract Prototype clone();
}

// 具体原型类
class ConcretePrototype extends Prototype {
    
    
    @Override
    public Prototype clone() {
    
    
        try {
    
    
            return (Prototype) super.clone();
        } catch (CloneNotSupportedException e) {
    
    
            e.printStackTrace();
            return null;
        }
    }
}

// 客户端
public class Client {
    
    
    public static void main(String[] args) {
    
    
        ConcretePrototype prototype = new ConcretePrototype();
        ConcretePrototype clone = (ConcretePrototype) prototype.clone();
        // 进行操作
    }
}

El código anterior muestra una implementación simple del patrón prototipo, en la que la clase prototipo abstracta define un clon de método abstracto, que se implementa en la clase prototipo concreta, y el objeto se clona llamando al método super.clone(). En el cliente, puede crear un objeto prototipo y clonarlo para obtener un nuevo objeto para operar.

El modo prototipo es adecuado para escenarios en los que es necesario crear una gran cantidad de objetos similares y la eficiencia se puede mejorar clonando objetos existentes. Simplifica el proceso de creación de objetos y reduce las operaciones de inicialización repetidas. Al mismo tiempo, el modo prototipo también tiene buena escalabilidad y se puede implementar una lógica de clonación personalizada heredando y anulando el método de clonación.

En general, el patrón prototipo es un patrón de diseño simple y práctico que tiene un amplio valor de aplicación en el desarrollo de software. Al utilizar racionalmente el patrón prototipo, se puede mejorar la reutilización, la mantenibilidad y la flexibilidad del código, mejorando así la eficiencia y la calidad del desarrollo de software.