Modelli di design - Modello prototipo

Il modello prototipo si riferisce alla creazione di oggetti duplicati tenendo presente le prestazioni. Questo tipo di modello di progettazione rientra nel modello di creazione poiché questo modello fornisce uno dei modi migliori per creare un oggetto.

Questo modello implica l'implementazione di un'interfaccia prototipo che dice di creare un clone dell'oggetto corrente. Questo modello viene utilizzato quando la creazione di un oggetto direttamente è costosa. Ad esempio, un oggetto deve essere creato dopo una costosa operazione di database. Possiamo memorizzare l'oggetto nella cache, restituirne il clone alla richiesta successiva e aggiornare il database come e quando necessario riducendo così le chiamate al database.

Implementazione

Creeremo una classe astratta Shape e classi concrete che estendono la classe Shape . Una classe ShapeCache è definita come un passaggio successivo che memorizza gli oggetti forma in un Hashtable e restituisce il loro clone quando richiesto.

PrototypPatternDemo , la nostra classe demo utilizzerà la classe ShapeCache per ottenere un oggetto Shape .

Passo 1

Crea una classe astratta che implementa l' interfaccia Clonable .

Shape.java

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;
   }
   
   public Object clone() {
      Object clone = null;
      
      try {
         clone = super.clone();
         
      } catch (CloneNotSupportedException e) {
         e.printStackTrace();
      }
      
      return clone;
   }
}

Passo 2

Crea classi concrete che estendono la classe precedente.

Rectangle.java

public class Rectangle extends Shape {

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

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

Square.java

public class Square extends Shape {

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

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

Circle.java

public class Circle extends Shape {

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

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

Passaggio 3

Crea una classe per ottenere classi concrete dal database e memorizzarle in un Hashtable .

ShapeCache.java

import java.util.Hashtable;

public class ShapeCache {
	
   private static Hashtable<String, Shape> shapeMap  = new Hashtable<String, Shape>();

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

   // for each shape run database query and create shape
   // shapeMap.put(shapeKey, shape);
   // for example, we are adding three shapes
   
   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);
   }
}

Passaggio 4

PrototypePatternDemo usa la classe ShapeCache per ottenere cloni di forme archiviate in un Hashtable .

PrototypePatternDemo.java

public class PrototypePatternDemo {
   public static void main(String[] args) {
      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());		
   }
}

Passaggio 5

Verifica l'output.

Shape : Circle
Shape : Square
Shape : Rectangle