【设计模式】原型模式

介绍

原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象,这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

代码演示

简单工厂将getter,setter封装到某个方法中,JDK提供的实现Cloneable 接口,实现快速复制。

浅克隆

案例:孙悟空有72变,拔一根毫毛就是一只猴子猴孙。

只是利用getter,setter的场景

定义Monkey类,只有名字的属性

@Getter
@Setter
public class Monkey {
    public String name;
}

定义金箍棒的类,金箍棒有高度和重量两个属性

@Getter
@Setter
@AllArgsConstructor
public class JinGuBang {
    //高度
    private int height;
    // 重量
    private int weight;
}

定义孙悟空的类,孙悟空的武器就是金箍棒。

@Getter
@Setter
public class SunWuKong extends Monkey {
    private JinGuBang jinGuBang;

}

孙悟空拔一根毫毛,生出跟自己长得一模一样的猴子猴孙

public class Client {

    public static void main(String[] args) {
        SunWuKong sunwukong = new SunWuKong();
        sunwukong.setName("齐天大圣");
        sunwukong.setJinGuBang(new JinGuBang(1000, 30000));
        // 造一个跟孙悟空一模一样的猴子猴孙
        SunWuKong copy = new SunWuKong();
        copy.setName(sunwukong.getName());
        copy.setJinGuBang(sunwukong.getJinGuBang());

    }
}

我造一只猴子猴孙,我直接通过set,get就可以完成,但是如果我想要造几千只几万只呢?
不着急,请看下面的分解

使用Cloneable的代码

Monkey类,JinGuBang 类与不使用设计模式代码一致。所以下面代码就不贴这两个类了。
孙悟空类

@Getter
@Setter
public class SunWuKong extends Monkey implements Cloneable {
    private JinGuBang jinGuBang;

    @Override
    public Object clone() {
        SunWuKong sunWuKong = new SunWuKong();
        sunWuKong.setName(this.getName());
        sunWuKong.setJinGuBang(this.getJinGuBang());
        return sunWuKong;
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        SunWuKong sunWuKong=new SunWuKong();
        JinGuBang jinGuBang=new JinGuBang(100,3000);
        sunWuKong.setJinGuBang(jinGuBang);
        sunWuKong.setName("齐天大圣");
        SunWuKong copy=(SunWuKong) sunWuKong.clone();

        System.out.println("孙悟空和拷贝的孙悟空指向同一个引用地址嘛? "+(sunWuKong==copy));
        System.out.println("孙悟空和拷贝的孙悟空有同一根金箍棒嘛?"+(sunWuKong.getJinGuBang()==copy.getJinGuBang()));
        System.out.println("孙悟空的名字和拷贝的孙悟空名字是同一个嘛?" +(sunWuKong.getName()==sunWuKong.getName()));
    }
}

打印结果

孙悟空和拷贝的孙悟空指向同一个引用地址嘛? false
孙悟空和拷贝的孙悟空有同一根金箍棒嘛?true
孙悟空的名字和拷贝的孙悟空名字是同一个嘛?true

根据打印结果,可以知道,孙悟空和拷贝,两个对象并不是同一个对象,但是他们拥有同一根金箍棒。但是呢,金箍棒只有一根,两个人争着用肯定是会有问题的。

我们再写一个类来验证下,拷贝的金箍棒变了,孙悟空的金箍棒是不是也会变

public class ShadowPrototypeTest {
    public static void main(String[] args) {
        SunWuKong sunWuKong = new SunWuKong();
        sunWuKong.setJinGuBang( new JinGuBang(100, 3000));
        sunWuKong.setName("齐天大圣");

        SunWuKong copy = (SunWuKong) sunWuKong.clone();
        copy.getJinGuBang().setHeight(1);

        System.out.println(JSON.toJSONString(sunWuKong.getJinGuBang()));
    }
}

打印结果

{"height":1,"weight":3000}

##### 浅克隆类图

shadowClone.png

通过验证,说明,拷贝的孙悟空 金箍棒变大变小了,也会影响到本体的孙悟空。这个时候肯定是会有问题了,先不说金箍棒就只有龙宫有那么一根绝版,就说我们的齐天大圣跟妖怪作战的时候,突然金箍棒受到了其他人的控制,变大变小了,那孙悟空岂不是都要抓狂了。
于是这个时候深克隆来了,深克隆解决了什么问题呢,没错,就是copy的对象,可以跟本体一样拥有一根"金箍棒",但是他的金箍棒跟本体孙悟空的真的金箍棒可不是同一根。金箍棒全世界就那么一根呐。copy的"金箍棒"可以是一根棍子,可以是其他的。

深克隆

对浅克隆中对金箍棒类进行修改,使用序列化

@Getter
@Setter
@AllArgsConstructor
public class JinGuBang implements  Serializable {
    private static final long serialVersionUID = 1L;

    //高度
    private int height;
    // 重量
    private int weight;

}

对浅克隆中的孙悟空类进行修改,使用序列化,将对象写入到流中

@Getter
@Setter
public class SunWuKong extends Monkey implements Cloneable,Serializable {
    private static final long serialVersionUID = 1L;

    private JinGuBang jinGuBang;

    @Override
    public Object clone() {
        return this.deepClone();
    }

    // 克隆会破坏单例
    private Object deepClone() {
        SunWuKong copy = null;
        ObjectOutputStream out=null;
        ObjectInputStream in=null;

        try {
            //内存中完成操作,对象读写,是通过字节码直接操作
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
             out = new ObjectOutputStream(byteOut);
            out.writeObject(this);
            ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
             in = new ObjectInputStream(byteIn);

            // 完整的新的对象,new 一个对象
            copy = (SunWuKong) in.readObject();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            if (out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return copy;
    }

}

深克隆测试类

public class DeepPrototypeTest {
    public static void main(String[] args) {
        SunWuKong sunWuKong = new SunWuKong();
        sunWuKong.setJinGuBang(new JinGuBang(100, 3000));
        sunWuKong.setName("齐天大圣");

        SunWuKong copy = (SunWuKong) sunWuKong.clone();

        System.out.println("本体的金箍棒引用地址:" + sunWuKong.getJinGuBang());
        if (copy != null) {
            System.out.println("copy的金箍棒引用地址:" + copy.getJinGuBang());
        }

    }
}

打印结果展示

本体的金箍棒引用地址:com.example.teach.designpatterns.prototype.simple.simple1.JinGuBang@5b480cf9
copy的金箍棒引用地址:com.example.teach.designpatterns.prototype.simple.simple1.JinGuBang@4b9af9a9

通过打印结果我们可以看到,本体和拷贝对金箍棒并不是同一根。

深克隆类图

deepClone.png

个人的理解是Java中定义的clone()没有深浅克隆之分,都是统一的调用Object的clone方法。

通过深克隆和浅克隆两个模型,可以知道
浅克隆不会克隆原对象中的引用类型,仅仅拷贝了引用类型的指向。
深克隆则拷贝了所有。拷贝的这个对象完全是不一样的对象。深克隆能够做到原对象和新对象之间完全没有影响。

使用场景

1、资源优化场景。
2、类初始化需要消化非常多的资源,这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问,而且各个调用者可能都需要修改其值时,可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中,原型模式很少单独出现,一般是和工厂方法模式一起出现,通过 clone 的方法创建一个对象,然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体,大家可以随手拿来使用。
8、循环体中生产大量对象时。

优缺点
优点:
1、性能提高。
2、逃避构造函数的约束。

缺点:
1、配备克隆方法需要对类的功能进行通盘考虑,这对于全新的类不是很难,但对于已有的类不一定很容易,特别当一个类引用不支持串行化的间接对象,或者引用含有循环结构的时候。
2、必须实现 Cloneable 接口。

应用实例

应用实例:
1:JAVA 中的 Object clone() 方法
2:BeanUtils.copy()
3:JSON.parseObject()
4:Guava
5:spring中的配置scope="prototype";
6: ArrayList扩容的时候,调用的grow()方法,里面有一个逻辑是调用到

        elementData = Arrays.copyOf(elementData, newCapacity);

ArrayList 克隆的时候,是对它内部元素一个一个的迭代,再进行赋值

 public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

主要的逻辑在System.arraycopy();

System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
阅读 116

推荐阅读
目录