不管怎么样，都要继续充满着希望

上一章简单介绍了原型模式(七), 如果没有看过, 请观看上一章

一. 建造者模式

引用 菜鸟教程里面的建造者模式介绍: https://www.runoob.com/design-pattern/builder-pattern.html

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

一.一 介绍

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例：

1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

2、JAVA 中的 StringBuilder。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

组成角色	具体	关系	作用
产品（Product）	House	具体生产器要构造的复杂对象	具体生产器要构造的复杂对象
具体生产器(ConcreteBuilder)	SimpleHouseBuilder,HightHouseBuilder	生产各个组件	实现Builder接口的类，具体生成器将实现Builder接口所定义的方法
抽象生成器(Bulider)	HouseBuilder	定义构造步骤	除了为创建一个Product对象的各个组件定义了若干个方法之外，还要定义返回Product对象的方法
指挥者(Director)	HouseDirector	按照步骤组装部件，并返回Product	按照步骤组装部件，并返回Product

二. 实现

如 定义一个盖房子的操作

二.一 不使用建造者模式

二.一.一 定义抽象类

定义一个抽象类:

public abstract class AbstractHouse {
    protected abstract void buildBasic();
    protected abstract void buildWalls();
    protected abstract void buildRoofed();

    public void build () {
        buildBasic();
        buildWalls();
        buildRoofed();
    }
}

二.一.二 子类实现

@Slf4j
public class SimpleHouse extends AbstractHouse{
    @Override
    protected void buildBasic() {
        log.info("简单楼打地基");
    }

    @Override
    protected void buildWalls() {
        log.info("简单楼砌墙壁");
    }

    @Override
    protected void buildRoofed() {
        log.info("简单楼地板");
    }
}

@Slf4j
public class HightHouse extends AbstractHouse{

    @Override
    protected void buildBasic() {
        log.info("高楼打地基");
    }

    @Override
    protected void buildWalls() {
        log.info("高楼砌墙壁");
    }

    @Override
    protected void buildRoofed() {
        log.info("高楼地板");
    }
}

二.一.三 测试方法

 @Test
    public void oneTest() {
        AbstractHouse simpleHouse = new SimpleHouse();
        simpleHouse.build();

        AbstractHouse hightHouse  = new HightHouse();
        hightHouse.build();
    }

这种方式是不符合设计原则的.

二.二 建造者模式

二.二.一 定义产品 Product

@Data
public class House {
    private String basic;
    private String wall;
    private String roofed;
}

二.二.二 抽象生成器 Builder

一般只需要一个方法 build()

public abstract class HouseBuilder {

    protected House house = new House();

    protected abstract void buildBasic();
    protected abstract void buildWalls();
    protected abstract void buildRoofed();

    public House build() {
        buildBasic();
        buildWalls();
        buildRoofed();
        return house;
    }
    /**
     一个其他的类型操作,类似于不同的套餐
     */
    public House noRoofBuild () {
        buildBasic();
        buildWalls();
        return house;
    }
}

二.二.三 具体生产器 ConcreteBuilder

public class SimpleHouseBuilder extends HouseBuilder{

    @Override
    protected void buildBasic() {
        house.setBasic("地基10");
    }

    @Override
    protected void buildWalls() {
        house.setWall("砌墙2");
    }

    @Override
    protected void buildRoofed() {
        house.setRoofed("地板2");
    }
}

public class HightHouseBuilder extends HouseBuilder{

    @Override
    protected void buildBasic() {
        house.setBasic("地基100");
    }

    @Override
    protected void buildWalls() {
        house.setWall("砌墙20");
    }

    @Override
    protected void buildRoofed() {
        house.setRoofed("地板20");
    }
}

二.二.四 指挥者 Director

public class HouseDirector {
    HouseBuilder houseBuilder = null;

    public HouseDirector (HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public House build () {
        return this.houseBuilder.build();
    }

    public House noRoofBuild () {
        return this.houseBuilder.noRoofBuild();
    }
}

二.二.五 测试使用

    @Test
    public void twoTest() {
        HouseDirector houseDirector = new HouseDirector(new HightHouseBuilder());
        House house = houseDirector.build();
        log.info(">>> 打印高信息: {}", house);

        houseDirector.setHouseBuilder(new SimpleHouseBuilder());

        House noRoofHouse = houseDirector.noRoofBuild();
        log.info(">>> 打印低信息: {}", noRoofHouse);
        
        House house2 = houseDirector.build();
        log.info(">>> 打印低信息: {}", house2);
    }

三. 普通实体类的建造者

如，我们定义一个 Student 类

注意， @Builder 注解

@Data
@Builder
public class Student {
    private Integer id;
    private String name;
    private String sex;
}

我们在使用的时候，是这样使用的， 是一个建造者

@Test
    public void threeTest() {
        Student student = Student.builder().id(1).name("张三").sex("男").build();
        log.info("学生信息: {}", student);
    }

源代码会动态编译成:

public class Student {
    private Integer id;
    private String name;
    private String sex;

    Student(Integer id, String name, String sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }

    public static Student.StudentBuilder builder() {
        return new Student.StudentBuilder();
    }

    public static class StudentBuilder {
        private Integer id;
        private String name;
        private String sex;

        StudentBuilder() {
        }

        public Student.StudentBuilder id(Integer id) {
            this.id = id;
            return this;
        }

        public Student.StudentBuilder name(String name) {
            this.name = name;
            return this;
        }

        public Student.StudentBuilder sex(String sex) {
            this.sex = sex;
            return this;
        }

        public Student build() {
            return new Student(this.id, this.name, this.sex);
        }

        public String toString() {
            return "Student.StudentBuilder(id=" + this.id + ", name=" + this.name + ", sex=" + this.sex + ")";
        }
    }
}

本章节的代码放置在 github 上:

https://github.com/yuejianli/DesignPattern/tree/develop/Builder

谢谢您的观看，如果喜欢，请关注我，再次感谢 !!!