设计模式之原型模式

package com.alibaba.design.prototypepattern;
/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/31-15:31
 */
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;
    }
}

package com.alibaba.design.prototypepattern;
/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/31-15:34
 */
public class Circle extends Shape {
    public Circle(){
        type = "Circle";
    }
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

package com.alibaba.design.prototypepattern;
/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/31-15:32
 */
public class Rectangle extends Shape {
    public Rectangle(){
        type = "Rectangle";
    }
    @Override
    void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

package com.alibaba.design.prototypepattern;
/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/31-15:33
 */
public class Square extends Shape {
    public Square() {
        type = "Square";
    }
    @Override
    void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

package com.alibaba.design.prototypepattern;
import java.util.Hashtable;
/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/31-15:35
 */
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();
    }
    // 对每种形状都运行数据库查询，并创建该形状
    // shapeMap.put(shapeKey, shape);
    // 例如，我们要添加三种形状
    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 com.alibaba.design.prototypepattern;
/**
 * @author zhouyanxiang
 * @create 2020-07-2020/7/31-15:37
 */
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());
    }
}

我们看一下Object这个对象,我们直接看一下克隆这个方法
protected native Object clone() throws CloneNotSupportedException;
很明显看出来,他是一个native的方法,接下来我们再看一个,Cloneable这个接口,public interface Cloneable,
只要看看哪些类实现这个接口呢,就知道了这个原型模式,是如何使用的,我们按一下Ctrl+T,这里面有一个定位,
直接点一下,会在下边显示出来,这里面开始搜索,在搜索的时候呢,我们再看一个类,ArrayList,相信这个类大家都是知道的,
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
他实现了Cloneable这个接口,我们看一下它是如何重写的呢,
public Object clone() {
  try {
    ArrayList<?> v = (ArrayList<?>) super.clone();
    v.elementData = Arrays.copyOf(elementData, size);
    v.modCount = 0;
    return v;
  } catch (CloneNotSupportedException e) {
    // this shouldn't happen, since we are Cloneable
    throw new InternalError(e);
  }
}
通过Arrays.copyOf这个方法把这里面的元素,copy了一份,同理HashMap这里面
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
是一样的,他也实现了Cloneable这个接口,同时他也重写了克隆这个方法
@SuppressWarnings("unchecked")
@Override
public Object clone() {
  HashMap<K,V> result;
  try {
    result = (HashMap<K,V>)super.clone();
  } catch (CloneNotSupportedException e) {
    // this shouldn't happen, since we are Cloneable
    throw new InternalError(e);
  }
  result.reinitialize();
  result.putMapEntries(this, false);
  return result;
}
// These methods are also used when serializing HashSets
final float loadFactor() { return loadFactor; }
final int capacity() {
  return (table != null) ? table.length :
    (threshold > 0) ? threshold :
    DEFAULT_INITIAL_CAPACITY;
}
有兴趣的可以来看一下,那在这里想说一下,就是对于原型模式,我们平时在使用的时候,一定要检对象是否和预期是一致的,
也就是说这个对象,是新创建出来的呢,还是只是创建一个引用,指向的是同一个地址,也就是说要把深克隆和浅克隆一定要
应用好,我们看一下下面搜索出来的都是实现了Cloneable这个接口的实现类,这里又很多,这个是JDK的

包括redission,还有redis的client,还有Spring里面的mybatis,这里面都是实现了Cloneable接口,我们看一下Cache,
CacheKey,这个类也实现了Cloneable,
public class CacheKey implements Cloneable
CacheKey是Mybatis里面关于Cache使用的一个类,我们看一下它是如何重写的
  @Override
  public CacheKey clone() throws CloneNotSupportedException {
    CacheKey clonedCacheKey = (CacheKey) super.clone();
    clonedCacheKey.updateList = new ArrayList<Object>(updateList);
    return clonedCacheKey;
  }
这里面可以看到,首先是super.clone(),然后强转一个新的出来,然后把里面的List赋值成一个新的List,并把这个元素放到
新的List里面,进行返回,这样就保证了ArrayList,是一个新创建的ArrayList,但是注意里面的updateList
private List<Object> updateList;
这个又是一个List,有兴趣的,建议可以试一下,克隆出来的里面的,这个元素,是相同的对象还是不同的对象,非常你们能够操作一下,
你可以模拟CacheKey来写一个类,主要是List,然后再进一步的说,如果List里面包装的,不是String,而是Date对象,我们再看一下效果,
希望能够动起手来,那接着看,下面这些是实现Cloneable接口的,包括在开源框架中,会有很多,有兴趣的可以自己挨个看一下,这里面
还是挺有意思的,那原型模式在开源框架中,使用的非常广泛,就拿CacheKey来说,这里面也是非常注重克隆出来的对象,引用问题,
所以我们在实现原型模式的时候,这一点是一定一定要注意的.