四、建造者模式

1.动机

在软件系统中，存在某些复杂对象的构建工作，其通常由各个部分的子对象用一定的算法组成。由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将他们组合在一起的算法确相对稳定，如何提供一种封装离机制隔离各个部分的变化，从而保持系统中稳定构建算法不随着需求改变而改变？

2.实现

（1）要构建的产品

package com.example.demo.builder;

public class House {

    private String floor;

    private String wall;

    private String window;

    private String door;

    private String houseCelling;


    public String getFloor() {
        return floor;
    }

    public void setFloor(String floor) {
        this.floor = floor;
    }

    public String getWall() {
        return wall;
    }

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

    public String getWindow() {
        return window;
    }

    public void setWindow(String window) {
        this.window = window;
    }

    public String getDoor() {
        return door;
    }

    public void setDoor(String door) {
        this.door = door;
    }

    public String getHouseCelling() {
        return houseCelling;
    }

    public void setHouseCelling(String houseCelling) {
        this.houseCelling = houseCelling;
    }

    @Override
    public String toString() {
        return "House{" +
                "floor='" + floor + '\'' +
                ", wall='" + wall + '\'' +
                ", window='" + window + '\'' +
                ", door='" + door + '\'' +
                ", houseCelling='" + houseCelling + '\'' +
                '}';
    }
}

(2)构建器抽象类

package com.example.demo.builder;

public interface HouseBuilder {

    void buildDoor();

    void buildWall();

    void buildWindows();

    void buildFloor();

    void buildHouseCelling();

    House buildHouse();
}

(3)导演类

package com.example.demo.builder;

public abstract class HouseDirect {

    /**
     * 算法相对稳定 先建地板，再打墙....
     * @param builder 生成器实例
     * @return house 实例
     */
    public static House createHouse(HouseBuilder builder){
        builder.buildFloor();
        builder.buildWall();
        builder.buildWindows();
        builder.buildHouseCelling();
        builder.buildDoor();
        return builder.buildHouse();
    }

}

(3) 建造者实现类

package com.example.demo.builder;

import org.springframework.beans.BeanUtils;

public class PinkHouseBuilder implements HouseBuilder{

    private String floor;

    private String wall;

    private String window;

    private String door;

    private String houseCelling;

    public void setFloor(String floor) {
        this.floor = floor;
    }

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

    public void setWindow(String window) {
        this.window = window;
    }

    public void setDoor(String door) {
        this.door = door;
    }

    public void setHouseCelling(String houseCelling) {
        this.houseCelling = houseCelling;
    }

    public String getFloor() {
        return floor;
    }

    public String getWall() {
        return wall;
    }

    public String getWindow() {
        return window;
    }

    public String getDoor() {
        return door;
    }

    public String getHouseCelling() {
        return houseCelling;
    }

    @Override
    public void buildDoor() {
        this.door = "粉色的门";
    }

    @Override
    public void buildWall() {
        this.wall = "粉色的墙";
    }

    @Override
    public void buildWindows() {
        this.window = "粉色的窗户";
    }

    @Override
    public void buildFloor() {
        this.floor = "粉色的地板";
    }

    @Override
    public void buildHouseCelling() {
        this.houseCelling = "粉色的天花板";
    }

    @Override
    public House buildHouse() {
        House house = new House();
        BeanUtils.copyProperties(this, house);
        return house;
    }
}

3.要点

• 建造者模式主要用于分步骤构建一个复杂对象，在其中分步骤是一个稳定的算法，但是复杂对象的各个部分则会发生各种变化
• 建造者模式主要在于复杂对象各个部分的频繁变动，但是难以应对分步骤构建算法的变动
• 抽象工厂主要解决系列对象的需求变化，建造者模式解决对象啊部分的需求变化
• 建造者模式通常和组合模式一起使用