重修设计模式-创建型-原型模式

重修设计模式-创建型-原型模式

原型模式就是利用已有对象（原型）通过拷贝方式来创建对象的模式，达到节省对象创建时间的目的。适用于对象创建成本较大，且同一类的不同对象之间差别不大的场景。

比如一个对象中的数据需要经过复杂计算才能得到（如排序），或者对象是从网络、文件系统等通过IO读取的，这种情况下就可以用原型模式快速拷贝出一个新对象来使用，而不是再经过复杂计算或读取 IO 来创建对象。

原型模式的核心就是对象的拷贝，且有浅拷贝和深拷贝的区别。

• 浅拷贝：只会复制基本类型的数据和引用对象的内存地址，不会递归的拷贝引用对象本身，比如 Java 中 Object 的 clonse() 方法。
• 深拷贝：不仅复制基本类型的数据，也会拷贝引用类型的对象（会开辟新的内存空间，并将新开辟的内存地址引用给新对象），从而得到一份完全独立的对象。

Kotlin 中 data class 的 copy() 方法，或 Java 中 Object 的 clone() 方法都是浅拷贝的实现，下面验证一下：

data class User(var name: String, var age: Int, val address: Address): Cloneable {
    public override fun clone(): Any {
        return super.clone()
    }
}

data class Address(var street: String, var city: String) : Cloneable {
    override fun clone(): Any {
        return super.clone()
    }
}

测试 copy() 和 clone() 方法：

fun main(args: Array<String>) {
    val user = User("白泽", 18, Address("浦东新区花园石桥路28弄", "上海"))
    val userCopy = user.copy()
    val userCopy1 = user.clone() as User

    println("user1:${user}")
    println("user2:${userCopy}")
    println("user address:${user.address == userCopy.address}")     //判断值，相当于equal
    println("user address:${user.address === userCopy.address}")    //判断内存地址

    println("---")

    println("user1:${user}")
    println("user2:${userCopy1}")
    println("user address:${user.address == userCopy1.address}")     //判断值，相当于equal
    println("user address:${user.address === userCopy1.address}")    //判断内存地址
}

代码执行结果：

user1:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user2:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user address:true
user address:true
---
user1:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user2:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user address:true
user address:true

可见引用类型对象指向的内存地址还是同一个，并没有真正地进行拷贝，这一点通过源码也可以得到验证。将 User 编译成字节码后，再反编译成 Java 语言：

public final class User implements Cloneable {
   @NotNull
   private String name;
   private int age;
   @NotNull
   private final Address address;

   //调用的是Object的clone()方法
   @NotNull
   public Object clone() {
      return super.clone();
   }

   //componentX()方法，用于解构赋值语法

   @NotNull
   public final User copy(@NotNull String name, int age, @NotNull Address address) {
      Intrinsics.checkNotNullParameter(name, "name");
      Intrinsics.checkNotNullParameter(address, "address");
      return new User(name, age, address);
   }
}

public final class Address implements Cloneable {
   @NotNull
   private String street;
   @NotNull
   private String city;

   @NotNull
   public Object clone() {
      return super.clone();
   }

   @NotNull
   public final Address copy(@NotNull String street, @NotNull String city) {
      Intrinsics.checkNotNullParameter(street, "street");
      Intrinsics.checkNotNullParameter(city, "city");
      return new Address(street, city);
   }
}

可以看到，copy() 方法并不会对引用类型对象进行拷贝工作，而是直接传入。而 clone() 方法则是由底层实现，执行逻辑相同。

@HotSpotIntrinsicCandidate
protected native Object clone() throws CloneNotSupportedException;

下面介绍深拷贝的几种实现方式：
1.深拷贝实现—自己实现Cloneable的clone方法：

data class User(var name: String, var age: Int, val address: Address): Cloneable {
    public override fun clone(): Any {
        return User(name, age, address.clone() as Address)
    }
}

data class Address(var street: String, var city: String) : Cloneable {
    public override fun clone(): Any {
        return Address(street, city)
    }
}

打印结果：

user1:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user2:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user address:true
user address:false

引用地址不相同了，说明是两个独立的对象，这种方式比较麻烦，增减字段都需要对 clone() 方法进行维护，如果引用对象嵌套较深还容易出错。

2.深拷贝实现—序列化：

fun main(args: Array<String>) {
    val user = User("白泽", 18, Address("浦东新区花园石桥路28弄", "上海"))
    val userCopy = deepCopy(user) as User

    println("user1:${user}")
    println("user2:${userCopy}")
    println("user address:${user.address == userCopy.address}")     //判断值，相当于equal
    println("user address:${user.address === userCopy.address}")    //判断内存地址
}

fun deepCopy(obj: Any?): Any {
    val bo = ByteArrayOutputStream()
    val oo = ObjectOutputStream(bo)
    oo.writeObject(obj)

    val bi = ByteArrayInputStream(bo.toByteArray())
    val oi = ObjectInputStream(bi)

    return oi.readObject()
}

打印结果：

user1:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user2:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user address:true
user address:false

这种实现方式需要类中所有引用类型（包括嵌套的）都实现 Serializable 接口，否则会抛出 NotSerializableException 异常。

3.深拷贝实现—Json：

fun main(args: Array<String>) {
    val user = User("白泽", 18, Address("浦东新区花园石桥路28弄", "上海"))
    val userCopy = deepCopy(user)

    println("user1:${user}")
    println("user2:${userCopy}")
    println("user address:${user.address == userCopy.address}")     //判断值，相当于equal
    println("user address:${user.address === userCopy.address}")    //判断内存地址
}

inline fun <reified T> deepCopy(data: T): T {
    val gson = Gson()
    val json = gson.toJson(data)
    return gson.fromJson<T>(json, T::class.java)
}

打印结果：

user1:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user2:User(name=白泽, age=18, address=Address(street=浦东新区花园石桥路28弄, city=上海))
user address:true
user address:false

这里使用 Kotlin 的内联函数配合范型实化封装了 deepCopy 方法，其内部是通过Google 的 Json 解析库 Gson 进行实现的，先将对象转为 Json 字符串，然后再解析 Json 来创建新对象。

4.深拷贝实现—写时复制思想

以上深拷贝方式由于在拷贝时创建了大量对象，都会伴随性能损耗。其实可以借助 Copy On Write 思想，先通过浅拷贝将对象复制出来，再使用中再进行对象的创建，从而将对象创建的损耗平摊到后续业务中。

当然这种方式需要看具体业务场景再决定如何实现，如果应用一个复杂的模式，只得到一点点的性能提升，这就是所谓的过度设计，得不偿失。

经典场景

理论说完了，再结合实际场景来尝试使用。比如 App 的个人中心展示了用户的所有信息，如用户名，生日，地址，个性签名等，同时还有保存和重置按钮，其中保存按钮需要实时更新状态：只有真正的修改了用户信息才可以点击，否则置灰无法点击。重置按钮点击后会恢复页面原信息。

这种需求场景可以利用原型模式的思想，通过拷贝得到一个新对象，后续的信息修改都基于新对象，并且每次改动后都和原对象进行对比，判断字段值是否真正修改来更新保存按钮状态。在点击重置按钮时，重新基于原对象拷贝新对象，并根据该对象刷新页面实现重置功能。

总结

利用已有对象来创建新对象，以达到节省创建时间的目的，就叫做原型模式。

原型模式的核心是对象的拷贝，对象拷贝又分为浅拷贝和深拷贝，其中浅拷贝会共用引用类型对象，而深拷贝会创建新的引用对象。