设计模式——原型模式（Prototype Pattern）

╰+攻爆jí腚メ 2022-11-10 14:29 107阅读 0赞

定义：原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。属于创建型模式。

通俗地说，原型模式就是快速构建对象的方法总结，简单工厂将get/set方法封装在某个方法中，JDK提供的实现Cloneable接口。

调用者不需要知道任何创建细节，不调用构造函数创建，直接拷贝。简化了产生对象的繁琐的过程，不需要通过构造方法去构造。

适用场景：

*  类初始化消耗资源较多
 *  new产生对象的过程非常繁琐（数据准备，访问权限等）
 *  构造函数比较复杂，不走构造函数，直接复制
 *  循环体中需要生产大量对象时

BeanUtils.copyProperties(source, target);

# 浅克隆 #

通过get/set赋值的方式构建一个新对象，对象中的引用类型属性，只是复制了引用地址，并非复制了值。

public interface Prototype { //原型接口
        Prototype clone();
    }
    public class SimplePrototype implements Prototype {
        private String name;
        private int age;
        List<String> hobbies;
    
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        public int getAge() { return age; }
        public void setAge(int age) { this.age = age; }
        public List<String> getHobbies() { return hobbies; }
        public void setHobbies(List<String> hobbies) { this.hobbies = hobbies; }
    
        @Override
        public Prototype clone() {
            SimplePrototype simplePrototype = new SimplePrototype();
            simplePrototype.setName(this.name);
            simplePrototype.setAge(this.age);
            simplePrototype.setHobbies(this.hobbies);
            return simplePrototype;
        }
    }
    
    public class SimplePrototypeTest {
        public static void main(String[] args) {
            SimplePrototype simplePrototype = new SimplePrototype();
            simplePrototype.setAge(20);
            simplePrototype.setName("张三");
            List<String> hobbies = new ArrayList<String>();
            hobbies.add("swimming");
            hobbies.add("fit");
            simplePrototype.setHobbies(hobbies);
            SimplePrototype copy = (SimplePrototype) simplePrototype.clone();
            copy.getHobbies().add("ball"); //修改的克隆值，但原对象值也发生了改变
            System.out.println(simplePrototype == copy); // false
            System.out.println(simplePrototype.getHobbies() == copy.getHobbies()); //同一块引用地址
            System.out.println(simplePrototype.toString());
            System.out.println(copy.toString());
        }
    }

![20210321165250376.png][]

# 深克隆 #

通过字节码在内存中直接操作，克隆后的对象属性是新的内存地址。

public class DeepPrototype implements Cloneable, Serializable {
        private int age;
        private String name;
        private List<String> hobbies;
    
        public int getAge() { return age; }
        public void setAge(int age) { this.age = age; }
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        public List<String> getHobbies() { return hobbies; }
        public void setHobbies(List<String> hobbies) { this.hobbies = hobbies; }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            Object object = null;
            ByteArrayOutputStream byteArrayOutputStream = null;
            ObjectOutputStream objectOutputStream = null;
            ByteArrayInputStream byteArrayInputStream = null;
            ObjectInputStream objectInputStream = null;
            try {
                byteArrayOutputStream = new ByteArrayOutputStream();
                objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
                objectOutputStream.writeObject(this);
                byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                objectInputStream = new ObjectInputStream(byteArrayInputStream);
                object = objectInputStream.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (null != byteArrayOutputStream) { byteArrayOutputStream.close(); }
                    if (null != objectOutputStream) { objectOutputStream.close(); }
                    if (null != byteArrayInputStream) { byteArrayInputStream.close(); }
                    if (null != objectInputStream) { objectInputStream.close(); }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return object;
        }
    }
    
    public class DeepPrototypeTest {
        public static void main(String[] args) throws CloneNotSupportedException {
            DeepPrototype deepPrototype = new DeepPrototype();
            deepPrototype.setAge(500);
            deepPrototype.setName("齐天大圣");
            List<String> hobbies = new ArrayList<String>();
            hobbies.add("swimming");
            hobbies.add("fit");
            deepPrototype.setHobbies(hobbies);
            DeepPrototype copy = (DeepPrototype) deepPrototype.clone();
            copy.getHobbies().add("study");
            System.out.println(deepPrototype.getHobbies() == copy.getHobbies()); // false 不同的内存地址
            System.out.println(deepPrototype);
            System.out.println(copy);
        }
    }

![20210321165951808.png][]

**原型模式优点：**

*  性能优良，Java自带的原型模式是基于内存二进制流的拷贝，比直接new一个对象性能上提升了许多。
 *  可以使用深度克隆保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，简化了创建过程。

**原型模式缺点：**

*  必须要新加一个clone方法
 *  当对已有类进行改造时，必须修改源码，违背了开闭原则
 *  深拷贝、浅拷贝需要运用得当

[20210321165250376.png]: /images/20221022/ba806c9308424028bd58e019aa413597.png
[20210321165951808.png]: /images/20221022/732337af551f43209b69524515f587f5.png