前言

本文内容

  • 介绍原型模式
  • 实现原型模式
  • 介绍原型模式的使用场景

    正文

    介绍

    如果对象的创建成本比较大，而同一个类的不同对象之间差别不大（大部分字段都相同），在这种情况下，我们可以利用对已有对象（原型）进行复制（或者叫拷贝）的方式来创建新对象，以达到节省创建时间的目的。这种基于原型来创建对象的方式就叫作原型设计模式（Prototype Design Pattern），简称原型模式。 -设计模式之美

简单的说，就是创建对象后，初始化的属性来自其它对象

实现

实现方式很简单，就是实现 Cloneable , 然后重写下 clone 方法。实现 Cloneable 并没有什么必须要实现的方法，只是用于JVM判断该类可以使用 clone 方法。这种方式直接由 JVM 进行处理，将被拷贝对象的内存中存储的信息复制一份到新内存中，所以不会调用构造器

  1. package cn.zjm404.stu.dp.creat.prototype;
  3. public class ProtoType implements Cloneable{
  4.     //属性
  5.     //方法
  7.     @Override
  8.     public ProtoType clone() {
  9.         ProtoType res = null;
  10.         try{
  11.             res = (ProtoType)super.clone();
  12.         } catch (CloneNotSupportedException e) {
  13.             e.printStackTrace();
  14.         }
  15.         return res;
  16.     }
  17. }

这里涉及到了两种拷贝方式，深拷贝与浅拷贝

浅拷贝与深拷贝

对于类中为引用数据类型的属性，浅拷贝只是把指向被拷贝的数据的地址复制一份进行保存，而深拷贝则是实例化一个同样的引用数据类型的对象，然后将被拷贝的对象的属性复制到新的对象中。
浅拷贝的好处就是拷贝比较快，但是对于还有引用数据类型属性的类，有一部分值是拷贝对象与背靠背对象共享的，如果这些值可以进行修改，那么就会出现问题。就像这样

  1. package cn.zjm404.stu.dp.creat.prototype;
  3. import lombok.*;
  5. @Setter
  6. @Getter
  7. @AllArgsConstructor
  8. @NoArgsConstructor
  9. @ToString
  10. public class MsgObject {
  11.     private int id;
  12.     private String msg;
  13. }
  1. package cn.zjm404.stu.dp.creat.prototype;
  3. import lombok.Getter;
  4. import lombok.Setter;
  5. import lombok.ToString;
  7. @Setter
  8. @Getter
  9. @ToString
  10. public class ProtoType implements Cloneable{
  11.     private MsgObject msg1;
  13.     @Override
  14.     public ProtoType clone() {
  15.         ProtoType res = null;
  16.         try{
  17.             res = (ProtoType)super.clone();
  18.         } catch (CloneNotSupportedException e) {
  19.             e.printStackTrace();
  20.         }
  21.         return res;
  22.     }
  23. }
  1. package cn.zjm404.stu.dp.creat.prototype;
  3. public class Client {
  4.     public static void main(String[] args) {
  5.         ProtoType protoType = new ProtoType();
  6.         protoType.setMsg1(new MsgObject(1,"hello world"));
  7.         System.out.println("protoType: " + protoType.toString());
  8.         ProtoType protoType1 = protoType.clone();
  9.         protoType1.getMsg1().setMsg("HELLO WORLD");
  10.         System.out.println("protoType1: " + protoType1.toString());
  11.         System.out.println("protoType: " + protoType.toString());
  12.     }
  13. }

image.png
可以看到被拷贝对象中的数据被修改了。解决方式有两种，一是对共享数据限制为读，不进行修改。二是使用深拷贝。

使用 Cloneable 来实现深拷贝

保证被拷贝中的引用数据类型属性都实现了 Cloneable ，然后重写被拷贝类的 clone ,将引用属性均使用 clone 方法

  1. package cn.zjm404.stu.dp.creat.prototype;
  3. import lombok.*;
  5. @Setter
  6. @Getter
  7. @AllArgsConstructor
  8. @NoArgsConstructor
  9. @ToString
  10. public class MsgObject implements Cloneable{
  11.     private int id;
  12.     private String msg;
  14.     @Override
  15.     public MsgObject clone() throws CloneNotSupportedException {
  16.         return (MsgObject) super.clone();
  17.     }
  18. }
  1. package cn.zjm404.stu.dp.creat.prototype;
  3. import lombok.Getter;
  4. import lombok.Setter;
  5. import lombok.ToString;
  8. @Setter
  9. @Getter
  10. @ToString
  11. public class ProtoType implements Cloneable{
  12.     private MsgObject msg1;
  14.     @Override
  15.     public ProtoType clone() throws CloneNotSupportedException {
  16.         ProtoType res = (ProtoType) super.clone();
  17.         res.msg1 = res.msg1.clone();
  18.         return res;
  19.     }
  21. }
  1. package cn.zjm404.stu.dp.creat.prototype;
  3. public class Client {
  4.     public static void main(String[] args) throws CloneNotSupportedException {
  5.         ProtoType protoType = new ProtoType();
  6.         protoType.setMsg1(new MsgObject(1,"hello world"));
  7.         System.out.println("protoType: " + protoType.toString());
  8.         ProtoType protoType1 = protoType.clone();
  9.         protoType1.getMsg1().setMsg("HELLO WORLD");
  10.         System.out.println("protoType1: " + protoType1.toString());
  11.         System.out.println("protoType: " + protoType.toString());
  12.     }
  13. }

image.png

使用序列化实现深拷贝

核心方法如下，先将对象中的数据转为 byte 流，然后再进行读取，转为 protoType 返回。

  1.     public ProtoType deepClone() throws IOException, ClassNotFoundException {
  2.         ByteArrayOutputStream bo = new ByteArrayOutputStream();
  3.         ObjectOutputStream oo = new ObjectOutputStream(bo);
  4.         oo.writeObject(this);
  6.         ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
  7.         ObjectInputStream oi = new ObjectInputStream(bi);
  9.         return (ProtoType) oi.readObject();
  10.     }

完整如下

  1. package cn.zjm404.stu.dp.creat.prototype;
  3. import lombok.Getter;
  4. import lombok.Setter;
  5. import lombok.ToString;
  7. import java.io.*;
  10. @Setter
  11. @Getter
  12. @ToString
  13. public class ProtoType implements Cloneable,Serializable{
  14.     private MsgObject msg1;
  16.     @Override
  17.     public ProtoType clone() throws CloneNotSupportedException {
  18.         ProtoType res = (ProtoType) super.clone();
  19.         res.msg1 = res.msg1.clone();
  20.         return res;
  21.     }
  23.     public ProtoType deepClone() throws IOException, ClassNotFoundException {
  24.         ByteArrayOutputStream bo = new ByteArrayOutputStream();
  25.         ObjectOutputStream oo = new ObjectOutputStream(bo);
  26.         oo.writeObject(this);
  28.         ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
  29.         ObjectInputStream oi = new ObjectInputStream(bi);
  31.         return (ProtoType) oi.readObject();
  32.     }
  33. }
package cn.zjm404.stu.dp.creat.prototype;

import lombok.*;

import java.io.Serializable;

@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class MsgObject implements Cloneable, Serializable {
    private int id;
    private String msg;

    @Override
    public MsgObject clone() throws CloneNotSupportedException {
        return (MsgObject) super.clone();
    }
}

package cn.zjm404.stu.dp.creat.prototype;

import java.io.IOException;

public class Client {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ProtoType protoType = new ProtoType();
        protoType.setMsg1(new MsgObject(1,"hello world"));
        System.out.println("protoType: " + protoType.toString());
        ProtoType protoType1 = protoType.deepClone();
        protoType1.getMsg1().setMsg("HELLO WORLD");
        System.out.println("protoType1: " + protoType1.toString());
        System.out.println("protoType: " + protoType.toString());
    }
}

使用场景

如果对象中的数据来自数据库或来自网络时，当再创建新的对象时，可以使用拷贝模式，减少创建时间。

参考