设计模式（六）建造者模式

概念

建造者模式是一种较为复杂的创建型模式,它将客户端与包含多个组成部分的复杂对象的创建过程分离,客户端无须知道复杂对象的内部组成部分与装配方式,只需要知道所需建造者的类型即可。建造者模式关注如何一步一步地创建一个复杂对象，不同的具体建造者定义了不同的创建过程,而且具体建造者相互独立，更换建造者或增加新的建造者非常方便,系统具有较好的扩展性。

实现方式

建造者模式的组成

抽象构建者(Builder): 它为创建一个复杂对象中各个属性指定抽象接口，用于创建复杂对象的各个属性。抽象返回创建完成的复杂对象方法。Builder可以是抽象类，也可以是接口。

具体建造者(ConcreteBuilder): 它实现 Builder 接口，实现各个属性的具体构造和装配方法，定义并明确所创建的复杂对象，还可以提供一个方法返回创建好的复杂对象。

构建的产品对象(Product): 它是被构建的复杂对象，包含多个属性，具体建造者创建该对象的内部实现并定义它的装配过程。

指挥者(Director): 指挥者类，他负责安排复杂对象的建造顺序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法调用建造者对象的属性构建与装配方法，完成复杂对象的建造。

实例

下面我们就用建造者模式来描述一个简单的客厅装修。

被构建的产品对象

/**
 * 客厅
 *
 * @author yuxuan
 * @version 1.0
 * @Date 2021/8/29 19:18
 **/
public class Parlour {

    /**
     * 墙
     */
    private String wall;

    /**
     * 地面瓷砖
     */
    private String floorTile;

    /**
     * 沙发
     */
    private String sofa;

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getFloorTile() {
        return floorTile;
    }

    public void setFloorTile(String floorTile) {
        this.floorTile = floorTile;
    }

    public String getSofa() {
        return sofa;
    }

    public void setSofa(String sofa) {
        this.sofa = sofa;
    }

    @Override
    public String toString() {
        return "Parlour{" +
                "wall='" + wall + '\'' +
                ", floorTile='" + floorTile + '\'' +
                ", sofa='" + sofa + '\'' +
                '}';
    }
}

抽象建造者和具体建造者

/**
 * 抽象建造者
 **/
public abstract class Builder {

    protected Parlour parlour = new Parlour();

    public abstract void buildWall();
    public abstract void buildFloorTile();
    public abstract void buildSofa();

    public Parlour getResult(){
        return parlour;
    }
}

/**
 * 具体建造者
 * 装修师傅 A
 **/
public class BuilderImplA extends Builder {
    @Override
    public void buildWall() {
        parlour.setWall("纯白色的墙面");
    }

    @Override
    public void buildFloorTile() {
        parlour.setFloorTile("格子花纹瓷砖");
    }

    @Override
    public void buildSofa() {
        parlour.setSofa("真皮沙发");
    }
}

/**
 * 具体建造者
 * 装修师傅 B
 **/
public class BuilderImplB extends Builder {
    @Override
    public void buildWall() {
        parlour.setWall("天蓝色的墙面");
    }

    @Override
    public void buildFloorTile() {
        parlour.setFloorTile("咖啡色条纹木质瓷砖");
    }

    @Override
    public void buildSofa() {
        parlour.setSofa("纯棉沙发");
    }
}

指挥者

/**
 * 指挥者
 * 项目经理
 **/
public class Direcotr {

    private Builder builder;

    public void setBuilder(Builder builder) {
        this.builder = builder;
    }


    public Parlour construct(){
        builder.buildWall();
        builder.buildFloorTile();
        builder.buildSofa();
        return builder.getResult();
    }


}

Client


public class Client {

    public static void main(String[] args) {
        Builder builderA = new BuilderImplA();
        Builder builderB = new BuilderImplB();

        Direcotr direcotr = new Direcotr();
        direcotr.setBuilder(builderA);
        Parlour constructA = direcotr.construct();

        direcotr.setBuilder(builderB);
        Parlour constructB = direcotr.construct();

        System.out.println(constructA);
        System.out.println(constructB);

    }

实现类图大致如下

image.png

总结

建造者模式主要用于创建一些复杂的对象，这些对象内部的建造顺序通常是稳定的，但对象内部的构建通常面临复杂的变化。建造者模式的好处就是使得构造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

与其他模式的区别

简单工厂模式：又叫静态工厂方法模式，它定义一个具体的工厂类，通过用静态方法来负责创建一些类的实例。也就是说，这个类集合了部分功能的类似或近似类的实例化，但工厂类无法被继承（只有一个工厂类，通过该类中静态方法来创建产品类的对象，随着产品类的增多，该静态方法也越来越复杂和难以维护）。
工厂方法模式：通过一个工厂类来完成对象的实例化。工厂模式在调用的时候需要先实例化工厂类。根据不同的产品创建不同的工厂类来返回实例。
抽象工厂模式：它分为抽象工厂类、抽象产品类、具体产品类。和工厂模式差不多，区别就是抽象工厂模式把一系列的产品进行统一。抽象工厂模式中，我们会把一系列相似的产品放在一个工厂类里面实例化，和现在车间的流水线差不多，一个流水线负责生产相似的产品，不同的产品需要另一条流水线来生产。工厂模式是针对细微的产品来创建工厂类。
建造者模式：强调的是控制产品的生产过程，使不同的产品生产可以使用相同的步骤。