Java设计模式：建造者模式

在日常开发中，如果遇到日常需求为：
①需要建房子：过程为打地基、砌墙、封顶；
②能够实现不同类型房子对建造过程的复用。

那么我们应该如何实现这个需求呢？首先我们先画出UML的关系图如下：

以一个抽象类作为父类，抽象的声明建造房子的方法，具体实现类则作为子类来实现抽象类，Client类则负责创建。

//抽象父类
public abstract class AbstractBuilding {
    public abstract void base();
    public abstract void wall();
    public abstract void roof();
    public void build(){
        base();
        wall();
        roof();
    }
}

//具体实现类
public class CommonBuilding extends AbstractBuilding{
    @Override
    public void base() {
        System.out.println("普楼打地基");
    }
    @Override
    public void wall() {
        System.out.println("普楼砌墙");
    }
    @Override
    public void roof() {
        System.out.println("普楼封顶");
    }
}

//具体实现类
public class HighBuilding extends AbstractBuilding{
    @Override
    public void base() {
        System.out.println("高楼打地基");
    }
    @Override
    public void wall() {
        System.out.println("高楼砌墙");
    }
    @Override
    public void roof() {
        System.out.println("高楼封顶");
    }
}

public class Client {
    public static void main(String[] args) {
        CommonBuilding commonBuilding = new CommonBuilding();
        commonBuilding.build();
        HighBuilding highBuilding = new HighBuilding();
        highBuilding.build();
    }
}

这种写法的有点是简单易懂，可是这种程序结构简单，扩展与维护起来较困难，耦合性比较强。
于是我们使用建造者模式替代。

对建造者模式的基本介绍：

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

建造者模式的四个角色：

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

UML关系图如下：

Building是产品，将其封装为一个Bean

public class Building {
    private String base;
    private String wall;
    private String roof;
    public String getBase() {
        return base;
    }
    public void setBase(String base) {
        this.base = base;
    }
    public String getWall() {
        return wall;
    }
    public void setWall(String wall) {
        this.wall = wall;
    }
    public String getRoof() {
        return roof;
    }
    public void setRoof(String roof) {
        this.roof = roof;
    }
}

Builder类作为抽象类，内部声明产品与抽象方法：

//抽象的建造者
public abstract class Builder {
    protected Building building = new Building();
    //抽象建造的流程
    public abstract void baseBuild();
    public abstract void wallBuild();
    public abstract void roofBuild();
    //返回房子
    public Building getBuilding(){
        return building;
    }
}

CommonBuilding类作为具体实现类，继承Builder父类，实现抽象父类的方法（同为实现类的HighBuilding写法一致，这里省略）:

public class CommonBuilding extends Builder{
    @Override
    public void baseBuild() {
        System.out.println("普楼打地基——小型");
    }
    @Override
    public void wallBuild() {
        System.out.println("普楼砌墙——小型");
    }
    @Override
    public void roofBuild() {
        System.out.println("普楼封顶——小型");
    }
}

建造指挥官，通过传入Builder对象，调用对象实现具体方法，仅仅负责实现建造的步骤，不关心建造的具体实现，返回最终产品：

public class BuildingDirector {
    Builder builder = null;
    //构造器传入
    public BuildingDirector(Builder builder){
        this.builder = builder;
    }
    //setter方法传入
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }
    //指挥者负责建造的过程管控
    public Building constructBuilding(){
        builder.baseBuild();
        builder.wallBuild();
        builder.roofBuild();
        return builder.getBuilding();
    }
}

客户端调用：

public class Client {
    public static void main(String[] args) {
        CommonBuilding commonBuilding = new CommonBuilding();
        BuildingDirector buildingDirector = new BuildingDirector(commonBuilding);
        //产品房子
        Building building = buildingDirector.constructBuilding();
    }
}

总结

掌握建造者模式需要记住建造者模式的四个角色，每个角色有每个角色负责的内容，达到解耦的实际效果。