常用设计模式系列（四）—建造者模式

2020-12-10 GOF设计模式, UML类图, 设计模式 0 Comments

一、前言

“山不在高，有仙则名。水不在深，有龙则灵。斯是陋室，惟吾德馨。苔痕上阶绿，草色入帘青。谈笑有鸿儒，往来无白丁。可以调素琴，阅金经。无丝竹之乱耳，无案牍之劳形。南阳诸葛庐，西蜀子云亭。孔子云：何陋之有？”

——《陋室铭》刘禹锡

唐代诗人刘禹锡使用短短八十一字，讲解了自己的志行高洁，安贫乐道，不与世俗同流合污的意趣。其巧妙的语言功底，使用简短的语言讲述了自己的故事，干练的词语将刘禹锡的文字水平体现的淋漓尽致。刘禹锡在那个时代的文学水平，使得当时的年轻人和后人都为之称赞。这不也是我们IT人的目标吗？我们每个IT人也都想用自己的青春时光+积极学习的心态，在这个世界上留下属于自己的辉煌，留下自己贡献青春的痕迹，也想让自己的技术能力受益于更多的新入行的朋友。我讲解设计模式的目的亦然如此，不仅仅是为了自己所学知识的总结，更是将自己所学知识整理出来给各位大佬参考，大家互相学习点评，也相信各位未来的代码、设计的项目能够渗透到生活的每一个角落，留下自己的在这个世界存在过的痕迹。

今天我们来讲解建造者模式，它和上一篇讲的抽象工厂模式，都属于创建型分类的对象模式的一种。同样是为了解决创建对象过程中的复杂场景。

二、建造者模式概念

创建者模式又叫建造者模式，是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

建造者模式的主要表现为：

使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

建造者（Builder）模式的主要角色如下：

1.产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
2.抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
3.具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法
4.指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

场景举例

一个大老板，使用自己继承的亿万遗产，一个汽车4S店，想要购买进购一批汽车，他通过朋友找到汽车厂商的大领导，说自己的需要500台车（具体产品），这个领导直接接待了这个大客户，说他亲自负责，然后这个领导（指挥者）把所有的产品线负责人拉过来说，说一个大客户需要500台车，需要在一个月内完成量产，每个流水线负责零件的生产。这个领导（指挥者）说：“到时候我亲自监工，每个零件的安装方式方法（抽象方法声明）由每个产品线负责人（抽象建造者）来负责贯彻，我会来指挥每个流水线（具体建造者）生产品并进行每个部件的安装，安装完成之后，产品线负责人（抽象建造者）把汽车交付（负责产品交付）给我，我给客户送去。”

这样的从客户购买到交付的过程，使用的模式就是建造者模式

UML图：

三、代码实现

1.编写产品类

package com.yang.builder;

/**
 * @ClassName Product
 * @Description 产品
 * @Author IT小白架构师之路
 * @Date 2020/12/10 20:14
 * @Version 1.0
 **/
public class Product {
    //轮子
    private String wheel;
    //车架
    private String frame;
    //座椅
    private String chair;

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getChair() {
        return chair;
    }

    public void setChair(String chair) {
        this.chair = chair;
    }

    public void run(){
        System.out.println("我有" + wheel + ",我有" + frame+ ",我还有" + chair + ",我是汽车，我能跑");
    }
}

2.编写抽象建造者

package com.yang.builder;

/**
 * @ClassName AbstractBuilder
 * @Description 抽象建造者
 * @Author IT小白架构师之路
 * @Date 2020/12/10 20:17
 * @Version 1.0
 **/
public abstract class AbstractBuilder {
    //内部的产品对象
    protected Product product = new Product();

    /**
     * 创建车轮的抽象方法
     */
    public abstract void createWheel();

    /**
     * 创建车架的抽象方法
     */
    public abstract void createFrame();

    /**
     * 创建座椅的抽象方法
     */
    public abstract void createChair();

    /**
     * 交付产品方法
     * @return
     */
    public Product getProduct() {
        return product;
    }
}

3.编写具体建造者A和具体建造者B

package com.yang.builder;

/**
 * @ClassName ConcreteBuilder
 * @Description 具体建造者
 * @Author IT小白架构师之路
 * @Date 2020/12/10 20:21
 * @Version 1.0
 **/
public class ConcreteBuilderA extends AbstractBuilder{
    @Override
    public void createWheel() {
        product.setWheel("轻便的车轮");
    }

    @Override
    public void createFrame() {
        product.setFrame("坚硬的车架");
    }

    @Override
    public void createChair() {
        product.setChair("舒适的座椅");
    }
}

package com.yang.builder;

/**
 * @ClassName ConcreteBuilder
 * @Description 具体建造者
 * @Author IT小白架构师之路
 * @Date 2020/12/10 20:21
 * @Version 1.0
 **/
public class ConcreteBuilderB extends AbstractBuilder{
    @Override
    public void createWheel() {
        product.setWheel("厚重的车轮");
    }

    @Override
    public void createFrame() {
        product.setFrame("普通的车架");
    }

    @Override
    public void createChair() {
        product.setChair("简约的座椅");
    }
}

4.编写指挥者

package com.yang.builder;

/**
 * @ClassName Director
 * @Description 指挥者
 * @Author IT小白架构师之路
 * @Date 2020/12/10 20:23
 * @Version 1.0
 **/
public class Director {
    //创建指挥者需要指定建造者
    private AbstractBuilder builder;
    //有参构造对象
    public Director(AbstractBuilder builder)
    {
        this.builder=builder;
    }

    /**
     * 指挥创建产品
     * @return
     */
    public Product createProduct(){
        builder.createWheel();
        builder.createFrame();
        builder.createChair();
        return builder.getProduct();
    }
}

5.编写客户端测试

package com.yang.builder;

/**
 * @ClassName Client
 * @Description 客户端
 * @Author IT小白架构师之路
 * @Date 2020/12/10 20:25
 * @Version 1.0
 **/
public class Client {
    public static void main(String[] args) {
        //生成建造者A
        AbstractBuilder builder = new ConcreteBuilderA();
        //生成指挥者，传入建造者A
        Director director = new Director(builder);
        //创建产品
        Product product = director.createProduct();
        product.run();
        //生成建造者A
        builder = new ConcreteBuilderB();
        //生成指挥者，传入建造者A
        director = new Director(builder);
        //创建产品
        product = director.createProduct();
        product.run();

    }
}

6.测试结果如下

1 2	我有轻便的车轮,我有坚硬的车架,我还有舒适的座椅,我是汽车，我能跑我有厚重的车轮,我有普通的车架,我还有简约的座椅,我是汽车，我能跑

代码实现可以看到，通过不同的具体建造者，我们可以生产出不同等级规格的产品，如果想要升级或者更换规格，可以通过更换具体建造者完成，建造者为核心，故为建造者模式

四、建造者模式优缺点分析及适用场景

优点：

1.使用建造者模式，客户可以不用关心产品内部的组成细节，将产品本身与产品的创建解耦，使得相同的创建过程可以创建不同的产品对象（使用多个具体产品建造者即可）。

2.每一个具体建造者可以做到独立，与其它建造者毫无关联，因此可以很方便的更换具体建造者或者增加新的具体建造者，用户使用具体建造者可以得到不同的产品对象。由于指挥类针对建造者做了编程实现，增加新的建造者无须修改原有类库的代码，系统扩展可以更加方便。

3.可以更加精细的控制产品的创建过程，将复杂的产品创建步骤分解在不同的方法中，使得产品创建过程更加清晰，也方便使用程序来控制创建过程。

缺点：

1.使用建造者创建的产品都是具有较多的共同点的，组成部分相似，如果需要新的差异性较大的产品，会不适合进行扩展。

2.如果产品的内部变化复杂，可能会定义许多具体建造者来完成这种变化，可能会导致系统越来越庞大，增加理解的难度和运行成本。

适用场景：

1.需要生成的产品对象具有复杂的内部结构，这些产品对象通常包括多个成员变量时。

2.需要生成的产品对象互相依赖，需要指定生成顺序（指挥者控制生成顺序）。

3.对象的创建过程独立于该创建对象的类，在建造者模式中引入指挥者类将创建过程封装在指挥者类中，而不在建造者类和客户类中场景。

4.隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

Java小白_Mr.Yang

Java 开发工程师