一、原型模式的基本介绍

在聊原型模式之前，我们来思考一个小问题，传统的方式我们是如何克隆对象呢？

那我们以多利羊(Sheep)为例，来说明上述这个问题，具体代码见下面：

多利羊（Sheep）

public class Sheep  {
    private String sname;
    private Date birthday;

    public Sheep(String sname, Date birthday) {
        this.sname = sname;
        this.birthday = birthday;
    }
    
    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

测试类（Client）

public class Client {

    public static void main(String[] args) {

        Sheep sheep=new Sheep("多利",new Date());
        Sheep sheep2=new Sheep(sheep.getSname(),sheep.getBirthday());
        System.out.println("sheep:"+sheep.getSname()+sheep.getBirthday());
        System.out.println("sheep2:"+sheep2.getSname()+sheep2.getBirthday());
    }
}

那我们来分析一下：

1、在创建新对象时，总是需要获取原始对象的属性，如果我们在实际项目中创建的对象复杂的话，效率是很低的。

2、总是需要重新初始化对象，而不是动态地获取对象运行时的状态，不够灵活。

有什么方法可以改进吗？，原型模式闪亮登场

大家都知道在Java中有一个Object类，这个类提供了一个clone()方法，该方法可以将Java对象复制一份，前提是该类实现一个Cloneable接口,这就是原型模式的源头。

什么是原型模式：

用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。

看了这个定义可能有的小伙伴们比较蒙，那我们来撸一把代码来说明（多利羊克隆）：

多利羊（Sheep）实现Cloneable

public class Sheep implements Cloneable {
    private String sname;
    private Date birthday;

    private Sheep mother;

    public Sheep getMother() {
        return mother;
    }

    public void setMother(Sheep mother) {
        this.mother = mother;
    }

    public Sheep(String sname, Date birthday) {
        this.sname = sname;
        this.birthday = birthday;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "sname='" + sname + '\'' +
                ", birthday=" + birthday +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Sheep sheep=null;
        try {
           sheep=(Sheep) super.clone();
        }catch (Exception e){
            e.printStackTrace();
        }
        return sheep;
    }
}

克隆方法的测试（Client）

public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {

        Sheep sheep=new Sheep("多利",new Date());
        Sheep mother=new Sheep("多利的妈妈",new Date());
        sheep.setMother(mother);
        Sheep sheep1=(Sheep) sheep.clone();
        System.out.println("sheep:"+sheep);
        System.out.println("sheep1:"+sheep1);
        System.out.println("sheep:"+sheep.getMother().hashCode());
        System.out.println("sheep1:"+sheep1.getMother().hashCode());
    }
}

运行结果：hashcode 的值一样

sheep:Sheep{sname=’多利’, birthday=Sun May 17 11:56:58 CST 2020}
sheep1:Sheep{sname=’多利’, birthday=Sun May 17 11:56:58 CST 2020}
sheephashcode:2061475679
sheep1hashcode:2061475679

二、原型模式实现浅克隆和深克隆

浅克隆的介绍：

对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。

对于数据类型是引用数据类型的成员变量（数组，对象），浅拷贝会进行引用传递，也就是将成员变量的引用值（内存地址）复制一份给新的对象，因为实际上两个对象的该成员变量都指向同一个实例（前面克隆羊就是浅拷贝，使用clone()方法实现）。

再次说明：其实就是克隆多利羊之后，克隆的对象没有被真正的复制一份，而是引用指向第一个对象的属性空间。

画图说明：

具体代码如下见上面（多利羊克隆）

深克隆的介绍：

1、对对象进行深拷贝要对整个对象（包括对象的引用类型）进行拷贝。

深克隆实现的方式：

1、重写clone()方法实现深克隆

2、通过对象序列化实现深克隆

第一种方式：重写clone()方法实现深克隆，参考下面代码实现：

public class Sheep implements Cloneable {
    private String sname;
    private Date birthday;
    public Mother mother;

    public Sheep() {
    }

    public Sheep(String sname, Date birthday,Mother mother ) {
        this.sname = sname;
        this.birthday = birthday;
        this.mother=mother;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "sname='" + sname + '\'' +
                ", birthday=" + birthday +
                ", mother=" + mother +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Sheep sheep=null;
        try {
            Object obj= super.clone();
            sheep=(Sheep) obj;
            sheep.mother=(Mother) mother.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sheep;
    }
}

多利的妈咪

public class Mother implements Cloneable {
    private int age;
    private String name;

    public Mother(int age, String name) {
        this.age = age;
        this.name = name;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

客户端测试：

public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {

        Sheep sheep=new Sheep("多利",new Date(),new Mother(12,"多利的妈妈"));
        Sheep sheep1=(Sheep) sheep.clone();

        System.out.println("sheep:"+sheep);
        System.out.println("sheep1:"+sheep1);
        System.out.println("sheephashcode:"+sheep.mother.hashCode());
        System.out.println("sheep1hashcode:"+sheep1.mother.hashCode());
    }
}

运行结果：hashcode 的值不一样

sheep:Sheep{sname=’多利’, birthday=Sun May 17 13:20:51 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@7adf9f5f}
sheep1:Sheep{sname=’多利’, birthday=Sun May 17 13:20:51 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@85ede7b}
sheephashcode:2061475679
sheep1hashcode:140435067

第二种方式：序列化和反序列化

需要在Sheep ,Mother 类实现一个序列化 Serializable，具体代码和上面第一种方式的代码一样，就是这Sheep代码中增加以下这段核心代码：

  // 通过对象的序列化实现
    public Object deepClone() throws Exception {
        ByteArrayOutputStream  bos=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(this);
        ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        Sheep sheep=(Sheep) ois.readObject();
        return sheep;
    }

运行结果：

sheep:Sheep{sname=’多利’, birthday=Sun May 17 13:51:23 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@72ea2f77}
sheep1:Sheep{sname=’多利’, birthday=Sun May 17 13:51:23 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@17f052a3}
sheephashcode:1927950199
sheep1hashcode:401625763

三、原型模式的应用场景

Spring 中bean 的scope 属性的声明：

<bean id="student" class="com.Student" scope="prototype"/>

public class ProtoType {

 public static void main(String[] args) {
 	// TODO Auto-generated method stub
 	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
 	// 获取monster[通过id获取monster]
 	Object bean = applicationContext.getBean("student");
 	System.out.println("bean:" + bean);
 	Object bean2 = applicationContext.getBean("student");
 	System.out.println("bean1" + bean2);
 	System.out.println(bean == bean2);
 	

 }

}

运行结果

bean:com.atguigu.spring.bean.Student@52bf72b5
bean1com.atguigu.spring.bean.Student@37afeb11
false

四、小结

优点：

1、创建新的对象比较复杂时，可以利用原型模式创建新的对象，不用重新初始化对象，而是动态地获得对象运行时的状态。

2、如果原始对象发生变化，其克隆的对象也会发生响应的变化，不需要修改代码来实现

缺点：

需要为每一个类配置一个克隆方法，需要器修改源代码，不符合OCP原则。

技术之路还很长，慢慢来吧，时间会证明一切。