死磕设计模式—建造者模式

前言（八问知识体系）

1.1.简介

什么是建造模式？
- 1.将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
- 2.建造者模式是一步一步创建一个复杂的对象，建造者模式注重的是一步一步的创建复杂对象。这个和工厂模式存在区别
建造模式的优缺点？
- 优点
  - 1.将产品本身和其创建过程解耦，用户不需要知道内部组成的细节
  - 2.具体的建造者完全独立，使用不同的具体建造者生产不同的对象
  - 3.增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”
- 缺点
  - 1.建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式
  - 2.如果产品内部变化很复杂，则需要大量的具体建造者，会导致系统更加庞大

1.2.类图

1.3.代码示例

抽象的产品建造流程

 1 public interface IBuilder {
 2 
 3     /**
 4      * buildPart1
 5      *
 6      * @description 建造产品的第一部分
 7      * @author luokangyuan
 8      * @date 2019/10/27 17:15
 9      * @version 1.0.0
10      */
11     void buildPart1();
12 
13     /**
14      * buildPart2
15      *
16      * @description 建造产品的第二部分
17      * @author luokangyuan
18      * @date 2019/10/27 17:15
19      * @version 1.0.0
20      */
21     void buildPart2();
22 
23     /**
24      * buildPart3
25      *
26      * @description 建造产品的第三部分
27      * @author luokangyuan
28      * @date 2019/10/27 17:15
29      * @version 1.0.0
30      */
31     void buildPart3();
32 
33     /**
34      * build
35      *
36      * @description 得到产品
37      * @return 产品
38      * @author luokangyuan
39      * @date 2019/10/27 17:16
40      * @version 1.0.0
41      */
42     Product build();

具体的建造者

 1 public class TruckConcreateBuilder implements IBuilder{
 2 
 3     private Product product = new Product();
 4     @Override
 5     public void buildPart1() {
 6         product.setPart1("货车轮胎完成");
 7     }
 8 
 9     @Override
10     public void buildPart2() {
11         product.setPart2("货车发动机完成");
12     }
13 
14     @Override
15     public void buildPart3() {
16         product.setPart3("货车车架完成");
17     }
18 
19     @Override
20     public Product build() {
21         return product;
22     }
23 }
24 public class ConcreteBuilder implements IBuilder {
25     private Product product = new Product();
26 
27     @Override
28     public void buildPart1() {
29         product.setPart1("轮胎完成");
30     }
31 
32     @Override
33     public void buildPart2() {
34         product.setPart2("发动机完成");
35     }
36 
37     @Override
38     public void buildPart3() {
39         product.setPart3("车架完成");
40     }
41 
42     @Override
43     public Product build() {
44         return product;
45     }
46 }

指挥者

 1 @AllArgsConstructor
 2 @Data
 3 public class Conductor {
 4 
 5     private IBuilder builder;
 6 
 7     /**
 8      * construct
 9      *
10      * @description 指挥者负责产品的创建流程
11      * @return 产品
12      * @author luokangyuan
13      * @date 2019/10/27 19:13
14      * @version 1.0.0
15      */
16     public Product construct() {
17         builder.buildPart1();
18         builder.buildPart2();
19         builder.buildPart3();
20         return builder.build();
21     }
22 }

产品

 1 @Data
 2 public class Product {
 3 
 4     /* 组成产品的第一部分*/
 5     private String part1;
 6 
 7     /* 组成产品的第一部分*/
 8     private String part2;
 9 
10     /* 组成产品的第一部分*/
11     private String part3;
12 }

客户端调用

1 public static void main(String[] args) {
2     IBuilder builder = new ConcreteBuilder();
3     Conductor conductor = new Conductor(builder);
4     Product product = conductor.construct();
5     log.info("产品信息：{},{},{}", product.getPart1(), product.getPart2(),product.getPart3());
6     conductor.setBuilder(new TruckConcreateBuilder());
7     Product truck = conductor.construct();
8     log.info("产品信息：{},{},{}", truck.getPart1(), truck.getPart2(), truck.getPart3());
9 }

实例详细类图

1.4.总结和应用场景

需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
需要生成的产品对象的属性相互依赖，需要指定其生成顺序
隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品
典型的lombok中的@Builder注解
游戏人物的角色可以使用建造者模式，都有服装，技能，装备等共同属性
JDK中的StringBuilder使用了建造者模式
- 1.Appendable接口定义了append抽象方法，就是一个抽象的建造者
- 2.AbstractStringBuilder实现了Appendable，就是一个具体的建造者，但是不能实例化
- 3.StringBuilder继承了AbstractStringBuilder，相当于一个具体建造者角色，同时还是一个指挥者角色

转载于：http://luokangyuan.com/si-ke-she-ji-mo-shi-jian-zao-zhe-mo-shi/