设计模式——建造者模式

大家好，欢迎来到IT知识分享网。

建造者模式

1.1 基本介绍

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

1.2 建造者模式中的四个角色

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

1.3 建房子案例

1.3.1 传统模式

代码演示：

public abstract class AbstractHouse { 
    public abstract void buildBasic(); public abstract void buildWalls(); public abstract void roofed(); public void build() { 
    buildBasic(); buildWalls(); roofed(); } } 

实现类

public class CommonHouse extends AbstractHouse{ 
    @Override public void buildBasic() { 
    System.out.println("普通房子打地基"); } @Override public void buildWalls() { 
    System.out.println("普通房子砌墙"); } @Override public void roofed() { 
    System.out.println("普通房子封顶"); } } public class HighBuilding extends AbstractHouse{ 
    @Override public void buildBasic() { 
    System.out.println("高楼打地基"); } @Override public void buildWalls() { 
    System.out.println("高楼砌墙"); } @Override public void roofed() { 
    System.out.println("高楼封顶"); } } 

Clinet 调用

public class Client { 
    public static void main(String[] args) { 
    CommonHouse commonHouse = new CommonHouse(); commonHouse.build(); } } 

问题：

1. 设计的程序结构，过于简单，没有设计缓存层对象，程序的扩展和维护不好.也就是说，这种设计方案，把产品(即:房子)和 创建产品的过程(即:建房子流程)封装在一起，耦合性增强了。
2. 解决方案:将产品和产品建造过程解耦=>建造者模式

1.3.2 建造者模式

1. 需要建房子:这一过程为打桩、砌墙、封顶。不管是普通房子也好，别墅也好都需要经历这些过程，下面我们使用建造者模式(Builder Patterm)来完成
2. 思路分析图解(类图)
   
   代码实现：
   
   

public class House { 
    private String basic; private String wall; private String roofed; public String getBasic() { 
    return basic; } public void setBasic(String basic) { 
    this.basic = basic; } public String getWall() { 
    return wall; } public void setWall(String wall) { 
    this.wall = wall; } public String getRoofed() { 
    return roofed; } public void setRoofed(String roofed) { 
    this.roofed = roofed; } } 

抽象建造者

public abstract class HouseBuilder { 
    protected House house = new House(); public abstract void buildBasic(); public abstract void buildWalls(); public abstract void roofed(); public House buildHouse() { 
    return house; } } 

具体建造者：

public class CommonHouse extends HouseBuilder { 
    @Override public void buildBasic() { 
    System.out.println("普通房子打地基"); } @Override public void buildWalls() { 
    System.out.println("普通房子砌墙"); } @Override public void roofed() { 
    System.out.println("普通房子封顶"); } } public class HighBuilding extends HouseBuilder { 
    @Override public void buildBasic() { 
    System.out.println("高楼打地基"); } @Override public void buildWalls() { 
    System.out.println("高楼砌墙"); } @Override public void roofed() { 
    System.out.println("高楼封顶"); } } 

指挥者：

public class HouseDirector { 
    HouseBuilder houseBuilder = null; public HouseDirector(HouseBuilder houseBuilder) { 
    this.houseBuilder = houseBuilder; } public void setHouseBuilder(HouseBuilder houseBuilder) { 
    this.houseBuilder = houseBuilder; } public House constructHouse(){ 
    houseBuilder.buildBasic(); houseBuilder.buildWalls(); houseBuilder.roofed(); return houseBuilder.buildHouse(); } } 

最后建造产品：

public class Client { 
    public static void main(String[] args) { 
    CommonHouse commonHouse = new CommonHouse(); HouseDirector houseDirector = new HouseDirector(commonHouse); houseDirector.constructHouse(); System.out.println("=================="); HighBuilding highBuilding = new HighBuilding(); houseDirector.setHouseBuilder(highBuilding); houseDirector.constructHouse(); } } 

打印结果:

普通房子打地基 普通房子砌墙 普通房子封顶 ================== 高楼打地基 高楼砌墙 高楼封顶 

1.4 拓展

假设现在有一个Computer类

public class Computer { 
    private String cpu; private String zhuban; private String ram; private String disk; public Computer(String cpu, String zhuban, String ram, String disk) { 
    this.cpu = cpu; this.zhuban = zhuban; this.ram = ram; this.disk = disk; } public String getCpu() { 
    return cpu; } public void setCpu(String cpu) { 
    this.cpu = cpu; } public String getZhuban() { 
    return zhuban; } public void setZhuban(String zhuban) { 
    this.zhuban = zhuban; } public String getRam() { 
    return ram; } public void setRam(String ram) { 
    this.ram = ram; } public String getDisk() { 
    return disk; } public void setDisk(String disk) { 
    this.disk = disk; } @Override public String toString() { 
    return "Computer{" + "cpu='" + cpu + '\'' + ", zhuban='" + zhuban + '\'' + ", ram='" + ram + '\'' + ", disk='" + disk + '\'' + '}'; } } 

每次创建都需要多个参数

public class Client { 
    public static void main(String[] args) { 
    Computer computer = new Computer("i5-12600kf", "华硕b760", "32g", "1TB"); System.out.println(computer); } } 

我们可以使用建造者模式优化一下：

public class Computer { 
    private String cpu; private String zhuban; private String ram; private String disk; public Computer(String cpu, String zhuban, String ram, String disk) { 
    this.cpu = cpu; this.zhuban = zhuban; this.ram = ram; this.disk = disk; } public String getCpu() { 
    return cpu; } public void setCpu(String cpu) { 
    this.cpu = cpu; } public String getZhuban() { 
    return zhuban; } public void setZhuban(String zhuban) { 
    this.zhuban = zhuban; } public String getRam() { 
    return ram; } public void setRam(String ram) { 
    this.ram = ram; } public String getDisk() { 
    return disk; } public void setDisk(String disk) { 
    this.disk = disk; } @Override public String toString() { 
    return "Computer{" + "cpu='" + cpu + '\'' + ", zhuban='" + zhuban + '\'' + ", ram='" + ram + '\'' + ", disk='" + disk + '\'' + '}'; } private Computer(Builder builder){ 
    this.cpu = builder.cpu; this.zhuban = builder.zhuban; this.ram = builder.ram; this.disk = builder.disk; } public static final class Builder{ 
    private String cpu; private String zhuban; private String ram; private String disk; public Builder cpu(String cpu){ 
    this.cpu = cpu; return this; } public Builder zhuban(String zhuban){ 
    this.zhuban = zhuban; return this; } public Builder ram(String ram){ 
    this.ram = ram; return this; } public Builder disk(String disk){ 
    this.disk = disk; return this; } public Computer build(){ 
    return new Computer(this); } } } 

创建方式：

public class Client { 
    public static void main(String[] args) { 
    Computer computer = new Computer.Builder().cpu("i5-12600kf").zhuban("华硕b760").ram("32g").disk("1TB").build(); System.out.println(computer); } } 

1.5 优缺点

• 优点：
  • 建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
  • 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
  • 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
  • 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则。
• 缺点：
  • 造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大、则不适合使用建造者模式，因此其使用范围受到一定的限制。

1.6 工厂方法模式VS建造者模式

工厂方法模式注重的是整体对象的创建方式；而建造者模式注重的是部件构建的过程，意在通过一步一步地精确构造创建出一个复杂的对象。我们举个简单例子来说明两者的差异，如要制造一个超人，如果使用工厂方法模式，直接产生出来的就是一个力大无穷、能够飞翔、内裤外穿的超人；而如果使用建造者模式，则需要组装手、头、脚、躯干等部分，然后再把内裤外穿，于是一个超人就诞生了。

1.7 抽象工厂模式VS建造者模式