java设计模式之原型模式

最新推荐文章于 2023-07-22 21:33:35 发布

尼古拉斯大树

最新推荐文章于 2023-07-22 21:33:35 发布

阅读量858

点赞数

分类专栏： Java设计模式文章标签：原型模式 java 设计模式

本文链接：https://blog.csdn.net/weixin_42109071/article/details/128530179

版权

Java设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、原型模式概述

1.1 什么是原型模式？

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象

1.2 基本介绍

用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
原理：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝他们自己来实施创建，即对象.clone()
理解：孙悟空拔出猴毛，变成其他孙悟空

1.3 使用场景

1.如果你需要复制一些对象，同时又希望代码独立于这些对象所属的具体类，可以使用原型模式。
2.如果子类的区别仅在于其对象的初始化方式，那么你可以使用该模式来减少子类的数量。别人创建这些子类的目的可能是为了创建特定类型的对象。
3.Spring中原型bean的创建，就是原型模式的应用

1.4 原型模式优缺点

原型模式的克隆分为浅克隆和深克隆。
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原
有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

二、原型模式代码实现

原型模式包含如下角色：
抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

原型模式的克隆分为浅克隆和深克隆

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址

在JDK中的Object类中提供了clone（）方法来实现浅克隆。Cloneable接口是抽象原型，而实现了Cloneable接口的子实现类就是具体的原型类。

2.1 创建对象——古老方法


/**
 * 羊 实体类
 */
public class Sheep {

    // 名称
    private String name;
    // 产地
    public SheepAddress sheepAddress;

    public Sheep(){}

    public Sheep(String name, SheepAddress sheepAddress) {
        this.name = name;
        this.sheepAddress = sheepAddress;
    }

    @Override
    public String toString() {
        return "Sheep{name='" + name + ", sheepAddress=" + sheepAddress +"}";
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, sheepAddress);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public SheepAddress getSheepAddress() {
        return sheepAddress;
    }

    public void setSheepAddress(SheepAddress sheepAddress) {
        this.sheepAddress = sheepAddress;
    }
}

/**
 * 羊产地
 */
public class SheepAddress {

    //省
    private String province;
    //市
    private String city;

    public SheepAddress(){}

    public SheepAddress(String province, String city) {
        this.province = province;
        this.city = city;
    }

    @Override
    public String toString() {
        return "SheepAddress{province=" + province + ", city='" + city + "}";
    }

    @Override
    public int hashCode() {
        return Objects.hash(province, city);
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

public class ProtTest {

    public static void main(String[] args) {
        Sheep sheep = new Sheep("多莉", new SheepAddress("内蒙古", "呼和浩特市"));
        System.out.println("sheep对象的hashcode:" + sheep.hashCode() + " sheepAddress对象的hashcode:" + sheep.sheepAddress.hashCode() + " 属性值：" + sheep);

        Sheep sheep1 = new Sheep("多莉1", new SheepAddress("内蒙古1", "呼和浩特市1"));
        System.out.println("sheep对象的hashcode:" + sheep1.hashCode() + " sheepAddress对象的hashcode:" + sheep1.sheepAddress.hashCode() + " 属性值：" + sheep1);

        Sheep sheep2 = new Sheep("多莉2", new SheepAddress("内蒙古2", "呼和浩特市2"));
        System.out.println("sheep对象的hashcode:" + sheep2.hashCode() + " sheepAddress对象的hashcode:" + sheep2.sheepAddress.hashCode() + " 属性值：" + sheep2);

    }

}

输出结果：

sheep对象的hashcode:-150317243 sheepAddress对象的hashcode:-173282477 属性值：Sheep{name='多莉, sheepAddress=SheepAddress{province=内蒙古, city='呼和浩特市}}
sheep对象的hashcode:-364921810 sheepAddress对象的hashcode:-1076816753 属性值：Sheep{name='多莉1, sheepAddress=SheepAddress{province=内蒙古1, city='呼和浩特市1}}
sheep对象的hashcode:-364921747 sheepAddress对象的hashcode:-1076816721 属性值：Sheep{name='多莉2, sheepAddress=SheepAddress{province=内蒙古2, city='呼和浩特市2}}

使用古老办法，使用new一个一个赋值，很明显有些缺点，每次都需要调用对象去获取属性

2.2 创建对象——浅拷贝

/**
 * 原型设计模式：浅拷贝，创建一只多莉羊并实现其Cloneable接口
 **/
public class SheepClone06 implements Cloneable{

    // 名称
    private String name;
    // 产地
    public SheepAddress06 sheepAddress;

    public SheepClone06(){}

    public SheepClone06(String name, SheepAddress06 sheepAddress) {
        this.name = name;
        this.sheepAddress = sheepAddress;
    }

    public void printSheep() {
        System.out.println(name + ":" + "是一只克隆羊！");
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, sheepAddress);
    }

    @Override
    public String toString() {
        return "SheepClone06{name='" + name + ", sheepAddress=" + sheepAddress + "}";
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public SheepAddress06 getSheepAddress() {
        return sheepAddress;
    }

    public void setSheepAddress(SheepAddress06 sheepAddress) {
        this.sheepAddress = sheepAddress;
    }
}

/**
 * 羊的产区
 */
public class SheepAddress06 {

    //省
    private String province;
    //市
    private String city;

    public SheepAddress06(){}

    public SheepAddress06(String province, String city) {
        this.province = province;
        this.city = city;
    }

    @Override
    public String toString() {
        return "SheepAddress06{province='" + province + "', city='" + city + "}";
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

/**
 * 原型设计模式是一种创建型设计模式，允许一个对象再创建另一个可定制的对象，无需知道如何创建对象的细节，
 * springmvc框架中的单例（singleton）与多例（prototype）正是基于该设计模式而设计的。
 * 原型设计模式分为俩种，一种是浅拷贝，另一种是深拷贝。浅拷贝指的是对于基本数据类型和引用类型的变量通过值传递和引用传递，
 * 通俗易懂的说法就是，原对象的任何更改都会影响到克隆对象。而深拷贝是通过完整的克隆，重新创建一个新的对象，
 * 原对象的更改不会影响到克隆对象。浅拷贝通过实现Cloneable接口，重写clone方法实现。
 * 深拷贝可以通过重写clone方法或者实现Serializable序列化接口，通过序列化实现对象深拷贝。
 * 多用于复杂对象的创建，简化对象创建过程。本节我们以克隆多莉羊为例，实现原型模式的一个案例。
 *
 * 原型设计模式：浅拷贝，创建一只多莉羊并实现其Cloneable接口
 */
public class ProtTest06 {

    public static void main(String[] args) throws CloneNotSupportedException {
        SheepClone06 sheep = new SheepClone06("多莉", new SheepAddress06("内蒙古", "呼和浩特市"));
        sheep.printSheep();
        System.out.println("sheep对象-->hashcode值:" + sheep.hashCode() + " sheepAddress对象的hashcode值:" + sheep.sheepAddress.hashCode() + " 属性值：" + sheep);
        //调用克隆方法克隆一只多莉羊
        System.out.println();
        System.out.println("开始浅拷贝SheepClone对象...");
        SheepClone06 cloneSheep = (SheepClone06) sheep.clone();
        cloneSheep.printSheep();
        //更改多莉羊的产地
        sheep.getSheepAddress().setProvince("新疆");
        sheep.getSheepAddress().setCity("乌鲁木齐");
        //克隆的多莉羊属性
        System.out.println("克隆sheep对象-->hashcode值:" + cloneSheep.hashCode() + " sheepAddress对象的hashcode值:" + cloneSheep.sheepAddress.hashCode() + " 属性值: " + cloneSheep);

        System.out.println();
        System.out.println("两个对象值分别为 sheep=" + sheep +" cloneSheep="+cloneSheep);
    }

}

输出结果：

从上面的案例可以看出，修改复制的新对象属性内容，会影响之前的对象属性值，我们可以得出结论，浅拷贝即引用传递，值复制

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

2) 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值

3) 前面我们克隆羊就是浅拷贝

4) 浅拷贝是使用默认的 clone()方法来实现 sheep = (Sheep) super.clone();

2.3 创建对象——深拷贝


public class SheepClone07 implements Cloneable, Serializable {

    // 名称
    private String name;
    // 产地
    public SheepAddress07 sheepAddress;

    public SheepClone07(){}

    public SheepClone07(String name, SheepAddress07 sheepAddress) {
        this.name = name;
        this.sheepAddress = sheepAddress;
    }

    public void printSheep() {
        System.out.println(name + ":" + "是一只克隆羊！");
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, sheepAddress);
    }

    @Override
    public String toString() {
        return "SheepClone07{name='" + name + ", sheepAddress=" + sheepAddress + "}";
    }

    /**
     * 方式一： 通过重写clone方法实现深拷贝
     **/
    protected Object clone() throws CloneNotSupportedException {
        //完成对属性为基本数据类型和String的克隆
        Object deep = super.clone();
        SheepClone07 sheepClone = (SheepClone07) deep;
        sheepClone.sheepAddress = (SheepAddress07) sheepAddress.clone();
        return sheepClone;
    }


    /**
     * 方式二： 通过序列化反序列化实现深拷贝(推荐使用)
     **/
    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);
            SheepClone07 sheepClone = (SheepClone07) ois.readObject();
            return sheepClone;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e2) {
                System.out.println(e2.getMessage());
            }
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public SheepAddress07 getSheepAddress() {
        return sheepAddress;
    }

    public void setSheepAddress(SheepAddress07 sheepAddress) {
        this.sheepAddress = sheepAddress;
    }
}

public class SheepAddress07 implements Cloneable, Serializable {

    //省
    private String province;
    //市
    private String city;

    public SheepAddress07(){}

    public SheepAddress07(String province, String city) {
        this.province = province;
        this.city = city;
    }

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


    @Override
    public String toString() {
        return "SheepAddress07{province='" + province + "', city='" + city + "}";
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

public class ProtTest07 {

    public static void main(String[] args) throws CloneNotSupportedException {
        SheepClone07 sheep = new SheepClone07("多莉", new SheepAddress07("内蒙古", "呼和浩特市"));
        sheep.printSheep();
        System.out.println("sheep对象-->hashcode值:" + sheep.hashCode() + " sheepAddress对象的hashcode值:" + sheep.sheepAddress.hashCode() + " 属性值：" + sheep);

        System.out.println();
        System.out.println("开始深拷贝方式一SheepClone对象(通过重写clone方法实现深拷贝)...");
        SheepClone07 cloneSheepOne = (SheepClone07) sheep.clone();
        cloneSheepOne.setName("绵羊");
        cloneSheepOne.printSheep();
        System.out.println("克隆sheep对象-->hashcode值:" + cloneSheepOne.hashCode() + " sheepAddress对象的hashcode值:" + cloneSheepOne.sheepAddress.hashCode() + " 属性值: " + cloneSheepOne);

        System.out.println();
        System.out.println("开始深拷贝方式二序列化SheepClone对象(通过序列化反序列化实现深拷贝)...");
        SheepClone07 cloneSheepTwo = (SheepClone07) sheep.deepClone();
        cloneSheepTwo.printSheep();
        System.out.println("克隆sheep对象-->hashcode值:" + cloneSheepTwo.hashCode() + " sheepAddress对象的hashcode值:" + cloneSheepTwo.sheepAddress.hashCode() + " 属性值: " + cloneSheepTwo);

        System.out.println();
        System.out.println("两个对象值分别为 sheep=" + sheep +" cloneSheepOne="+cloneSheepOne+" cloneSheepTwo="+cloneSheepTwo);

    }
}

输出结果：

深拷贝基本介绍
1) 复制对象的所有基本数据类型的成员变量值

2) 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝

3) 深拷贝实现方式

重写clone方法来实现深拷贝
通过对象序列化实现深拷贝(推荐)