设计模式笔记（四）—— 原型模式

原型模式

定义：

原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
不需要知道任何创建细节，不调用构造函数

类型：

创建型

适用场景：

• 类初始化消耗较多资源
• new 产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）
• 构造函数比较复杂
• 循环体中生产大量对象

优点：

二进制流拷贝，性能比直接new一个对象高，简化创建过程

缺点：

必须配备克隆方法；对克隆复杂对象或对克隆出的对象进行复杂改造时，容易引入风险；深拷贝、浅拷贝要运用得当

扩展：

深克隆、浅克隆

实现：

实现Cloneable接口，重写clone方法

@Getter
@Setter
@ToString
public class Mail implements Cloneable{
    private String name;
    private String emailAddress;
    private String content;
    public Mail() {
        System.out.println("Mail Class Constructor");
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        System.out.println("Clone mail Object");
        return super.clone();
    }
}
-----------------------------------------------------------------------
public class MailUtil {
    public static void sendMail(Mail mail) {
        String outputContent = "向{0}小伙伴, 邮件地址{1}, 邮件内容: {2} 发送邮件成功";
        System.out.println(MessageFormat.format(outputContent, mail.getName(),
                mail.getEmailAddress(), mail.getContent()));
    }
    public static void saveOriginMailRecord(Mail mail) {
        System.out.println("==== 存储originMail记录, originMail: " + mail.getContent());
    }
}
-----------------------------------------------------------------------
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Mail mail = new Mail();
        mail.setContent("初始化模板");

        for (int i = 1; i <= 5; i++) {
            Mail mailTemp = (Mail) mail.clone();
            mailTemp.setName("姓名" + i);
            mailTemp.setEmailAddress("姓名" + i + "@qq.com");
            mailTemp.setContent("十连" + i + "ssr");
            MailUtil.sendMail(mailTemp);
        }
        MailUtil.saveOriginMailRecord(mail);
    }
}

深克隆、浅克隆

深克隆与浅克隆的区别体现在引用类型上

浅克隆：
使用默认的重写clone方法

clone得到一个对象后，输出相同，对象的内存地址不同
而当我们只修改pigge的birthday属性值后，发现pig的birthday也被修改了

@Getter
@Setter
@AllArgsConstructor
public class Pig implements Cloneable{
    private String name;
    private Date birthday;

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

    @Override
    public String toString() {
        return "Pig{" +
                "name='" + name + '\'' +
                ", birthday=" + birthday +
                '}' + '\n' + super.toString();
    }
}
------------------------------------------------------------------------
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date birthday = new Date(0L);
        Pig pigge = new Pig("佩奇", birthday);
        Pig pig = (Pig) pigge.clone();
        System.out.println(pigge);
        System.out.println(pig);
        System.out.println("=============================");
        pigge.getBirthday().setTime(999999999999L);
        System.out.println(pigge);
        System.out.println(pig);
    }
}

控制台输出：

Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
com.orcas.gof23.prototype.clone.Pig@7440e464
Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
com.orcas.gof23.prototype.clone.Pig@49476842
=============================
Pig{name='佩奇', birthday=Sun Sep 09 09:46:39 CST 2001}
com.orcas.gof23.prototype.clone.Pig@7440e464
Pig{name='佩奇', birthday=Sun Sep 09 09:46:39 CST 2001}
com.orcas.gof23.prototype.clone.Pig@49476842

debug后，可以看到
虽然pigge和pig的内存地址不同，然而它们的birthday是同一个内存地址，因此在修改其中一个对象的birthday时，另一个对象的birthday也被修改了。

克隆出来的Date引用的是同一个对象，是浅克隆。

深克隆：

需要将该对象中的引用对象单独进行克隆

  @Override
    protected Object clone() throws CloneNotSupportedException {
        Pig pig = (Pig) super.clone();
        pig.birthday =(Date) pig.birthday.clone();
        return pig;
    }

此时，debug可看到
两个对象中的Date类型的birthday指向了不同的内存地址
因此在修改其中一个birthday的值时不会影响到另一个

克隆破坏单例

public class Test {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        HungrySingleton instance = HungrySingleton.getInstance();
        Method cloneMethod = instance.getClass().getDeclaredMethod("clone");
        cloneMethod.setAccessible(true);
        HungrySingleton cloneInstance = (HungrySingleton) cloneMethod.invoke(instance);
        System.out.println(instance);
        System.out.println(cloneInstance);
    }
}
-------------------------------------------------------------------
public class HungrySingleton implements Serializable, Cloneable {
    private final static HungrySingleton instance;
    static {
        instance = new HungrySingleton();
    }
    private HungrySingleton() {
        if (instance != null) {
            throw new RuntimeException("单例构造器静止反射调用");
        }
    }
    public static HungrySingleton getInstance() {
        return instance;
    }
    private Object readResolve() {
        return instance;
    }

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

输出了不同的对象

com.orcas.gof23.singleton.HungrySingleton@4d7e1886
com.orcas.gof23.singleton.HungrySingleton@3cd1a2f1

如何避免？

不实现Cloneable接口，或者重写clone方法时，直接返回实例

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

具体应用

实现了Cloneable接口的

1、ArrayList

   public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

2、HashMap

    @Override
    public Object clone() {
        HashMap<K,V> result;
        try {
            result = (HashMap<K,V>)super.clone();
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
        result.reinitialize();
        result.putMapEntries(this, false);
        return result;
    }

等等