Notas de estudio del modo de diseño --- 5. Modo de prototipo

• El patrón de prototipo (patrón de prototipo) se utiliza para crear objetos repetidos, mientras se garantiza el rendimiento. Este tipo de patrón de diseño es un patrón de creación, que proporciona una forma óptima de crear objetos;

• Este modelo implementa una interfaz prototipo que se usa para crear un clon del objeto actual; este modelo se usa cuando el costo de crear directamente un objeto es relativamente alto. Por ejemplo, un objeto debe crearse después de una operación costosa de almacenamiento de datos. Podemos almacenar ese juego en caché; en la próxima solicitud, devuelva su clon y actualice la base de datos cuando sea necesario para reducir las llamadas a la base de datos

• Intención: utilizar instancias de prototipos para especificar los tipos de objetos creados y crear nuevos objetos copiando estos prototipos;

• Solución principal: construir y eliminar prototipos en funcionamiento;

• Cuando usar:

• • 1. Cuando un sistema debe ser creado, compuesto y representado independientemente de sus productos;

  • 2. Cuando la clase que se instanciará se especifica en tiempo de ejecución, por ejemplo, mediante carga dinámica;

  • 3. Para evitar crear un nivel de clase de fábrica paralelo al nivel de clase de producto;

  • 4. Cuando una instancia de una clase solo puede tener una de varias combinaciones diferentes de estados. Puede ser más conveniente construir un número correspondiente de prototipos y clonarlos que instanciar la clase manualmente en el estado apropiado cada vez;

• Cómo resolverlo: utilice un objeto prototipo existente para generar rápidamente la misma instancia que el objeto prototipo;

• Código clave:

• • 1. Para lograr la clonación, herede Cloneable en Java y anule clone (). En .net, puede usar el método ObjectwiseClone () de la clase Object para lograr una copia superficial de objetos o una copia profunda a través de la serialización;

  • 2. El modo prototipo también se utiliza para aislar la relación de acoplamiento entre los usuarios de objetos de clase y clases concretas (clases variables). También requiere que estas "clases variables" tengan interfaces estables;

• Ejemplos de aplicación:

• • 1. división celular;

  • 2. Método Object Clone () en Java;

• Ventajas:

• • 1. Mejora del rendimiento;

  • 2. Escapar de las restricciones de la función del mecanismo;

• Desventajas

• • 1. Equipado con métodos de clonación, es necesario considerar las funciones de clase en general. Esto no es difícil para las clases nuevas, pero no es fácil para las clases existentes, especialmente cuando una referencia no admite objetos indirectos serializados, o la referencia contiene ciclos Tiempo estructural

  • 2. Debe implementar la interfaz clonable;

• Escenario de uso:

• • 1. Escenarios de optimización de recursos;

  • 2. La inicialización de la clase necesita digerir muchos recursos, este recurso incluye datos, recursos de hardware, etc.

  • 3. Escenarios para los requisitos de desempeño y seguridad;

  • 4. Crear un objeto a través de nuevo requiere una preparación de datos muy engorrosa o derechos de acceso, puede usar el modo prototipo;

  • 5. Una escena donde se realizan múltiples cambios a un objeto;

  • 6. Un objeto Xu Tao proporciona acceso a otros juegos, y cuando la persona que llama puede necesitar modificar su valor, puede considerar usar el modo prototipo para copiar múltiples objetos para que la persona que llama los use;

  • 7. En proyectos reales, el patrón prototipo rara vez aparece solo, y generalmente aparece junto con el patrón de fábrica. El método de clonación crea un objeto, y luego el método de fábrica se proporciona a la persona que llama;

  • Nota: a diferencia de construir un nuevo objeto creando instancias de una clase, el modo prototipo genera un nuevo objeto copiando un objeto existente. La copia superficial implementa Cloneable, rewrite, y la copia profunda implementa Serializable para leer el flujo binario. ;

• Combate real:

• • Crearemos una Forma abstracta y una clase de entidad que amplíe la clase Forma; el siguiente paso es definir la clase ShapeCache, que almacena los objetos de forma en una tabla hash y devuelve sus clones cuando se solicita;

  • PrototypePatternDemo, la clase que demostramos utiliza la clase ShapeCache para obtener objetos Shape;

 

package prototype;

/**
 * @author yangxin_ryan
 */
public abstract class Shape implements Cloneable {
    private String id;
    protected String type;
    abstract void draw();

    public String getType() {
        return type;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException{
        Object clone = null;
        clone = super.clone();
        return super.clone();
    }
}

package prototype;

/**
 * @author yangxin_ryan
 */
public class Rectangle extends Shape {

    public Rectangle() {
        type = "Rectangle";
    }

    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

package prototype;

/**
 * @author yangxin_ryan
 */
public class Square extends Shape {

    public Square() {
        type = "Square";
    }

    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

package prototype;

/**
 * @author yangxin_ryan
 */
public class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }

    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

package prototype;

import java.util.Hashtable;

/**
 * @author yangxin_ryan
 */
public class ShapeCache {

    private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();

    public static Shape getShape(String shapeId) throws Exception {
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape)cachedShape.clone();
    }

    public static void loadCache() {
        Circle circle = new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(), circle);

        Square square = new Square();
        square.setId("2");
        shapeMap.put(square.getId(), square);

        Rectangle rectangle = new Rectangle();
        rectangle.setId("3");
        shapeMap.put(rectangle.getId(), rectangle);
    }
}

package prototype;

/**
 * @author yangxin_ryan
 */
public class PrototypePatternDemo {

    public static void main(String[] args) throws Exception{
        ShapeCache.loadCache();
        Shape clonedShape = (Shape)ShapeCache.getShape("1");
        System.out.println("Shape : " + clonedShape.getType());
        Shape clonedShape2 = (Shape)ShapeCache.getShape("2");
        System.out.println("Shape : " + clonedShape2.getType());
        Shape clonedShape3 = (Shape)ShapeCache.getShape("3");
        System.out.println("Shape : " + clonedShape3.getType());
    }
}