设计模式--建造者模式详解

建造者模式

• 建造者模式也属于创建型模式，它提供了一种创建对象的最佳方式
  
• 定义：将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建差别的表示（假设有差别的建造者实现类，可以产生差别的产物）
  
• 重要作用：在用户不知道对象的创建过程和细节的环境下（用户只须要调指挥者来创建就可以了）就可以直接创建复杂的对象。
  
• 用户只须要给出指定复杂对象的类型和内容，建造者负责按顺序创建复杂对象（把内部的建造过程和细节隐蔽起来）
  
• 例子：
  
  
  
  • 工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）
    
  • 汽车购买者（用户）：你只要说出你须要的型号（对象的类型与内容），然后可以直接购买就可以使用了（固然不知道汽车怎么组装的（车轮、车门、发动机、方向盘等等））
    
  
  

• 脚色分析：
  

• 既然是建造者模式，那么我们照旧继续就以造房子为例子，假设将造房简化为以下步调：
  
  
  
  • 地基
    
  • 钢筋工程
    
  • 铺电线
    
  • 粉刷
    
  
  

假如要盖一间房子，首先是要一个建筑公司或工程承包商（指挥者），承包商指挥工人（具体建造者）来造房子（产物），最后验收
代码展示：
首先先创建抽象建造者

1. package com.lyc.builder.demo01;
2. //抽象的建造者，只负责定义一些接口与方法
3. public abstract class Builder {
4.     public abstract void buildPartA();
5.     public abstract void buildPartB();
6.     public abstract void buildPartC();
7.     public abstract void buildPartD();
8.     //完工：得到产品
9.     public abstract Product getResult();
10. }

复制代码

再创建产物类

1. package com.lyc.builder.demo01;
3. import lombok.Data;
5. //产品：房子
6. @Data
7. public class Product {
8.     private String partA;
9.     private String partB;
10.     private String partC;
11.     private String partD;
12. }

复制代码

再创建具体建造者实现类

1. package com.lyc.builder.demo01;
2. //具体的建造者 worker是builder的具体实现，一个builder可能有几个不同的worker
3. public class Worker extends Builder{
4.     private Product product;
5.     public Worker(){
6.         product = new Product();
7.     }
8.     @Override
9.     public void buildPartA() {
10.         product.setPartA("partA");
11.         System.out.println("partA");
12.     }
14.     @Override
15.     public void buildPartB() {
16.         product.setPartB("partB");
17.         System.out.println("partB");
18.     }
20.     @Override
21.     public void buildPartC() {
22.         product.setPartC("partC");
23.         System.out.println("partC");
24.     }
26.     @Override
27.     public void buildPartD() {
28.         product.setPartD("partD");
29.         System.out.println("partD");
30.     }
32.     @Override
33.     public Product getResult() {
34.         return product;
35.     }
36. }

复制代码

在创建指挥类Director

1. package com.lyc.builder.demo01;
2. //指挥者 核心，负责指挥构建一个工程，工程如何构建，有他决定
3. public class Director {
4.     //指挥工人按照顺序建造房子
5.     public Product builder(Builder builder){
6.         //指挥者可以指挥工人按照不同的顺序执行方法，
7.         builder.buildPartA();
8.         builder.buildPartB();
9.         builder.buildPartC();
10.         builder.buildPartD();
11.         //返回产品
12.         return builder.getResult();
13.     }
14. }

复制代码

最后进行测试

1. public class Test {
2.     public static void main(String[] args) {
3.         //指挥
4.         Director director = new Director();
5.         Product builder = director.builder(new Worker());
6.         System.out.println(builder.toString());
7.     }
8. }

复制代码

细节分析：

• 上面示例是Builder模式的常规用法，导演Director在Builder模式中具有重要的作用，它用于指导具体构建者怎样构建产物，控制调用先后序次，并向调用者返回完整的产物类，但是有些环境下须要简化系统布局，可以把Director与抽象建造者进行结合
  
• 通过静态内部类方式实现零件无序装配构造，这种方式使用更加灵活，更符合定义，内部有复杂对象的默认实现，使用时可以根据用户需求自由定义更改内容，并且无需改变具体的构造方式。就可以生产出差别复杂的产物
  
• 比如：汉堡套餐，服务员（具体建造者）可以随意搭配任意几种产物组成一款套餐（产物），比第一种少了Director，重要是因为第二种方式把指挥者交给用户操作，使得产物创建更加简单灵活
  

第二种方式代码展示：
首先照旧须要创建抽象建造类

1. public abstract class Builder {
2.     public abstract Builder buildPartA(String msg); //汉堡
3.     public abstract Builder buildPartB(String msg); //可乐
4.     public abstract Builder buildPartC(String msg); //薯条
5.     public abstract Builder buildPartD(String msg); //甜品
6.    // 返回产品
7.     public abstract Product getResult();
8. }

复制代码

创建产物类（这里存放着默认的产物）

1. import lombok.Data;
3. //产品：套餐
4. @Data
5. public class Product {
6.     //默认套餐
7.     private String partA = "汉堡";
8.     private String partB = "可乐";
9.     private String partC = "薯条";
10.     private String partD = "甜点";
11. }

复制代码

具体的创建者实现类

1. package com.lyc.builder.demo02;
2. //具体建造者
3. public class Worker extends Builder{
4.     private Product product;
5.     public Worker(){
6.         product = new Product();
7.     }
8.     @Override
9.     public Builder buildPartA(String msg) {
10.         product.setPartA(msg);
11.         return this;
12.     }
14.     @Override
15.     public Builder buildPartB(String msg) {
16.         product.setPartB(msg);
17.         return this;
18.     }
20.     @Override
21.     public Builder buildPartC(String msg) {
22.         product.setPartC(msg);
23.         return this;
24.     }
26.     @Override
27.     public Builder buildPartD(String msg) {
28.         product.setPartD(msg);
29.         return this;
30.     }
32.     @Override
33.     public Product getResult() {
34.         return product;
35.     }
36. }

复制代码

最后进行测试

1. package com.lyc.builder.demo02;
3. public class Test {
4.     public static void main(String[] args) {
5.         //服务员
6.         Worker worker = new Worker();
7.         //链式编程 :在原来的基础上，可以自由组合，如果不组合，也有默认的套餐
8.         Product result = worker.buildPartA("全家桶").buildPartB("雪碧")
9.                 .getResult();
10.         System.out.println(result.toString());
11.     }
12. }

复制代码

这里将指挥者与客户端相结合，让客户端自己来进行套餐的搭配。
建造者模式与工厂模式的区别：
工厂模式是造什么，建造者模式是怎么造，一个宏观，一个微观
建造者模式优点：

• 产物的建造与表示分离，实现了解耦，使用建造者模式可以使客户端不必知道产物内部组成的细节。
  
• 将复杂的产物的创建步调分解在差别的方法中，使得创建过程更加清楚
  
• 具体的建造者类之间是相互独立的，这有利于系统的扩展，增长新的具体建造者无需修改原有类库的代码，符合“开闭原则”。
  

缺点：

• 建造者模式所创建的产物一样平常具有较多的共同点，其组成部分相似；假如产物之间的差异性很大，则不得当使用创造者模式，因此其适用范围受到了一定的限定。
  
• 假如产物的内部变革复杂，可能会导致须要定义许多具体建造者来实现这种变革，导致系统变得很巨大
  

应用场景：

• 须要天生的产物对象有复杂的内部布局，这些产物对象具备共性；
  
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建差别的产物。
  
• 得当于一个具有较多的零件（属性）的产物（对象）的创建过程。
  

建造者与抽象工厂模式的比力：

• 与抽象工厂模式相比，建造者模式返回一个组装好的完整产物，而抽象工厂模式返回一系列相关的产物，这些产物位于差别的产物等级布局，构成了一个产物族。
  
• 在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产物对象，抽象工厂模式偏重于直接通过工厂制造获得对象 而在建造者模式中客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导怎样天生对象，包括对象的组装过程和建造步调，它偏重于一步步构造一个复杂对象，返回一个完整的对象。
  
• 假如将抽象工厂模式看成汽车配件生产工厂，生产一个产物族的产物，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车!
  

我们须要清楚的认识到工厂模式与创建者模式的区别，并且勤加练习，盼望对各人有所帮助

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。