设计模式：03-原型模式 / 建造者模式(生成器模式)

article - @houyu   2019/12/01   阅读: 1901   点赞: 0  

本篇博客主要是学习 韩顺平_Java设计模式 做一个学习笔记使用

5. 原型模式

基本介绍
1) 原型模式(Prototype 模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
2) 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
3) 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它 们自己来实施创建，即 对象.clone()
4) 形象的理解：孙大圣拔出猴毛， 变出其它孙大圣

5.1. 问题的引入

  1. /**
  2.  * @author houyu
  3.  * @createTime 2019/11/18 20:38
  4.  */
  5. public class Demo1 {
  7.     /**
  8.      * 定义个类 Person
  9.      */
  10.     public static class Person {
  11.         private int age;
  12.         private String name;
  14.         public Person(int age, String name) {
  15.             this.age = age;
  16.             this.name = name;
  17.         }
  18.         public int getAge() {
  19.             return age;
  20.         }
  21.         public String getName() {
  22.             return name;
  23.         }
  24.         @Override
  25.         public String toString() {
  26.             final StringBuilder sb = new StringBuilder("Person{");
  27.             sb.append("age=").append(age);
  28.             sb.append(", name='").append(name).append('\'');
  29.             sb.append('}');
  30.             return sb.toString();
  31.         }
  32.     }
  34.     public static void main(String[] args) {
  35.         // 问题的引入:
  36.         // 需要拷贝 Person 5份
  37.         Person original = new Person(10, "tom");
  38.         //
  39.         Person person1 = new Person(original.getAge(), original.getName());
  40.         Person person2 = new Person(original.getAge(), original.getName());
  41.         Person person3 = new Person(original.getAge(), original.getName());
  42.         Person person4 = new Person(original.getAge(), original.getName());
  43.         Person person5 = new Person(original.getAge(), original.getName());
  44.         //
  45.         System.out.println(person1);
  46.         System.out.println(person2);
  47.         System.out.println(person3);
  48.         System.out.println(person4);
  49.         System.out.println(person5);
  50.         /**
  51.          * 分析问题:
  52.          * 传统的方式的优缺点
  53.          *
  54.          * 1) 优点是比较好理解，简单易操作。
  55.          * 2) 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
  56.          * 3) 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
  57.          * 4) 改进的思路分析
  58.          */
  59.     }
  60. }

5.2 原型模式的浅拷贝

使用默认的原型模式实现的是对象的浅拷贝
什么是浅拷贝?
这个对象的类属性, 如果是基本类型 boolean int long double float char byte short 等类似会进行值传递, 如果是String(final) 也会> 进行值传递
如果是引用类型, 那就就引用拷贝, 比如 List Map Array(int[]…)

  1. 实现接口 implements Cloneable
  2. 重写方法: @Override protected Object clone(){}
  3. 调用端调用clone()即可

代码

  1. import java.util.Arrays;
  3. /**
  4.  * @author houyu
  5.  * @createTime 2019/11/18 20:38
  6.  */
  7. public class Demo2 {
  9.     /**
  10.      * 定义个类 Person
  11.      */
  12.     public static class Person implements Cloneable {
  13.         private int age;
  14.         private String name;
  15.         private int[] array = {1, 2};
  17.         public Person(int age, String name) {
  18.             this.age = age;
  19.             this.name = name;
  20.         }
  21.         public int getAge() {
  22.             return age;
  23.         }
  24.         public String getName() {
  25.             return name;
  26.         }
  27.         public int[] getArray() {
  28.             return array;
  29.         }
  31.         @Override
  32.         public String toString() {
  33.             final StringBuilder sb = new StringBuilder("Person{");
  34.             sb.append("age=").append(age);
  35.             sb.append(", name='").append(name).append('\'');
  36.             sb.append(", array=").append(Arrays.toString(array));
  37.             sb.append('}');
  38.             return sb.toString();
  39.         }
  41.         @Override
  42.         protected Object clone() {
  43.             try {
  44.                 return super.clone();
  45.             } catch(CloneNotSupportedException e) {
  46.                 e.printStackTrace();
  47.             }
  48.             return null;
  49.         }
  50.     }
  52.     public static void main(String[] args) {
  53.         // 问题的引入:
  54.         // 需要拷贝 Person 5份
  55.         Person original = new Person(10, "tom");
  56.         //
  57.         Person person1 = (Person) original.clone();
  58.         Person person2 = (Person) original.clone();
  59.         Person person3 = (Person) original.clone();
  60.         Person person4 = (Person) original.clone();
  61.         Person person5 = (Person) original.clone();
  62.         //
  63.         System.out.println(person1 == original);
  64.         System.out.println(person2 == original);
  65.         System.out.println(person3.getArray() == original.getArray());
  66.         System.out.println(person4);
  67.         System.out.println(person5);
  68.         /*
  69.          * false
  70.          * false
  71.          * true
  72.          * Person{age=10, name='tom', array=[1, 2]}
  73.          * Person{age=10, name='tom', array=[1, 2]}
  74.          */
  75.         //
  76.         /**
  77.          * 注意点:
  78.          *
  79.          * 1. 使用默认的原型模式实现的是对象的浅拷贝
  80.          *
  81.          * 什么是浅拷贝?
  82.          * 这个对象的类属性, 如果是基本类型 boolean int long double float char byte short 等类似会进行值传递, 如果是String(final) 也会进行值传递
  83.          *
  84.          * 如果是引用类型, 那就就引用拷贝, 比如 List Map Array(int[]...)
  85.          *
  86.          */
  87.     }
  88. }

5.3 重写默认原型模式实现深拷贝

注意点：

  • 使用默认的原型模式close，会导致引用类型没有深拷贝，引用是同一个，因此可能会导致其他问题，如：线程安全等。。。
  • 改进方案1(不推荐)：在原来的clone基础之上，手动一个一个添加引用类型的clone
  • 改进方案2(推荐)：使用流写入写出进行克隆（ObjectOutputStream，ObjectInputStream）
  • 改进方案3(推荐)：使用JSON序列化工具进行克隆（fastjson，gson，jackson…）
  1. 实现接口 implements Cloneable, Serializable
  2. 重写方法: @Override protected Object clone(){}，使用 ObjectOutputStream ObjectInputStream 实现
  3. 调用端调用clone()即可
  1. import java.io.ByteArrayInputStream;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.Closeable;
  4. import java.io.IOException;
  5. import java.io.ObjectInputStream;
  6. import java.io.ObjectOutputStream;
  7. import java.io.Serializable;
  8. import java.util.Arrays;
  10. /**
  11.  * @author houyu
  12.  * @createTime 2019/11/18 20:38
  13.  */
  14. public class Demo3 {
  16.     /**
  17.      * 定义个类 Person
  18.      */
  19.     public static class Person implements Cloneable, Serializable {
  20.         private int age;
  21.         private String name;
  22.         private int[] array = {1, 2};
  24.         public Person(int age, String name) {
  25.             this.age = age;
  26.             this.name = name;
  27.         }
  28.         public int getAge() {
  29.             return age;
  30.         }
  31.         public String getName() {
  32.             return name;
  33.         }
  34.         public int[] getArray() {
  35.             return array;
  36.         }
  38.         @Override
  39.         public String toString() {
  40.             final StringBuilder sb = new StringBuilder("Person{");
  41.             sb.append("age=").append(age);
  42.             sb.append(", name='").append(name).append('\'');
  43.             sb.append(", array=").append(Arrays.toString(array));
  44.             sb.append('}');
  45.             return sb.toString();
  46.         }
  48.         @Override
  49.         protected Object clone() {
  50.             ObjectOutputStream objectOutputStream = null;
  51.             ByteArrayOutputStream byteArrayOutputStream = null;
  52.             ObjectInputStream objectInputStream = null;
  53.             ByteArrayInputStream byteArrayInputStream = null;
  54.             try {
  55.                 byteArrayOutputStream = new ByteArrayOutputStream();
  56.                 objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
  57.                 objectOutputStream.writeObject(this);
  58.                 byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
  59.                 objectInputStream = new ObjectInputStream(byteArrayInputStream);
  60.                 return objectInputStream.readObject();
  61.             } catch(IOException | ClassNotFoundException e) {
  62.                 e.printStackTrace();
  63.             } finally {
  64.                 close(objectOutputStream, byteArrayOutputStream, objectInputStream, byteArrayInputStream);
  65.             }
  66.             return null;
  67.         }
  69.         private void close(Closeable... closeables) {
  70.             for(Closeable closeable : closeables) {
  71.                 if(closeable == null) {
  72.                     continue;
  73.                 }
  74.                 try { closeable.close(); } catch(IOException e) {}
  75.             }
  76.         }
  77.     }
  79.     public static void main(String[] args) {
  80.         // 问题的引入:
  81.         // 需要拷贝 Person 5份
  82.         Person original = new Person(10, "tom");
  83.         //
  84.         Person person1 = (Person) original.clone();
  85.         Person person2 = (Person) original.clone();
  86.         Person person3 = (Person) original.clone();
  87.         Person person4 = (Person) original.clone();
  88.         Person person5 = (Person) original.clone();
  89.         //
  90.         System.out.println(person1 == original);
  91.         System.out.println(person2 == original);
  92.         System.out.println(person3.getArray() == original.getArray());
  93.         System.out.println(person4);
  94.         System.out.println(person5);
  95.         /*
  96.          * false
  97.          * false
  98.          * true
  99.          * Person{age=10, name='tom', array=[1, 2]}
  100.          * Person{age=10, name='tom', array=[1, 2]}
  101.          */
  102.         //
  103.         /**
  104.          * 注意点:
  105.          *
  106.          * 1. 必须需要实现Serializable
  107.          *
  108.          */
  109.     }
  110. }

5.4 原型模式在 Spring 框架中源码分析(getBean)

  1. // 1.0 org.springframework.context.support.AbstractApplicationContext
  2. public Object getBean(String name) throws BeansException {
  3.     assertBeanFactoryActive();
  4.     return getBeanFactory().getBean(name);
  5. }
  7. // 2.0 org.springframework.beans.factory.support.AbstractBeanFactory
  8. public Object getBean(String name) throws BeansException {
  9.     return doGetBean(name, null, null, false);
  10. }
  12. // 3.0 org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean()
  13. // Create bean instance.
  14. if (mbd.isSingleton()) {
  15.     sharedInstance = getSingleton(beanName, () -> {
  16.         try {
  17.             return createBean(beanName, mbd, args);
  18.         }
  19.         catch (BeansException ex) {
  20.             // Explicitly remove instance from singleton cache: It might have been put there
  21.             // eagerly by the creation process, to allow for circular reference resolution.
  22.             // Also remove any beans that received a temporary reference to the bean.
  23.             destroySingleton(beanName);
  24.             throw ex;
  25.         }
  26.     });
  27.     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  28. }
  30. else if (mbd.isPrototype()) {
  31.     // It's a prototype -> create a new instance.
  32.     Object prototypeInstance = null;
  33.     try {
  34.         beforePrototypeCreation(beanName);
  35.         prototypeInstance = createBean(beanName, mbd, args);
  36.     }
  37.     finally {
  38.         afterPrototypeCreation(beanName);
  39.     }
  40.     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  41. }
  43. else {
  44.     String scopeName = mbd.getScope();
  45.     final Scope scope = this.scopes.get(scopeName);
  46.     if (scope == null) {
  47.         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  48.     }
  49.     try {
  50.         Object scopedInstance = scope.get(beanName, () -> {
  51.             beforePrototypeCreation(beanName);
  52.             try {
  53.                 return createBean(beanName, mbd, args);
  54.             }
  55.             finally {
  56.                 afterPrototypeCreation(beanName);
  57.             }
  58.         });
  59.         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  60.     }
  61.     catch (IllegalStateException ex) {
  62.         throw new BeanCreationException(beanName,
  63.                 "Scope '" + scopeName + "' is not active for the current thread; consider " +
  64.                 "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  65.                 ex);
  66.     }
  67. }

6. 建造者模式(生成器模式)

基本介绍
1) 建造者模式（Builder Pattern） 又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出 来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
2) 建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们， 用户不需要知道内部的具体构建细节。

6.1 建造者模式的四个角色

1) Product（产品角色）： 一个具体的产品对象。
2) Builder（抽象建造者）： 创建一个 Product 对象的各个部件指定的 接口/抽象类。
3) ConcreteBuilder（具体建造者）： 实现接口，构建和装配各个部件。
4) Director（指挥者）： 构建一个使用 Builder 接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作 用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。

建造者模式解决盖房需求应用实例

  1. /**
  2.  * @author houyu
  3.  * @createTime 2019/11/18 20:00
  4.  */
  5. public class Demo1 {
  7.     /**
  8.      * 产品: 房屋
  9.      */
  10.     public static class House {
  11.         private String wall;
  12.         private String houseTop;
  14.         public String getWall() {
  15.             return wall;
  16.         }
  18.         public House setWall(String wall) {
  19.             this.wall = wall;
  20.             return this;
  21.         }
  23.         public String getHouseTop() {
  24.             return houseTop;
  25.         }
  27.         public House setHouseTop(String houseTop) {
  28.             this.houseTop = houseTop;
  29.             return this;
  30.         }
  32.         @Override
  33.         public String toString() {
  34.             final StringBuilder sb = new StringBuilder("House{");
  35.             sb.append(", wall='").append(wall).append('\'');
  36.             sb.append(", houseTop='").append(houseTop).append('\'');
  37.             sb.append('}');
  38.             return sb.toString();
  39.         }
  40.     }
  42.     /**
  43.      * 抽象建造者: 房屋抽象构建者
  44.      *
  45.      * interface / abstract class
  46.      */
  47.     public interface HouseBuilder {
  48.         /**
  49.          * 做墙
  50.          */
  51.         void makeWall();
  53.         /**
  54.          * 做房顶
  55.          */
  56.         void makeHourTop();
  58.         /**
  59.          * 制作完成房子
  60.          */
  61.         House buildHouse();
  62.     }
  65.     /**
  66.      * 具体构建者: 我的房屋构建者
  67.      */
  68.     public static class MyHouseBuilder extends House implements HouseBuilder {
  69.         House house = new House();
  71.         @Override
  72.         public void makeWall() {
  73.             house.setWall("MyHouseBuilder.makeWall");
  74.         }
  75.         @Override
  76.         public void makeHourTop() {
  77.             house.setHouseTop("MyHouseBuilder.makeHourTop");
  78.         }
  80.         @Override
  81.         public House buildHouse() {
  82.             /**
  83.              * 由 具体构建者 进行构建
  84.              */
  85.             makeWall();
  86.             makeHourTop();
  87.             return house;
  88.         }
  89.     }
  91.     /**
  92.      * 指挥者: 我自己
  93.      */
  94.     public static class My {
  96.         private HouseBuilder builder;
  98.         public My setBuilder(HouseBuilder builder) {
  99.             this.builder = builder;
  100.             return this;
  101.         }
  103.         public House build() {
  104.             return builder.buildHouse();
  105.         }
  106.     }
  108.     public static void main(String[] args) {
  109.         // 创建具体构建者
  110.         HouseBuilder builder = new MyHouseBuilder();
  111.         // 创建指挥者
  112.         My my = new My();
  113.         // 给指挥者传递构建者
  114.         my.setBuilder(builder);
  115.         // 指挥者调用构建者的具体流程构建完成返回房子
  116.         House build = my.build();
  117.         // 输出房子
  118.         System.out.println("build.toString() = " + build.toString());
  119.         /**
  120.          * 这个案例的构建者模式是比较标准的, 很明确的存在4个角色
  121.          *
  122.          * 在很多源码中的构建者模式对于这4个角色, 分界比较模糊, 有些类担任双重角色也是有可能的, 如StringBuilder
  123.          * 也有些构建者模式没有完全存在这4个角色, 有的只有三个角色也有可能的...
  124.          */
  125.     }
  126. }

说明:
在很多源码中的构建者模式对于这4个角色, 分界比较模糊, 有些类担任双重角色也是有可能的, 如StringBuilder
也有些构建者模式没有完全存在这4个角色, 有的只有三个角色也有可能的…

6.2 构造者模式在 JDK 框架中源码分析(StringBuilder)

  1. // 产品
  2. public final class String implements java.io.Serializable, Comparable<String>, CharSequence, Constable, ConstantDesc {
  3. }
  5. // 抽象构建者
  6. public interface Appendable {
  7.     // ...
  8.     Appendable append(CharSequence csq) throws IOException;
  9. }
  11. // 具体建造者 (AbstractStringBuilder 实现了 Appendable 接口方法，这里的 AbstractStringBuilder 已经是建造者，只是不能 实例化)
  12. abstract class AbstractStringBuilder implements Appendable, CharSequence {
  13.     // ...
  14.     public AbstractStringBuilder append(Object obj) {
  15.         return append(String.valueOf(obj));
  16.     }
  17. }
  19. // StringBuilder 即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成, 而 StringBuilder 继承了 AbstractStringBuilder
  20. public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, Comparable<StringBuilder>, CharSequence {
  21.     // ...
  22.     public StringBuilder(String str) {
  23.         super(str.length() + 16);
  24.         append(str);
  25.     }
  26. }

6.3 构造者模式在 lombok 中的应用

6.3.1编写实体类

  1. import lombok.Builder;
  3. @Builder
  4. public class Friend {
  5.     private String name;
  6.     private Integer age;
  7. }

6.3.2编写使用类

  1. public class Test {
  2.     public static void main(String[] args) throws Exception {
  3.         // 下面一行代码充当了 指挥者 和 具体建造者
  4.         Friend friend = Friend.builder().age(10).name("张三").build();
  5.         System.out.println("friend = " + friend);
  6.     }
  7. }

6.3.3反编译 Friend 的构建者

  1. public class Friend {
  2.     private String name;
  3.     private Integer age;
  5.     Friend(String name, Integer age) {
  6.         this.name = name;
  7.         this.age = age;
  8.     }
  10.     public static Friend.FriendBuilder builder() {
  11.         return new Friend.FriendBuilder();
  12.     }
  14.     // 这里没有抽象构建者, 只有具体构建者, 因此构建者模式不一定说一定要存在4个角色的
  15.     public static class FriendBuilder {
  16.         private String name;
  17.         private Integer age;
  19.         FriendBuilder() {
  20.         }
  22.         public Friend.FriendBuilder name(String name) {
  23.             this.name = name;
  24.             return this;
  25.         }
  27.         public Friend.FriendBuilder age(Integer age) {
  28.             this.age = age;
  29.             return this;
  30.         }
  32.         public Friend build() {
  33.             return new Friend(this.name, this.age);
  34.         }
  36.         public String toString() {
  37.             return "Friend.FriendBuilder(name=" + this.name + ", age=" + this.age + ")";
  38.         }
  39.     }
  40. }

6.4 建造者模式的注意事项和细节

1) 客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可 以创建不同的产品对象
2) 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具 体建造者， 用户使用不同的具体建造者即可得到不同的产品对象
3) 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰， 也更方便使用程序来控制创建过程
4) 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭 原则”
5) 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使 用建造者模式，因此其使用范围受到一定的限制。
6) 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因 此在这种情况下，要考虑是否选择建造者模式.
7) 抽象工厂模式 VS 建造者模式
抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采 用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定 的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品

  标签   设计模式、  
mail csdn

作者  :  houyu [后宇]

程序员[ 后宇 ]，是一个关注编程，热爱技术的开发者，热衷于 【Java后端】，【数据爬虫】，【大数据】领域。

在这里会一直记录着我成长的点点滴滴，毕竟好记性不如烂笔头，如果你在博客中有所收获，这也将是我毕生的荣幸。如有差池，还望指出更正！

评论

暂时没有评论哦~，你来评论个吧！！