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

系列文章

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

文章目录

  • 系列文章
  • 3、原型模式
    • 3.1、传统方式克隆羊
    • 3.2、原型模式克隆羊
    • 3.3、原型模式在Spring中的源码分析
    • 3.4、深拷贝
    • 3.5、小结


3、原型模式

3.1、传统方式克隆羊

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

原来的思路:直接new十次

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第1张图片

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()

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第2张图片

羊类

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中的源码分析

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

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第3张图片

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

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第4张图片

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

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第5张图片

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

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第6张图片

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

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第7张图片

 

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());
    }
}

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第8张图片

三只羊的朋友都是同一个对象,它们的引用地址相同,这就叫浅拷贝(默认使用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());
    }
}

结果:

23种设计模式 —— 原型模式【克隆羊、浅拷贝、深拷贝】_第9张图片

评价:通过重新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原则!

你可能感兴趣的:(设计模式,设计模式)