场景 （1）构造一个复杂的对象，很多的属性，有些属性构造的时候需要做一些校验，格式转换

1.常规

  1. package com.example.demo.pattern.builder;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class WithoutBuilderPatternDemo {
  8.     public static void main(String[] args) {
  9.         // 构造这个复杂的product对象
  10.         Product product = new Product();
  11.         // 设置field1属性
  12.         System.out.println("在设置field1之前进行复杂的校验逻辑");  
  13.         product.setField1("值1");  
  14.         // 设置field2属性
  15.         System.out.println("在设置field2之前进行复杂的数据格式转化逻辑");  
  16.         product.setField2("值2");  
  17.         // 设置field3属性
  18.         System.out.println("在设置field3之前进行复杂的数据处理逻辑，跟其他对象的数据进行关联");
  19.         product.setField3("值3");  
  21.         // 上面是简化的一个逻辑，实际上对于一些有几十个字段，甚至是上百个字段的复杂对象的构建
  22.         // 上面那段代码会极度膨胀，非常复杂
  23.         // 一个是说，大量代码堆积在一起，维护性非常差，可读性非常差，一坨代码，跟屎一样，读不懂，没法改
  24.         // 另外一个，就是说，这段逻辑，如果在多个地方都有使用的话，一旦这段逻辑出现了一些变化，那么可能就需要
  25.         // 在多个地方修改这一大坨跟屎一样的代码
  26.         // 把不同的构造的步骤，抽取成某一个方法
  27.       }
  29.     public static class Product {
  31.         private String field1;
  32.         private String field2;
  33.         private String field3;
  35.         public String getField1() {
  36.             return field1;
  37.         }
  38.         public void setField1(String field1) {
  39.             this.field1 = field1;
  40.         }
  41.         public String getField2() {
  42.             return field2;
  43.         }
  44.         public void setField2(String field2) {
  45.             this.field2 = field2;
  46.         }
  47.         public String getField3() {
  48.             return field3;
  49.         }
  50.         public void setField3(String field3) {
  51.             this.field3 = field3;
  52.         }
  54.     }
  56. }

2.构造器模式

  1. package com.example.demo.pattern.builder;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class BuilderPatternDemo {
  8.     public static void main(String[] args) {
  9.         Director director = new Director(new ConcreteBuilder());  
  10.         Product product = director.build("值1", "值2", "值3");  
  11.         System.out.println(product);  
  13.         // 好处1：通过builder接口将复杂构建步骤拆分成了多个部分，代码逻辑清晰，维护性和扩展性都很好
  14.         // 好处2：将对象构建的过程，封装在了director里面，director来基于builder进行构建，构建逻辑修改，不需要修改很多地方
  15.         // 好处3：相对于工厂，有一个很好的抽象设计，director和builder
  16.     }
  18.     public static class Product {
  20.         private String field1;
  21.         private String field2;
  22.         private String field3;
  24.         public String getField1() {
  25.             return field1;
  26.         }
  27.         public void setField1(String field1) {
  28.             this.field1 = field1;
  29.         }
  30.         public String getField2() {
  31.             return field2;
  32.         }
  33.         public void setField2(String field2) {
  34.             this.field2 = field2;
  35.         }
  36.         public String getField3() {
  37.             return field3;
  38.         }
  39.         public void setField3(String field3) {
  40.             this.field3 = field3;
  41.         }
  43.         @Override
  44.         public String toString() {
  45.             return "Product [field1=" + field1 + ", field2=" + field2 + ", field3=" + field3 + "]";
  46.         }
  48.     }
  50.     public interface Builder {
  52.         void field1(String value);
  53.         void field2(String value);
  54.         void field3(String value);
  55.         Product create();
  57.     }
  59.     public static class ConcreteBuilder implements Builder {
  61.         private Product product = new Product();
  62.         @Override
  63.         public void field1(String value) {
  64.             System.out.println("在设置field1之前进行复杂的校验逻辑");  
  65.             product.setField1(value); 
  66.         }
  67.         @Override
  68.         public void field2(String value) {
  69.             System.out.println("在设置field2之前进行复杂的数据格式转化逻辑");  
  70.             product.setField2(value);
  71.         }
  72.         @Override
  73.         public void field3(String value) {
  74.             System.out.println("在设置field3之前进行复杂的数据处理逻辑，跟其他对象的数据进行关联");
  75.             product.setField3(value);  
  76.         }
  77.         @Override
  78.         public Product create() {
  79.             return product;
  80.         }
  82.     }
  84.     /**
  85.      * director是面向builder的接口，来编程的
  86.      * director可以复杂控制构建的一个步骤，具体的每个步骤的逻辑封装在具体的builder类中
  87.      * 如果我们此时要更换一整套的构建逻辑，可以再搞一个新的builder类就可以了
  88.      * 但是我们的整个构建步骤是没有任何改变的
  89.      * 
  90.      * 如果整个构建步骤变化了，但是对构建的逻辑是没有影响的
  91.      * 
  92.      * @author chenchao
  93.      *
  94.      */
  95.     public static class Director {
  97.         private Builder builder;
  99.         public Director(Builder builder) {
  100.             this.builder = builder;
  101.         }
  103.         public Product build(String field1, String field2, String field3) {
  104.             builder.field1(field1);
  105.             builder.field2(field2);
  106.             builder.field3(field3);  
  107.             return builder.create();
  108.         }
  110.     }
  112. }

3.升级 搭配工厂模式

  1. package com.example.demo.pattern.builder;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class OptimizedBuilderPatternDemo {
  8.     public static void main(String[] args) {
  9.         Product product = new ConcreteBuilder()
  10.                 .field1("值1")
  11.                 .field2("值2")
  12.                 .field3("值3")
  13.                 .create();
  14.         System.out.println(product);  
  16.         // 现在基本上流行的一些开源框架，构造器模式的运用，一般都是上面这种变种模式
  17.     }
  19.     public static class Product {
  21.         private String field1;
  22.         private String field2;
  23.         private String field3;
  25.         public String getField1() {
  26.             return field1;
  27.         }
  28.         public void setField1(String field1) {
  29.             this.field1 = field1;
  30.         }
  31.         public String getField2() {
  32.             return field2;
  33.         }
  34.         public void setField2(String field2) {
  35.             this.field2 = field2;
  36.         }
  37.         public String getField3() {
  38.             return field3;
  39.         }
  40.         public void setField3(String field3) {
  41.             this.field3 = field3;
  42.         }
  44.         @Override
  45.         public String toString() {
  46.             return "Product [field1=" + field1 + ", field2=" + field2 + ", field3=" + field3 + "]";
  47.         }
  49.     }
  51.     public interface Builder {
  53.         Builder field1(String value);
  54.         Builder field2(String value);
  55.         Builder field3(String value);
  56.         Product create();
  58.     }
  60.     public static class ConcreteBuilder implements Builder {
  62.         private Product product = new Product();
  64.         public Builder field1(String value) {
  65.             System.out.println("在设置field1之前进行复杂的校验逻辑");  
  66.             product.setField1(value); 
  67.             return this;
  68.         }
  70.         public Builder field2(String value) {
  71.             System.out.println("在设置field2之前进行复杂的数据格式转化逻辑");  
  72.             product.setField2(value);
  73.             return this;
  74.         }
  76.         public Builder field3(String value) {
  77.             System.out.println("在设置field3之前进行复杂的数据处理逻辑，跟其他对象的数据进行关联");
  78.             product.setField3(value);  
  79.             return this;
  80.         }
  82.         public Product create() {
  83.             return product;
  84.         }
  86.     }
  88. }

4.说明

构造器是一种非常棒，非常实用，非常常用的设计模式

常见于在构建一个复杂的对象，或者是构建一个复杂的表达式的时候，在开源框架中有大量广泛的运用

给大家举个例子，Mockito框架中，when().thenReturn()之类的，其实就是构造器模式的一种，通过多个连续的方法完成一个模拟对象的构建；还有就是spring test框架汇总，MvcMock对象，也是通过thenExpected()等多个连续的方法，完成一个mvc测试对象的构建。

用构造器模式的最大好处是啥？复杂对象的构建过程太复杂了，里面可能包含一些业务逻辑，比如值检查，格式转换之类的。如果每个客户端都自己手动去完成构建的话，那么大量的冗余代码是一个；另外一个，如果我们要改变对象的构建过程的实现，可以就在构造器中一个地方修改即可，对于调用方完全透明；最后，如果我们要完全替换掉以前的builder实现的话，那么完全可以在工厂里替换一个实现，还跟简单工厂模式结合起来使用了