每日一个设计模式之【原型模式】

每日一个设计模式之【原型模式】

☁️前言🎉🎉🎉

  大家好✋，我是知识汲取者😄，今天给大家带来一篇有关原型模式的学习笔记。众所周知能够熟练使用设计模式是一个优秀程序猿的必备技能，当我们在项目中选择一个或多个合适的设计模式，不仅能大大提高项目的稳健性、可移植性、可维护性，同时还能让你的代码更加精炼，具备艺术美感。

在学原型模式之前，先提出几个问题：

1. 原型模式是什么，有什么用？（What）
2. 为什么原型模式能有这样的作用？（Why）
3. 原型模式如何用？（How）

话不多说，先上车再说吧(●ˇ∀ˇ●)，相信等你认真看完这篇文章，一定能搞懂这三个问题（PS：如果看完还不懂我倒立**😣）

推荐阅读：

• 设计模式导学：🚪传送门
• 每日一个设计模式系列专栏：🚪传送门
• 设计模式专属Gitee仓库：✈启程
• 设计模式专属Github仓库：🚀上路
• 知识汲取者的个人主页：💓点我哦

🌻原型模式概述

• 什么是原型模式？

  原型模式（Prototype Pattern）是一种创建型模式，他采取克隆原型对象的方法来创建对象的实例，所以也可称作克隆模式。使用原型模式创建的实例，具有与原型一样的数据。

• 原型模式的作用：提高程序的性能。因为原始的使用new创建对象，需要进行数据准备、数据访问和权限访问等一系列耗时的操作，而原型模式是通过克隆对象的方法创建按对象的实例，不需要耗费多余的时间去进行对象初始化

• 原型模式的优缺点

  • 优点：

    • 节约内存。所有实例共享同一个方法，不会创建多个，占用系统资源较少
    • 提高程序的性能。对象的创建是通过克隆出来的，不需要额外消耗时间去进行初始化

    ……

  • 缺点：实现较为复杂，需要细心，不然很容易出现bug

  ……

• 原型模式的应用场景

  • 类初始化消耗资源过多 : 如果类初始化时消耗过多的资源 , 如这个类中某个成员占用大量内存 , 为了节省开销
  • 初始化繁琐耗时 : 类对象创建时经过大量的计算 , 或与本地资源 ( 数据库 , 文件 ) 频繁交互 , 每次创建消耗大量的 CPU 与 时间资源
  • 构造函数复杂 : 类中定义的构造函数复杂
  • 实例对象数量庞大 : 如果在内存中循环创建了很多该实例对象 , 就可以使用原型模式复用不用的对象 , 用于创建新对象
  • 一个对象需要提供给其它对象访问，而且各个调用者可能都需要修改其值时，推荐使用浅克隆
  • 在创建对象的时候，我们不只是希望被创建的对象继承其基类的基本结构，还希望继承原型对象的数据时，推荐使用深克隆

  ……

  在Spring中，原型模式应用得非常广泛。例如 scope = “prototype”，在我们经常用的JSON中的parseObject()方法也是一种原型模式。在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者

• 原型模式的分类

  • 浅克隆：只复制指向某个对象的指针，而不是复制对象的本身，新旧对象还是共享同一块内存，修改一个对象的引用数据，会同时改变另一个对象的引用数据
  • 深克隆：会另外创建一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象

🌱原型模式的实现

🍀浅克隆

所有的Java类都继承自java.lang.Object，而Object类提供一个clone()方法，可以将一个Java对象复制一份在Java中可以直接使用Object提供的clone()方法来实现对象的克隆（浅克隆）能够实现克隆的Java类必须实现一个标识接口Cloneable，表示这个Java类支持复制如果一个类没有实现这个接口但是调用了clone()方法，Java编译器将抛出一个CloneNotSupportedException异常

• 浅克隆的特点：克隆的是基本数据类型和String类型的数据，其他类型的数据都是直接克隆引用

• 浅克隆应用场景：

  • 克隆的对象中只含有基本数据类型或String类型
  • 克隆出来的对象，并不会修改除String以外的引用数据

  ……

• 浅克隆示意图：

• 浅克隆的特点：浅克隆出来的对象，两个对象中的引用数据共用同一块堆内存

• 浅克隆的实现步骤

  • Step1：创建一个类（这个类我们称之为原型类），实现Cloneable接口，同时重写clone方法

    注意：重写的clone方法的访问级别是protected，无法跨包访问，需要修改成public或者default

  • Step2：通过原型类的实例化对象调用clone方法创建一个新的对象

  示例：

  问题描述：通过浅克隆创建Student对象

  具体实现的类图：

  

  Teacher（原型类中的引用数据类型）

  package com.hhxy.projo;
  
  /**
   * @author ghp
   * @date 2022/9/25
   * @Title 老师类
   * @description
   */
  public class Teacher {
      private String name;
      private Integer age;
      
      
     /*-------------------------------------------------------------------------*/
        //为了节约篇幅，构造方法、get方法、set方法、toString方法就被我省略了
        //如果想看完整代码请参考我的gitee仓库
     /*------------------------------------------------------------------------*/
  
  }
  
  

  Stduent（原型类）

  package com.hhxy.projo;
  
  /**
   * @author ghp
   * @date 2022/9/25
   * @Title 学生类
   * @description
   */
  public class Student implements Cloneable{
      private String name;
      private Integer age;
      private String className;
      private Teacher teacher;
      /**
       * 浅克隆
       */
      @Override
      public Student clone(){
          Student student = null;
          try {
              student = (Student) super.clone();
          } catch (CloneNotSupportedException e) {
              throw new RuntimeException(e);
          }
          return student;
      }
  	/*-------------------------------------------------------------------*/
        //为了节约篇幅，构造方法、get方法、set方法、toString方法就被我省略了
        //如果想看完整代码请参考我的Gitee或Github仓库
      /*------------------------------------------------------------------*/
  }
  

测试类

package com.hhxy.test;

import com.hhxy.projo.Student;
import com.hhxy.projo.Teacher;

/**
 * @author ghp
 * @date 2022/9/25
 * @Title 测试类1
 * @description 用于测试浅克隆和深克隆的区别
 */
public class Test1 {
    public static void main(String[] args) throws CloneNotSupportedException {

        Teacher teacher1 = new Teacher("小明", 32);
        //创建一个原型对象，用于克隆
        Student student1 = new Student("张三", 20, "计科一班", teacher1);

        //输出student1的内容、student1的哈希码和student1中teacher的哈希码
        System.out.println("student1 = " + student1);
        System.out.println("student1.hashCode() = " + student1.hashCode());
        System.out.println("student1.getTeacher().hashCode() = " + student1.getTeacher().hashCode());
        System.out.println("---------------------------------------------");

        //使用浅克隆创建student2对象
        Student student2 = student1.clone();
        student2.setName("李四");
        student2.setClassName("计科二班");
//      student2.setTeacher(new Teacher("小红",33));//重新在堆内存中为Teacher开辟一个空间并进行赋值，不会影响student2
        student2.getTeacher().setName("小红");//直接修改堆内存中原有的Teacher对象的值，会影响student2中Teacher的值

        //输出student2的内容、student2的哈希码和student2中teacher的哈希码
        System.out.println("student2 = " + student2);
        System.out.println("student2.hashCode() = " + student2.hashCode());
        System.out.println("student2.getTeacher().hashCode() = " + student2.getTeacher().hashCode());
        System.out.println("---------------------------------------------");

        //重新输出student1的内容、student1的哈希码和student1中teacher的哈希码
        System.out.println("student1 = " + student1);
        System.out.println("student1.hashCode() = " + student1.hashCode());
        System.out.println("student1.getTeacher().hashCode() = " + student1.getTeacher().hashCode());

    }
}

测试结果：

备注：修改数组、集合这种引用数据类型，也会影响到student1（前提是先要通过get方法获取该类型的数据，然后再进行修改，因为直接使用set方法修改，会重新创建一个对象，并不是改变原有的对象）

🍀深克隆

通过前面的测试，我们可以发现浅克隆存在一个严重的bug：当我们修改student2中的引用数据Teacher时，会同时改变student1中Teacher的值，针对这个bug我们可以使用另一种方式进行克隆，也就是深克隆。深克隆对于克隆的引用数据，会重新再堆内存中开辟一个空间用于存储，所以此时克隆出来的student2和student1可以说是一点联系都没有，除了一开始数据是一致的以外。

• 深克隆的特点：深克隆出来的对象完全相互独立，互不影响
• 深克隆示意图：

🐳方式一：使用浅克隆实现深克隆

• 使用浅克隆实现深克隆的特点：这种方式实现起来较为简单，但是如果Teacher中也存在一个引用数据类型的对象，那么就要套娃了

• 应用场景：

  • 如果克隆的对象不存在套娃现象，推荐使用
  • 如果克隆的对象结构比较简单（比如像实验的这个student类），推荐使用

  ……

• 实现步骤：

  • Step1：将原型类和存储在原型的引用数据对应的类都实现Cloneable接口

  • Step2：在克隆方法中，不仅克隆student1，还对student1中的Teacher对象进行克隆

    说明：其实对Teacher对象进行克隆然后进行赋值，这个操作就相当于是将之前浅克隆中注释的哪一行搬到方法内部了，本质还是重新创建一个Teacher对象

  具体实现的类图：

  

  Teacher类（原型类中的引用数据类型），实现Cloneable

  略……

  Student类（原型类）

  package com.hhxy.projo;
  
  /**
   * @author ghp
   * @date 2022/9/25
   * @Title 学生类
   * @description
   */
  public class Student implements Cloneable{
      private String name;
      private Integer age;
      private String className;
      private Teacher teacher;
      /**
       * 使用浅克隆实现深克隆
       */
      @Override
      public Student deepClone(){
          Student student = null;
          try {
              student = (Student) super.clone();
              //深克隆新增步骤：
              student.setTeacher(student.getTeacher().clone());
          } catch (CloneNotSupportedException e) {
              throw new RuntimeException(e);
          }
          return student;
      }
  	/*-------------------------------------------------------------------*/
        //为了节约篇幅，构造方法、get方法、set方法、toString方法就被我省略了
        //如果想看完整代码请参考我的Gitee或Github仓库
      /*------------------------------------------------------------------*/
  }
  

  测试代码

  package com.hhxy.test;
  
  import com.hhxy.projo.Student;
  import com.hhxy.projo.Teacher;
  
  /**
   * @author ghp
   * @date 2022/9/25
   * @Title 测试类1
   * @description 用于测试浅克隆和深克隆的区别
   */
  public class Test1 {
      public static void main(String[] args) throws CloneNotSupportedException {
  
          Teacher teacher1 = new Teacher("小明", 32);
          //创建一个原型对象，用于克隆
          Student student1 = new Student("张三", 20, "计科一班", teacher1);
  
  
          //输出student1的内容、student1的哈希码和student1中teacher的哈希码
          System.out.println("student1 = " + student1);
          System.out.println("student1.hashCode() = " + student1.hashCode());
          System.out.println("student1.getTeacher().hashCode() = " + student1.getTeacher().hashCode());
          System.out.println("---------------------------------------------");
  
          //使用浅克隆创建student2对象
          Student student2 = student1.deepClone();
          //修改克隆出来的对象的数据
          student2.setName("李四");
          student2.setClassName("计科二班");
          student2.getTeacher().setName("小红");
  
          //输出student2的内容、student2的哈希码和student2中teacher的哈希码
          System.out.println("student2 = " + student2);
          System.out.println("student2.hashCode() = " + student2.hashCode());
          System.out.println("student2.getTeacher().hashCode() = " + student2.getTeacher().hashCode());
          System.out.println("---------------------------------------------");
  
          //重新输出student1的内容、student1的哈希码和student1中teacher的哈希码
          System.out.println("student1 = " + student1);
          System.out.println("student1.hashCode() = " + student1.hashCode());
          System.out.println("student1.getTeacher().hashCode() = " + student1.getTeacher().hashCode());
  
      }
  }
  

  测试结果

  

🐳方式二：使用序列化、反序列化实现深克隆

• 特点：克隆出来的对象和原型对象，除了一开始数据一样外，没有任何关系，两者互不影响

• 应用场景：如果原型对象的数据比较复杂 或者 是原型对象中的引用数据类型中存在引用数据类型时

• 实现步骤：

  • Step1：将原型类 和 原型类中引用数据类型对应的类 都实现Cloneable和Serializable两个接口
  • Step2：在原型类中编写一个深刻隆的方法，利用序列化、反序列化克隆出一个新的对象

  

  Teacher类（原型类中的引用数据类型），实现Cloneable和Serializable两个接口

  略……

  Student类（原型类）

  package com.hhxy.projo;
  
  /**
   * @author ghp
   * @date 2022/9/25
   * @Title 学生类
   * @description
   */
  public class Student implements Cloneable{
      private String name;
      private Integer age;
      private String className;
      private Teacher teacher;
      /**
       * 使用序列化、反序列化实现深克隆
       */
      public Student deepClone(){
          //创建流对象
          ByteArrayOutputStream baos = null;
          ObjectOutputStream oos = null;
          ByteArrayInputStream bais = null;
          ObjectInputStream bis = null;
          try{
              //序列化
              baos = new ByteArrayOutputStream();
              oos = new ObjectOutputStream(baos);
              oos.writeObject(this);
              //反序列化
              bais = new ByteArrayInputStream(baos.toByteArray());
              bis = new ObjectInputStream(bais);
              //返回反序列化构建的对象
              return (Student) bis.readObject();
          } catch (Exception e) {
              //如果发生异常，就输出异常信息，并返回一个null
              e.printStackTrace();
              return null;
          }finally {
              //释放资源
              try {
                  baos.close();
                  oos.close();
                  bais.close();
                  bis.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
  	/*-------------------------------------------------------------------*/
        //为了节约篇幅，构造方法、get方法、set方法、toString方法就被我省略了
        //如果想看完整代码请参考我的Gitee或Github仓库
      /*------------------------------------------------------------------*/
  }
  

  测试代码

  将方式一的测试代码改一下就OK了，略……

  测试结果

  

🌲总结

说白了原型模式的作用就是为了提高程序的性能，减少创建对象时的时间、资源消耗。一般而言，在项目中原型模式都是和工厂模式成对出现的。同时在使用原型模式的时候，一定要注意浅克隆和深克隆的区别！

• 深克隆和浅克隆的区别和联系

  • 使用同样的接口。浅克隆和深克隆都需要原型类实现Cloneable接口，不同的是使用深克隆，不仅要让原型类实现Cloneable接口，还要让原型类中引用数据类型对应的类也实现Cloneable接口（如果深克隆是使用方式二，还要同时实现Serializable接口）

  • 克隆方式不同。浅克隆只会克隆String类型和基本数据类型的数据，对于其他引用数据类型克隆的是引用，修改克隆得到的对象中的引用数据类型（除String以外的引用数据类型，比如数组、集合、类对象）会同时修改原型类中的引用数据类型；

    深克隆克隆的是对象的所有数据，克隆出来对象和原型对象除了一开始数据是一样的以外，没有任何关系，两者互不影响

  • 性能不同。浅克隆共用引用，不会重新开辟堆内存，能够节约一定的内存；而深克隆会重新开辟堆内存，用于存放克隆的引用数据类型。所以浅克隆的性能要优于深克隆

• 深克隆两种实现方式的异同

  • 方式一（使用浅克隆实现深克隆）实现起来很简单，但是面对类中数据比较多时，或者是类中引用数据又存在引用数据时，就会让实现变得很复杂，比较适合用在一些简单的场所
  • 方式二（实用序列化、反序列化实现深克隆）实现起来不算复杂，且适用范围很全面，推荐使用

至此，文章就结束了，相信你心中应该有What、Why、How三个问题的答案了吧(●’◡’●)

如果觉得本文对你有一丢丢帮助的话😄，欢迎点赞👍+评论✍，您的支持将是我写出更加优秀文章的动力O(∩_∩)O

---

上一篇：每日一个设计模式之【单例模式】

下一篇：每日一个设计模式之【工厂模式】

参考文章：

• 【源码分析设计模式 4】JDK中的原型模式
• 序列化和反序列化的详解

在此致谢