设计模式之原型模式

介绍：

原型模式（原始模式）是指：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的办法创建更过的同类型对象，即对象.clone()。

传统方式：

我们都知道克隆羊多莉的故事。本模式中使用多莉来做讲解。

每一只羊都有一下几个共同属性：姓名（name）、年龄（age）、颜色（color）:

package com.charon.prototype;

/**
 * @className: Sheep
 * @description:
 * @author: charon
 * @create: 2022-03-09 23:10
 */
public class Sheep {

    private String name;

    private int age;

    private String color;

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

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

传统的创建对象的模式：

package com.charon.prototype;

/**
 * @className: Test
 * @description: 传统创建对象
 * @author: charon
 * @create: 2022-03-09 23:11
 */
public class Test {

    public static void main(String[] args) {
        Sheep sheep = new Sheep("多莉", 1, "white");

        Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        System.out.println(sheep);
        System.out.println(sheep1);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);
        System.out.println(sheep5);
    }
}

对于传统的创建对象的方式的优缺点如下：

优点是比较好理解，简单易操作
缺点是在创建对象的时候，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率比较低下。
并且每一次都需要重新初始化对象，而不是动态地获得对象运行时地状态，不够灵活。

原型模式：

既然上面的方式有缺点，下面我们来看看使用原型模式如何改进。

原型模式有两种表现形式：第一种是简单形式，第二种是登记形式。

1.简单原型模式：

在java语言中，所有的javaBean都继承自java.lang.Object类，而Object类中提供了一个clone()的方法，可以将一个javaBean对象复制一份。但是这个javaBean必须实现一个标识接口Cloneable，表明这个javaBean是可以复制的。

简单原型模式的UML类图：

简单原型模式涉及的客户角色、抽象原型角色、具体原型角色三个角色：

客户角色：客户类提出创建对象的请求
抽象原型角色：这是一个抽象角色，通常由一个java接口或java抽象类实现，此角色给出所有的具体原型类所需的接口
具体原型：被复制的对象，此角色需要实现抽象的原型角色所要求的接口

抽象原型角色：

package com.charon.prototype.improve;

/**
 * @className: Sheep
 * @description: 简单原型模式-抽象原型角色
 * @author: charon
 * @create: 2022-03-11 22:06
 */
public interface Sheep extends Cloneable{
    Sheep clone();
}

具体角色：

package com.charon.prototype.improve;

/**
 * @className: CloneSheep
 * @description: 克隆羊
 * @author: charon
 * @create: 2022-03-11 22:12
 */
public class CloneSheep implements Sheep{
    private String name;

    private int age;

    private String color;

    public CloneSheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

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

    /**
     * 实现克隆方法
     * @return
     */
    @Override
    public Sheep clone() {
        try {
            return (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

客户端调用：

package com.charon.prototype.improve;


/**
 * @className: Client
 * @description:
 * @author: charon
 * @create: 2022-03-11 22:15
 */
public class Client {

    public static void main(String[] args) {
        CloneSheep sheep = new CloneSheep("多莉", 1, "white");
        Sheep sheep1 = sheep.clone();
        Sheep sheep2 = sheep.clone();
        Sheep sheep3 = sheep.clone();
        Sheep sheep4 = sheep.clone();
        Sheep sheep5 = sheep.clone();
        System.out.println(sheep);
        System.out.println(sheep1);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);
        System.out.println(sheep5);
    }
}

打印结果：
    Sheep{name='多莉', age='1', color='white'}
    Sheep{name='多莉', age='1', color='white'}
    Sheep{name='多莉', age='1', color='white'}
    Sheep{name='多莉', age='1', color='white'}
    Sheep{name='多莉', age='1', color='white'}
    Sheep{name='多莉', age='1', color='white'}

如此这般，就算Sheep类多了一个属性，也只需要改动很小的代码，其他的代码都不需要改动。

2.登记形式的原型模式

这种模式的UML类图如下：

如上图所示，本模型有客户端角色、抽象原型角色、具体原型角色、原型管理器角色以下几种角色：

客户端角色：客户端类向管理员提出创建对象的请求
抽象原型角色：这是一个抽象角色，通常由一个接口或抽象类实现，此角色给出所有的具体原型类所需的角色
具体原型角色：被复制的对象，需要实现抽象的原型角色所要求的接口
原型管理器角色：传教具体原型类的对象，并记录每一个被创建的对象

具体原型角色：

package com.charon.prototype.improve;

/**
 * @className: CloneSheep1
 * @description:
 * @author: charon
 * @create: 2022-03-12 16:03
 */
public class CloneSheep1 implements Sheep{
    private String name;

    private int age;

    private String color;

    public CloneSheep1(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

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

    /**
     * 实现克隆方法
     * @return
     */
    @Override
    public synchronized Sheep clone() {
        try {
            return (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

原型管理器角色：作为对所有原型对象的等级，这个角色提供必要的方法，供外界增加新的原型对象和取得已经登记过的原型对象。

package com.charon.prototype.improve;

import java.util.Vector;

/**
 * @className: PrototypeManager
 * @description:
 * @author: charon
 * @create: 2022-03-12 15:43
 */
public class PrototypeManager {

    private Vector objects = new Vector();

    /**
     * 聚集管理方法：增加一个新的对象
     * @param sheep
     */
    public void add(CloneSheep1 sheep){
        objects.add(sheep);
    }

    /**
     * 取出聚集中的一个对象
     * @param i
     * @return
     */
    public CloneSheep1 get(int i){
        return (CloneSheep1) objects.get(i);
    }

    /**
     * 获取大小
     * @return
     */
    public int getSize(){
        return objects.size();
    }
}

客户端调用：

package com.charon.prototype.improve;

/**
 * @className: Client1
 * @description:
 * @author: charon
 * @create: 2022-03-12 16:10
 */
public class Client1 {

    private static PrototypeManager mgr = new PrototypeManager();

    private static CloneSheep1 sheep;

    private static void registerSheep(){
        sheep = new CloneSheep1("多莉", 1, "white");
        CloneSheep1 sheep1 = (CloneSheep1) sheep.clone();
        mgr.add(sheep1);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Client1.registerSheep();
        }
        for (int i = 0; i < Client1.mgr.getSize(); i++) {
            System.out.println(Client1.mgr.get(i));
        }
    }

}

如果需要创建的原型对象数目比较少而且比较固定的话，可以采用第一种简单形式的原型模式，在这种情况下，原型对象的引用可以有客户端自己保存。

如果需要创建的原型对象数目不固定的话，可以采用第二种登记原型模式。在这种情况下，客户端并不保存对原型对象的引用，这个任务被交给管理员对象。在复制一个原型对象之前，客户端可以查看管理员对象是否已经有一个满足要求的原型对象，如果有，客户直接从管理员类取得这个对象的引用，如果没有，客户端就需要自行复制此原型对象。

深拷贝和浅拷贝

讲到克隆，就离不开深拷贝和浅拷贝。

浅拷贝：

对于数据类型及基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象
对于数据类型的引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象，因为实际上两个对象的该成员变量都指向同一个实例，在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
浅拷贝默认使用clone()方法来实现，super.clone();

深拷贝：

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

深拷贝的实现方式1：通过重写clone方法来实现

package com.charon.prototype.improve;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @className: DeepCloneByClone
 * @description: 通过重写clone方法实现深复制
 * @author: charon
 * @create: 2022-03-12 20:28
 */
public class DeepCloneByClone implements Cloneable{

    private String name;

    private Sheep sheep;

    public DeepCloneByClone(String name, Sheep sheep) {
        this.name = name;
        this.sheep = sheep;
    }

    @Override
    public String toString() {
        return "DeepCloneByClone{" +
                "name='" + name + '\'' +
                ", sheep=" + sheep +
                " '},sheep.hashCode =" + sheep.hashCode() ;
    }

    /**
     * 实现克隆方法
     * @return
     */
    @Override
    public DeepCloneByClone clone() {
        try {
            return (DeepCloneByClone) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 实现clone方法的深复制
     * @return
     */
    public DeepCloneByClone deepClone(){
        try {
            Object deep = null;
            // 对基本数据类型和string类型的克隆
            deep = super.clone();
            // 对引用类型的属性，进行单独处理
            DeepCloneByClone deepClone = (DeepCloneByClone) deep;
            deepClone.sheep = sheep.clone();
            return deepClone;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

}

深拷贝的实现方式2：通过对象序列化实现深拷贝

把对象写道琉璃的过程是序列化的过程，而把对象从流中读出来的叫做反序列化。这种方式需要实现Serializable接口。

package com.charon.prototype.improve;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @className: DeepCloneByClone
 * @description: 通过序列化方法实现深复制
 * @author: charon
 * @create: 2022-03-12 20:28
 */
public class DeepCloneByClone implements Serializable,Cloneable{

    private String name;

    private Sheep sheep;

    public DeepCloneByClone(String name, Sheep sheep) {
        this.name = name;
        this.sheep = sheep;
    }

    @Override
    public String toString() {
        return "DeepCloneByClone{" +
                "name='" + name + '\'' +
                ", sheep=" + sheep +
                " '},sheep.hashCode =" + sheep.hashCode() ;
    }

    /**
     * 实现克隆方法，浅克隆
     * @return
     */
    @Override
    public DeepCloneByClone clone() {
        try {
            return (DeepCloneByClone) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 使用序列化的方式实现深复制
     * @return
     */
    public DeepCloneByClone 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);
            DeepCloneByClone deep = (DeepCloneByClone) ois.readObject();
            return deep;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        } finally {
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(oos != null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(ois != null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

注意事项和细节：

创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
不用重新初始化对象，而是动态地获得对象运行时的状态
如果原始对象发生变化（增加或者减少属性），其它克隆对象地也会发生相应地变化，无需修改代码
在实现深克隆地时候可能需要比较复杂地代码
缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了"开-闭"原则

posted @ 2022-03-12 21:26 pluto_charon 阅读(85) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

pluto_charon