是什么？

建造者模式是一步一步创建一个复杂的对象，形如Builder.builder.a().b().c().build();它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。
构建者模式提供了一种极佳的复杂对象的创建方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

适用场景？

复杂对象的创建场景
一个复杂对象由多个零部件构成，用户只需一步一步安装零部件即可

代码实现

简单对象演示

假设一个产品对象Product只有一个属性name产品名称，其构建者模式如下：

  1. /**
  2.  * 简单对象-产品类
  3.  * 只有一个属性：产品名称
  4.  * 
  5.  * 演示构建者模式
  6.  */
  7. public class Product {
  8.        //产品名称
  9.     private String name;
  11.     //全参构造函数
  12.     public Product(String name) {
  13.         this.name = name;
  14.     }
  16.     //获取构建者
  17.     public static ProductBuilder builder(){
  18.         return new ProductBuilder();
  19.     }
  21.     //产品构造器提供者
  22.     static class ProductBuilder{
  23.         //复制Product的所有属性，作为暂存备份，构建对象时线程安全
  24.         //产品名称
  25.         private String name;
  27.         public ProductBuilder name(String name){
  28.             this.name=name;
  29.             return  this;
  30.         }
  32.         //构建对象方法
  33.         public Product build(){
  34.             //一次性new对象，保证线程安全
  35.             return new Product(name);
  36.         }
  38.     }
  40. }

使用非常简单方便

  1. Product.builder().name("产品名称").build();

复杂对象演示

复杂对象才能体现构建者模式的价值，
假设一个复杂的产品，由多个部件组成，使用构建者模式创建该产品的过程如下：

  1. //定义产品
  2. /**
  3.  * 复杂产品由多个部分组成
  4.  * PartA A部分
  5.  * PartB B部分
  6.  * 等等
  7.  */
  8. public class Product {
  9.     private Integer id;//产品唯一标识
  10.     private String name;//产品名称
  11.     private PartA partA;//零部件A
  12.     private PartB partB;//零部件B
  14.     static class PartA {
  15.         private String name;//零部件A的名称
  16.     }
  18.     static class PartB {
  19.         private Integer id;//零部件B的唯一标识
  20.         private String name;//零部件B的名称
  21.         private PartA partA;//零部件A
  22.     }
  24. }

构造者模式创建如上复杂产品对象，为产品Product创建构建者模式类

  1. /构造类对象
  2.     public static class ProductBuilder {
  3.         //冗余对象，保证创建对象得线程安全
  4.         private Integer id;
  5.         private String name;
  6.         private PartA partA;
  7.         private PartB partB;
  9.         ProductBuilder() {
  10.         }
  12.         public ProductBuilder id(final Integer id) {
  13.             this.id = id;
  14.             return this;
  15.         }
  17.         public ProductBuilder name(final String name) {
  18.             this.name = name;
  19.             return this;
  20.         }
  22.         public ProductBuilder partA(final PartA partA) {
  23.             this.partA = partA;
  24.             return this;
  25.         }
  27.         public ProductBuilder partB(final PartB partB) {
  28.             this.partB = partB;
  29.             return this;
  30.         }
  32.         public Product build() {
  33.             return new Product(this.id, this.name, this.partA, this.partB);
  34.         }
  36.     }

同理给PartA和PartB创建构造者模式类

  1. public static class PartABuilder {
  2.     private String name;
  4.     PartABuilder() {
  5.     }
  7.     public PartA.PartABuilder name(final String name) {
  8.         this.name = name;
  9.         return this;
  10.     }
  12.     public PartA build() {
  13.         return new PartA(this.name);
  14.     }
  16. }
  20. public static class PartBBuilder {
  21.     private Integer id;
  22.     private String name;
  23.     private PartA partA;
  25.     PartBBuilder() {
  26.     }
  28.     public PartB.PartBBuilder id(final Integer id) {
  29.         this.id = id;
  30.         return this;
  31.     }
  33.     public PartB.PartBBuilder name(final String name) {
  34.         this.name = name;
  35.         return this;
  36.     }
  38.     public PartB.PartBBuilder partA(final PartA partA) {
  39.         this.partA = partA;
  40.         return this;
  41.     }
  43.     public PartB build() {
  44.         return new PartB(this.id, this.name, this.partA);
  45.     }
  47. }

类全貌如下：

  1. /**
  2.  * 复杂产品由多个部分组成
  3.  * PartA A部分
  4.  * PartB B部分
  5.  * 等等
  6.  */
  7. public class Product {
  8.     private Integer id;//产品唯一标识
  9.     private String name;//产品名称
  10.     private PartA partA;//产品A部件
  11.     private PartB partB;//产品B部件
  13.     //全参构造方法
  14.     Product(final Integer id, final String name, final PartA partA, final PartB partB) {
  15.         this.id = id;
  16.         this.name = name;
  17.         this.partA = partA;
  18.         this.partB = partB;
  19.     }
  21.     //构造方法
  22.     public static ProductBuilder builder() {
  23.         return new ProductBuilder();
  24.     }
  26.     //构造类对象
  27.     public static class ProductBuilder {
  28.         //冗余对象，保证创建对象得线程安全
  29.         private Integer id;
  30.         private String name;
  31.         private PartA partA;
  32.         private PartB partB;
  34.         ProductBuilder() {
  35.         }
  37.         public ProductBuilder id(final Integer id) {
  38.             this.id = id;
  39.             return this;
  40.         }
  42.         public ProductBuilder name(final String name) {
  43.             this.name = name;
  44.             return this;
  45.         }
  47.         public ProductBuilder partA(final PartA partA) {
  48.             this.partA = partA;
  49.             return this;
  50.         }
  52.         public ProductBuilder partB(final PartB partB) {
  53.             this.partB = partB;
  54.             return this;
  55.         }
  57.         public Product build() {
  58.             return new Product(this.id, this.name, this.partA, this.partB);
  59.         }
  61.     }
  63.     private static class PartA {
  64.         private String name;
  66.         PartA(final String name) {
  67.             this.name = name;
  68.         }
  70.         public static PartA.PartABuilder builder() {
  71.             return new PartA.PartABuilder();
  72.         }
  74.         public static class PartABuilder {
  75.             private String name;
  77.             PartABuilder() {
  78.             }
  80.             public PartA.PartABuilder name(final String name) {
  81.                 this.name = name;
  82.                 return this;
  83.             }
  85.             public PartA build() {
  86.                 return new PartA(this.name);
  87.             }
  89.         }
  90.     }
  92.     private static class PartB {
  93.         private Integer id;
  94.         private String name;
  95.         private PartA partA;
  97.         PartB(final Integer id, final String name, final PartA partA) {
  98.             this.id = id;
  99.             this.name = name;
  100.             this.partA = partA;
  101.         }
  103.         public static PartB.PartBBuilder builder() {
  104.             return new PartB.PartBBuilder();
  105.         }
  107.         public static class PartBBuilder {
  108.             private Integer id;
  109.             private String name;
  110.             private PartA partA;
  112.             PartBBuilder() {
  113.             }
  115.             public PartB.PartBBuilder id(final Integer id) {
  116.                 this.id = id;
  117.                 return this;
  118.             }
  120.             public PartB.PartBBuilder name(final String name) {
  121.                 this.name = name;
  122.                 return this;
  123.             }
  125.             public PartB.PartBBuilder partA(final PartA partA) {
  126.                 this.partA = partA;
  127.                 return this;
  128.             }
  130.             public PartB build() {
  131.                 return new PartB(this.id, this.name, this.partA);
  132.             }
  134.         }
  135.     }
  137. }

测试代码，构建者模式创建对象：

  1. Product build = Product.builder()
  2.                 .id(1)
  3.                 .name("测试产品")
  4.                 .partA(
  5.                         PartA
  6.                             .builder()
  7.                             .name("零部件A")
  8.                             .build()
  9.                 )
  10.                 .partB(
  11.                         PartB
  12.                             .builder()
  13.                             .id(1)
  14.                             .name("测试产品")
  15.                             .partA(
  16.                                     PartA
  17.                                         .builder()
  18.                                         .name("零部件A")
  19.                                         .build()
  20.                             )
  21.                             .build()
  23.                 )
  24.                 .build();