一、前言

本篇介绍 Java 设计模式中创建型模式的最后一种--原型模式。上篇设计模式主题为 《Java 设计模式之建造者模式(四)》

二、简单介绍

原型模式是一种对象创建型模式,它采取复制原型对象的方法来创建对象的实例。使用原型模式创建的实例,具有与原型一样的数据。

# 2.1 特点

  1. 由原型对象自身创建目标对象。即对象创建这一动作发自原型对象本身。

  2. 目标对象是原型对象的一个克隆。即通过原型模式创建的对象,不仅仅与原型对象具有相同的结构,还与原型对象具有相同的值。

  3. 根据对象克隆深度层次的不同,有浅度克隆与深度克隆。

# 2.2 应用场景

  1. 在创建对象的时候,我们不只是希望被创建的对象继承其父类的基本结构,还希望继承原型对象的数据。

  2. 希望对目标对象的修改不影响既有的原型对象(深度克隆的时候可以完全互不影响)。

  3. 隐藏克隆操作的细节。很多时候,对对象本身的克隆需要涉及到类本身的数据细节。

三、实现方式

我们以克隆羊为例,实现类需要实现 Cloneable 接口,同时要重写从 Object 类中继承的 clone 方法:

  1. public class Sheep implements Cloneable{
  2. private String name;
  3. private Date birthday;
  4. public String getName() {
  5. return name;
  6. }
  7. public void setName(String name) {
  8. this.name = name;
  9. }
  10. public Date getBirthday() {
  11. return birthday;
  12. }
  13. public void setBirthday(Date birthday) {
  14. this.birthday = birthday;
  15. }
  16. @Override
  17. protected Object clone() throws CloneNotSupportedException {
  18. return super.clone();
  19. }
  20. }

客户端:

  1. public class Client {
  2. public static void main(String[] args) throws CloneNotSupportedException {
  3. Date date = new Date(1365215478956L);
  4. Sheep sheep = new Sheep();
  5. sheep.setName("多利");
  6. sheep.setBirthday(date);
  7. Sheep clone = (Sheep) sheep.clone();
  8. System.out.println("克隆羊名字:" + clone.getName());
  9. System.out.println("克隆羊生日:" + clone.getBirthday());
  10. }
  11. }

结果:

  1. 克隆羊名字:多利
  2. 克隆羊生日:Sat Apr 06 10:31:18 CST 2013

当我们需要更多的羊时,只需调用第一只羊的 clone 方法即可,省去了给新建的对象设置属性的操作。

不过,上边的克隆方式属于浅度克隆,当对象中包含引用类型的属性时,这样浅克隆方式会存在一个问题。我们试着修改 date 的值:

  1. public class Client {
  2. public static void main(String[] args) throws CloneNotSupportedException {
  3. Date date = new Date(1365215478956L);
  4. Sheep sheep = new Sheep();
  5. sheep.setName("多利");
  6. sheep.setBirthday(date);
  7. Sheep clone = (Sheep) sheep.clone();
  8. System.out.println("克隆羊名字:" + clone.getName());
  9. System.out.println("克隆羊生日:" + clone.getBirthday());
  10. System.out.println("--------------------------------");
  11. // 修改本体羊生日
  12. date.setTime(3246584261356L);
  13. System.out.println("本体羊生日:" + sheep.getBirthday());
  14. System.out.println("克隆羊生日:" + clone.getBirthday());
  15. }
  16. }

结果打印:

  1. 克隆羊名字:多利
  2. 克隆羊生日:Sat Apr 06 10:31:18 CST 2013
  3. --------------------------------
  4. 本体羊生日:Thu Nov 17 12:57:41 CST 2072
  5. 克隆羊生日:Thu Nov 17 12:57:41 CST 2072

我们修改本体羊的日期,结果克隆羊的日期也发生变化。

因为浅度克隆只对基本数据类型的值进行备份,而引用类型的数据只是拷贝了指向对象的引用而已。其内存表现形式如下图:

从图中可知,两只羊共用一个日期对象。因此,当我们修改日期时,两只羊的日期也发生变化。

为了解决这一个问题,我们可以使用深度克隆方式,有 2 种方式可以实现深度克隆。

方式一:在 clone 方法中将所有引用类型数据进行克隆。

实体类:

  1. @Override
  2. protected Object clone() throws CloneNotSupportedException {
  3. Object obj = super.clone();
  4. Sheep sheep = (Sheep) obj;
  5. // 克隆时间
  6. sheep.birthday = (Date) this.birthday.clone();
  7. return sheep;
  8. }

在实体类的 clone 方法中,将引用类型的数据一起克隆。

在运行客户端代码时,结果如下:

  1. 克隆羊名字:多利
  2. 克隆羊生日:Sat Apr 06 10:31:18 CST 2013
  3. --------------------------------
  4. 本体羊生日:Thu Nov 17 12:57:41 CST 2072
  5. 克隆羊生日:Sat Apr 06 10:31:18 CST 2013

方式二:使用序列化和反序列化进行克隆

因为所有序列化方式,因此实体必须实现 Serializable 接口。

实体类:

  1. public class Sheep implements Cloneable,Serializable{
  2. ...
  3. }

客户端:

  1. public class Client {
  2. public static void main(String[] args) throws CloneNotSupportedException,ClassNotFoundException, IOException {
  3. Date date = new Date(1365215478956L);
  4. Sheep sheep = new Sheep();
  5. sheep.setName("多利");
  6. sheep.setBirthday(date);
  7. //通过序列化和反序列化进行克隆
  8. ByteArrayOutputStream bos = new ByteArrayOutputStream();
  9. ObjectOutputStream oos = new ObjectOutputStream(bos);
  10. oos.writeObject(sheep);
  11. ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
  12. ObjectInputStream ois = new ObjectInputStream(bis);
  13. Sheep clone = (Sheep) ois.readObject();
  14. System.out.println("克隆羊名字:" + clone.getName());
  15. System.out.println("克隆羊生日:" + clone.getBirthday());
  16. System.out.println("--------------------------------");
  17. // 修改本体羊生日
  18. date.setTime(3246584261356L);
  19. System.out.println("本体羊生日:" + sheep.getBirthday());
  20. System.out.println("克隆羊生日:" + clone.getBirthday());
  21. }
  22. }

打印结果与方式一的结果一致。

深度克隆的内存表现形式如下图:

四、性能比较

使用原型模式创建对象并不会调用类的构造方法。因此,在构造函数调用长且需要重复创建该类的实例的情况下,使用原型模式创建对象的优势就体现出来了。

实体类:

  1. public class Sheep implements Cloneable{
  2. private String name;
  3. private Date birthday;
  4. public Sheep() {
  5. try {
  6. Thread.sleep(10);
  7. } catch (InterruptedException e) {
  8. e.printStackTrace();
  9. }
  10. }
  11. public String getName() {
  12. return name;
  13. }
  14. public void setName(String name) {
  15. this.name = name;
  16. }
  17. public Date getBirthday() {
  18. return birthday;
  19. }
  20. public void setBirthday(Date birthday) {
  21. this.birthday = birthday;
  22. }
  23. @Override
  24. protected Object clone() throws CloneNotSupportedException {
  25. return super.clone();
  26. }
  27. }

延迟构造器调用的时间。

客户端:

  1. public class Client {
  2. public static void main(String[] args) throws CloneNotSupportedException {
  3. Sheep sheep = new Sheep();
  4. int num = 1000;
  5. long t1 = System.currentTimeMillis();
  6. for (int i = 0; i < num; i++) {
  7. Sheep tmp = new Sheep();
  8. }
  9. System.out.println("new 方式耗时:" + (System.currentTimeMillis() - t1) + "ms");
  10. long t2 = System.currentTimeMillis();
  11. for (int i = 0; i < num; i++) {
  12. Sheep tmp = (Sheep) sheep.clone();
  13. }
  14. System.out.println("克隆方式耗时:" + (System.currentTimeMillis() - t2) + "ms");
  15. }
  16. }

结果:

  1. new 方式耗时:10298ms
  2. 克隆方式耗时:1ms