java设计模式之原型模式

原型模式的定义：

　　原型模式指原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象，属于创建型设计模式。原型模式的核心在于复制原型对象。

以系统中已存在的一个对象原型，直接基于内存二进制流进行复制，不需要再经历耗时的对象初始化过程，性能将大大提升。

原型模式的应用场景：

• 创建对象成本大，需要优化资源。
• 创建一个对象需要繁琐的数据准备或权限访问，需要提高性能或提高安全性。
• 系统中大量使用该类对象，且各个调用者都需要给它的属性重新赋值。

分析JDK浅克隆API带来的问题：

　　在java提供的API中，不需要手动创建抽象原型接口，java内置了Cloneable抽象原型接口，自定义的类型只需要实现该接口并重写Object.clone方法即可完成

对本类的复制。

　　通过查看JDK的源码发现，其实Cloneable是一个空接口。java之所以提供Cloneable接口，只是为了在运行时通知java虚拟机可以安全的在该类上使用clone

方法。如果没有实现Cloneable接口，调用clone()方法会抛出CloneNotSupportedException异常。

 如果使用clone()方法，需要满足以下条件：

1. 对于任何对象o，都有o.clone() != o,也就是说克隆产生的对象和原对象不是同一个对象。
2. 对于任何对象o，都有o.clone().getClass() == o.getClass(),也就是说克隆产生的对象和原对象类型相同。
3. 对于任何对象o，应该有o.clone().equals(o)成立，为什么这样不是绝对的呢，因为如果在不重写hashcode和equals的情况下，是不能保证两个对象equals相等的。

那么在java中浅克隆会带来什么问题呢，看下面的例子：

创建一个User类，并重写clone方法：

package com.liuyi.designmode.creational.prototype;

import lombok.Data;

import java.util.List;

/**
 * @ClassName User
 * @description：
 * @author：liuyi
 * @Date：2020/11/11 20:55
 */
@Data
public class User implements Cloneable{
    private Integer id;

    private String name;

    private List<String> phoneList;

    /* *
     * @Author liuyi
     * @Description //TODO 重写浅克隆方法
     * @Date 2020/11/11 21:11 
     * @Param []
     * @return com.liuyi.designmode.creational.prototype.User
     **/
    @Override
    protected User clone(){
        try {
            return (User) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

创建一个对象，然后克隆一个对象，再修改对应的属性值：

package com.liuyi.designmode.creational.prototype;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassName PrototypeTest
 * @description：
 * @author：liuyi
 * @Date：2020/11/11 21:04
 */
public class PrototypeTest {
    public static void main(String[] args) {
        //创建对象
        User user = new User();
        user.setId(1);
        user.setName("刘一");
        List<String> PhoneList = new ArrayList<>();
        PhoneList.add("1457697");
        PhoneList.add("545452");
        PhoneList.add("5155445645");
        user.setPhoneList(PhoneList);
        //打印之前的对象信息
        System.out.println(user);
        //克隆对象
        User clone = user.clone();
        //修改id为2
        clone.setId(2);
        //删除list对象的一个值
        clone.getPhoneList().remove(1);
        //分别打印
        System.out.println(user);
        System.out.println(clone);

    }
}

我们来看执行结果：

 可以看到，我对克隆之后的值进行修改，基础数据类型id改变了，没有影响原对象，但是改变引用类型List，则原对象的值也发生了改变。这就叫浅拷贝，这也是

浅克隆最致命的问题。那么怎么解决这个问题呢，使用深克隆可以解决该问题。

使用序列化实现深克隆：

　　在上面的基础上添加一个deepClone()方法，代码如下：

 /* *
     * @Author liuyi
     * @Description 深克隆
     * @Date 2020/11/11 21:40 
     * @Param []
     * @return com.liuyi.designmode.creational.prototype.User
     **/
    public User deepClone(){
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (User)ois.readObject();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

把clone方法修改为deepClone方法的结果如下：

 这次修改克隆对象没有影响到原对象，达到了我们的目的。

原型模式的优点：

• java自带的原型模式基于内存二进制流的复制，在性能上比直接new一个对象更佳。
• 可以使用深克隆方式保存对象的状态，以便在需要的时候使用，例如恢复的历史某个状态，可辅助实现撤销操作。

原型模式的缺点：

• 需要对每个类都重写clone方法才能实现。
• clone位于类的内部，如需要修改，则需要修改代码，违背开闭原则。
• 当实现深克隆时候，需要编写复杂的代码，且当对象存在多重嵌套是，需要每一层对象都实现深克隆，实现起来比较麻烦。