设计模式——建造者模式

前言

建造者模式又被称呼为生成器模式，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

使用多个简单的对象一步一步构建成一个复杂的对象，有点像造房子一样一步步从地基做起到万丈高楼。

定义

1、定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
2、主要作用：在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。
3、如何使用：用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）
4、解决的问题：
（1）、方便用户创建复杂的对象（不需要知道实现过程）
（2）、代码复用性 & 封装性（将对象构建过程和细节进行封装 & 复用）
5、注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序，一般用来创建更为复杂的对象

此段落是来自 https://www.jianshu.com/p/47329a94f5dc

实现方式

目前我见到最多建造者模式应用大概有两种，分别是
（1）通过Client（通常是程序入口main方法）、Director（总监）、Builder（建造者，当然也有单独把建造者抽象和实现类分别写成了两个类，前者负责规范，后者负责实现）和Product（可以是任何有效实体，比如返回的VO实体，配置实体类等）形成的建造者模式。
（2）通过静态内部类方式实现零件无序装配化构造。

实现一

1. Client（通常是程序入口main方法）；
2. Director（总监）: 调用具体建造者来创建复杂对象（产品）的各个部分，并按照一定顺序（流程）来建造复杂对象。
3. abstractBuilder: 描述具体建造者的公共接口，一般用来定义建造细节的方法，并不涉及具体的对象部件的创建。
4. concreteBuilder或者BuilderImpl： 描述具体建造者，并实现抽象建造者公共接口。
5. Product（可以是任何有效实体，比如返回的VO实体，配置实体类等）形成的建造者模式。

抽象建造者

/**
 * @author happy
 * @since 2021-04-17
 */
public abstract class HouseBuilder {
    protected House house = new House();

    //将建造流程写好
    public abstract void buildBasic();

    public abstract void buildWalls();

    public abstract void buildProof();

    //返回产品
    public House getHouse(){
        return house;
    }
}

建造者具体实现类

/**
 * @author happy
 * @since 2021-04-17
 */
public abstract class HouseBuilder {
    protected House house = new House();

    //将建造流程写好
    public abstract void buildBasic();

    public abstract void buildWalls();

    public abstract void buildProof();

    //返回产品
    public House getHouse(){
        return house;
    }
}

总监或者指挥者

/**
 * @author happy
 * @since 2021-04-17
 */
public class HouseDirector {
    HouseBuilder houseBuilder ;

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

    public void constructHouse(){
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.buildProof();
    }
}

产品

这里的产品是House类，也可以是Garden类，Tree类，School类。。。

/**
 * @author happy
 * @since 2021-04-17
 */
public class House {
    private String basic;
    private String walls;
    private String proof;

    public House(String basic, String walls, String proof) {
        this.basic = basic;
        this.walls = walls;
        this.proof = proof;
    }

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWalls() {
        return walls;
    }

    public void setWalls(String walls) {
        this.walls = walls;
    }

    public String getProof() {
        return proof;
    }

    public void setProof(String proof) {
        this.proof = proof;
    }

    public House() {
    }

    @Override
    public String toString() {
        return "House{" +
                "basic='" + basic + '\'' +
                ", walls='" + walls + '\'' +
                ", proof='" + proof + '\'' +
                '}';
    }
}

客户端

/**
 * @author happy
 * @since 2021-04-17
 */
public class BuildClient {

    public static void main(String[] args) {
        //盖房子实现类
        HouseBuilderImpl houseBuilder = new HouseBuilderImpl();
        //准备创建房子的指挥者
        HouseDirector houseDirector = new HouseDirector(houseBuilder);
        //完成盖房子,返回产品-房子
        houseDirector.constructHouse();
    }
}

实现二

使用下面这种方式构建实体的时候，刚开始感觉高大上，但是慢慢思想就转换了，合适最重要，不要刻意追求设计模式，因为有时候搬过来也只是搬过来，证明你看过设计模式，但是殊不知已经过渡设计了，可能对于这个产品来说穷其一生也不会用到。

package designpatterns.builder.build;

/**
 * @author happy
 * @since 2022/8/28
 */
public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String clazz;
    private Integer grade;

    public Student(Builder builder) {
        this.id = builder.id;
        this.name = builder.name;
        this.age = builder.age;
        this.clazz = builder.clazz;
        this.grade = builder.grade;
    }

    public Student(Integer id, String name, Integer age, String clazz, Integer grade) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.clazz = clazz;
        this.grade = grade;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz;
    }

    public Integer getGrade() {
        return grade;
    }

    public void setGrade(Integer grade) {
        this.grade = grade;
    }

    public static class Builder {
        private Integer id;
        private String name;
        private Integer age;
        private String clazz;
        private Integer grade;

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

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

        public Builder age(Integer age) {
            this.age = age;
            return this;
        }

        public Builder clazz(String clazz) {
            this.clazz = clazz;
            return this;
        }

        public Builder grade(Integer grade) {
            this.grade = grade;
            return this;
        }

        public Student build() {
            return new Student(this);
        }
    }
}

主方法调用建造方法，给Student设置属性。

    public static void main(String[] args) {
        Student student = new Student.Builder()
                .id(1)
                .name("san")
                .age(30)
                .clazz("123")
                .grade(2)
                .build();

        System.out.println(student);
    }

感谢大家能够有耐心的看到文末，欢迎指正批评，谢谢。