学习笔记：设计模式之建造者模式

建造房子需求：
过程为打桩、砌墙、封顶三步，房子有各种各样的，比如普通房，高楼，别墅，各种房子的过程虽然一样，但是每个房子的要求不一样。

1.传统方法

public abstract class AbstractHouse {
    public abstract void buildBase(); //打地基
    public abstract void buildWall(); //砌墙
    public abstract void buildRoof(); //封顶
}

public class House extends AbstractHouse{
    @Override
    public void buildBase() {
        System.out.println("房子要打10米深的地基！");
    }
    @Override
    public void buildWall() {
        System.out.println("房子要砌20厘米厚的墙！");
    }
    @Override
    public void buildRoof() {
        System.out.println("房子要封装玻璃屋顶！");
    }
    public void build(){ //这里体现了各个步骤之间的顺序
        buildBase();
        buildWall();
        buildRoof();
    }
}

通过调用House类中的build()方法，执行结果为：

房子要打10米深的地基！
房子要砌20厘米厚的墙！
房子要封装玻璃屋顶！

注：这里只展示了其中一种类型房子的实现，其它的实现方式与上述非常相似，故在这里不再赘述。

评价

设计的程序结构，过于简单，没有设计缓存层对象，把房子和创建房子的过程封装在一起，耦合性增强了，使得程序的扩展和维护性不好。

2.建造者模式

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

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

Product部分：

创建产品的JavaBean类

public class House{
    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;
    }
    @Override
    public String toString() {
        return "House [base=" + base + ", wall=" + wall + ", roof=" + roof + "]";
    }
}

Builder部分：

创建生产产品各个过程的抽象方法

public abstract class Builder {
    public abstract void buildBase();//打地基
    public abstract void buildWall();//砌墙
    public abstract void buildRoof();//封顶
    public abstract House createHouse();
}

ConcreteBuilder部分：

继承并实现Builder中的抽象方法，具体的完成每一步的真正操作（不同的产品就是在这里不同的），并且将产生的结果封装到创建的House类型的实例中，并且创造开放方法来返回该实例，使得外部可以获得该实例。

public class CommonHouseBuilder extends Builder{  //这里的CommonHouseBuilder扮演的就是ConcreteBuilder 
    private House commonHouse = new House();
    @Override
    public void buildBase() {
        System.out.println("普通房屋要打10米深的地基！");
        commonHouse.setBase("10米深的地基");
    }
    @Override
    public void buildWall() {
        System.out.println("普通房屋要砌20厘米厚的墙！");
        commonHouse.setWall("20厘米厚的墙");
    }
    @Override
    public void buildRoof() {
        System.out.println("普通房屋要封装水泥屋顶！");
        commonHouse.setRoof("水泥屋顶");
    }
    @Override
    public House createHouse() {
        return commonHouse;
    }
}

Director部分：

通过传入的Builder类型实例来调用其中的方法，在该类中可以控制产品中不同步骤之间的执行顺序。

public class Director {
    private Builder builder = null;
    public Director(Builder builder){
        this.builder = builder;
    }
    public House construct(){
        builder.buildBase();
        builder.buildWall();
        builder.buildRoof();
        return builder.createHouse();
    }
}

测试部分：

public class Test {
    public static void main(String[] args){
        Director director = new Director(new CommonHouseBuilder());
        House commonHouse = director.construct();
        System.out.println(commonHouse);
    }
}

输出结果：

普通房屋要打10米深的地基！
普通房屋要砌20厘米厚的墙！
普通房屋要封装水泥屋顶！
House [base=10米深的地基, wall=20厘米厚的墙, roof=水泥屋顶]

建造者模式UML类图

3.总结

建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式。

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

1.建造者模式一般返回一个组装完成的产品，而抽象工厂模式返回了一系列的产品。
2.建造者模式更加重视生产产品的流程（顺序）。
3.抽象工厂模式更像是大批量生产各个零部件的工厂，建造者模式则是将这些零部件组装成一个成品。