23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】

系列文章

23种设计模式 —— 设计模式目的以及遵循的七大原则
23种设计模式 —— 单例模式【饿汉式、懒汉式、双重检查、静态内部类、枚举】
23种设计模式 —— 工厂模式【简单工厂、工厂方法、抽象工厂】
23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】

---

3、原型模式

3.1、传统方式克隆羊

现在有一只羊，姓名为Tom，年龄为2岁，颜色为白色，我们用程序创建和Tom属性完全相同的10只羊。

原来的思路：直接new十次

package design_partten.prototype.type1;

public class Sheep {
    private String name;
    private int age;
    private String color;
    //省略构造方法、set、get
}

public class Client {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("Tom", 3, "白色");
        Sheep sheep2 = new Sheep(sheep1.getName(), sheep1.getAge(), sheep1.getColor());
        Sheep sheep3 = new Sheep(sheep1.getName(), sheep1.getAge(), sheep1.getColor());
        Sheep sheep4 = new Sheep(sheep1.getName(), sheep1.getAge(), sheep1.getColor());
        Sheep sheep5 = new Sheep(sheep1.getName(), sheep1.getAge(), sheep1.getColor());
        //...
    }
}

优缺点：

• 比较好理解，简单易操作

• 在创建新对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂，效率很低。

• 总是需要重新初始化对象，无法动态获得对象运行时状态（例如在原始类里增加新属性，就必须去改new类时的代码），不够灵活。

• 改进思路：

  Java中Object类是所有类的根类，它提供了clone()方法，能将一个Java对象复制一份。我们需要实现Cloneable接口，该接口表示这个类能够复制且具有复制能力。这引出了原型模式。

 

3.2、原型模式克隆羊

• 原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新对象。

• 工作原理：将一个原型对象传给那个要进行创建的对象，这个要进行创建的对象请求拷贝它们自己来实施创建，即 对象.clone()

羊类

public class Sheep implements Cloneable {
    private String name;
    private int age;
    private String color;
    private String address="内蒙古";
	//省略构造方法、set、get、toString
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Sheep sheep = null;
        try {
            sheep = (Sheep)super.clone();
        }catch (Exception e){
            e.getStackTrace();
        }
        return sheep;
    }
}

测试

public class Client {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("Tom", 3, "白色");
        Sheep sheep2 = (Sheep)sheep1.clone();
        Sheep sheep3 = (Sheep)sheep1.clone();
        //...
        System.out.println(sheep2);
    }
}

结果：

结论：通过原型模式克隆羊，比传统方式更加灵活，它会直接克隆属性的值。

 

3.3、原型模式在Spring中的源码分析

在依赖注入时，我们可以选择原型模式。

进入debug，看看我们如何获取到bean的。

这里有一个bean工厂，进去看看。

里面还有个doGetBean，这个应该就是最主要的，进入doGetBean后，里面可以看见我们设置的原型模式。

他会判断是否是单例、是否是原型

 

3.4、深拷贝

前面我们的克隆羊的成员变量都是基本类型，如果成员中有一个对象呢？

如果成员变量是一个对象，那么通过前面的方式进行拷贝，不会创建新的成员对象。例如下面这样。

public class Sheep implements Cloneable {
    private String name;
    private int age;
    private String color;
    private String address="内蒙古";
    private Sheep friend;
    //....
}

public class Client {
    public static void main(String[] args) {
        Sheep sheep1 = new Sheep("Tom", 3, "白色");
        sheep1.setFriend(new Sheep("Bob", 2, "黑色"));
        Sheep sheep2 = (Sheep) sheep1.clone();
        Sheep sheep3 = (Sheep) sheep1.clone();
        //...
        System.out.println(sheep1.getFriend().hashCode());
        System.out.println(sheep2.getFriend().hashCode());
        System.out.println(sheep3.getFriend().hashCode());
    }
}

三只羊的朋友都是同一个对象，它们的引用地址相同，这就叫浅拷贝（默认使用clone()就是浅拷贝），在这种情况下修改一个克隆羊的朋友会影响到其他克隆羊。相对的，当我们拷贝时，将其对象类型的成员也拷贝，就叫深拷贝。

深拷贝基本介绍：

• 复制对象的所有基本数据类型的成员变量值
• 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象。也就是说，对象进行深拷贝就会对所有成员变量进行拷贝。
• 深拷贝实现方式：1. 重新clone()方法；2. 通过对象序列化实现。

方式一：重新clone()方法（这里懒得写set、get了，就直接把变量声明为public）

package design_partten.prototype.type1.improve;

class Bird implements Cloneable{
    public String name;

    public Bird(String name) {
        this.name = name;
    }

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

public class Sheep implements Cloneable {
    public String name;
    public int age;
    public String color;
    public Bird friend;

    public Sheep(String name, int age, String color, Bird friend) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.friend = friend;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {

        //1. 先拷贝基本数据类型的成员变量
        Sheep sheep = (Sheep) super.clone();

        //2. 拷贝引用类型的成员变量(即对引用类型成员再进行一次拷贝，然后赋值给刚刚拷贝的克隆羊)
        Bird friend = (Bird) this.friend.clone();
        sheep.friend = friend;

        return sheep;
    }
}

测试：

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep1 = new Sheep("Tom", 3, "白色", new Bird("鸟"));
        Sheep sheep2 = (Sheep) sheep1.clone();
        Sheep sheep3 = (Sheep) sheep1.clone();
        //...
        System.out.println(sheep1.friend.hashCode());
        System.out.println(sheep2.friend.hashCode());
        System.out.println(sheep3.friend.hashCode());
    }
}

结果：

评价：通过重新clone()方法来实现深拷贝，虽然看上去简单，代码较少，但这是因为我们成员变量只有一个是引用类型，如果有很多成员变量都是引用类型，那么我们每个变量都要去写。不推荐。

方式二：通过对象的序列化方式实现（推荐）

//在Sheep类添加该方法，且Sheep和Bird实现Serialized接口
public Object deepClone(){
    //创建字节数组输出流对象
    ByteArrayOutputStream bos = null;
    ObjectOutputStream oos = null;
    ByteArrayInputStream bis = null;
    ObjectInputStream ois = null;

    try {
        //序列化
        bos = new ByteArrayOutputStream();
        oos = new ObjectOutputStream(bos);
        oos.writeObject(this);//当前这个对象以对象流的方式输出

        //反序列化
        bis = new ByteArrayInputStream(bos.toByteArray());
        ois = new ObjectInputStream(bis);
        Sheep sheep = (Sheep)ois.readObject();

        return sheep;
    }catch (Exception e){
        e.getStackTrace();
        return null;
    }finally {
        //关闭流
        try {
            ois.close();
            bis.close();
            oos.close();
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

3.5、小结

• 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能提高效率。
• 无需重新初始化对象，而是动态地获得对象运行时状态，即如果对象在后面属性有所改变，通过克隆得到的会是属性改变后的对象，而不是初始的对象。
• 如果原始对象发生变化（增加或减少属性），其他克隆对象也会发生相应变化，无需修改代码。
• 缺点：需要增加clone方法，这对一个新的类来说没问题，但对于一个以前就创建好的类来说，这违背了OCP原则！