建造者模式

建造者模式（Builder Pattern）

定义

将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

屏蔽建造的具体细节，用户不需要知道对象的建造过程和细节，就可以创建出复杂的对象；
通过先设置好建造者的变量，然后再一次性地创建对象，能够避免无效状态，让对象一直处于有效的状态；
避免冗长的构造函数参数；
设置好所有需要的参数之后进行集中校验，能够避免使用set() 时由于属性志军存在依赖关系而产生的由于 set() 顺序错乱而导致的校验失败的问题。

属于创建型模式。

适用场景

• 创建对象需要很多步骤，但是步骤的顺序不一定固定。
• 对象有非常复杂的内部结构（属性较多）
• 希望把复杂对象的创建和使用分离

标准示例

抽象建造者（Builder）：定义了构建复杂对象所需的各个部件的接口，但不涉及具体的部件对象的创建。

public abstract class Builder {
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public abstract Product getResult();
}

具体建造者（ConcreteBuilder）：实现抽象建造者的接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供一个方法返回创建好的产品对象。

public class ConcreteBuilder1 extends Builder{
    public void buildPartA() {
        product.setPartA("builder1--A");
    }

    public void buildPartB() {
        product.setPartB("builder1--B");
    }

    public void buildPartC() {
        product.setPartC("builder1--C");
    }

    public Product getResult() {
        return product;
    }
}

指挥者（Director）：负责安排复杂对象的建造次序，调用具体建造者来创建复杂对象的各个部分。指挥者不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public Product construct(){
        builder.buildPartC();
        builder.buildPartB();
        builder.buildPartA();
        return builder.getResult();
    }
}

产品（Product）：需要创建的复杂对象，包含多个组成部件。

@Data
public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void show() {
        System.out.println("Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}');
    }
}

ClientTest 测试类：

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder1();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();

    }
}

输出结果：

Product{partA='builder1--A', partB='builder1--B', partC='builder1--C'}

我们来举个生活中的例子：
我们想买一台高配置的电脑。
需要选购：CPU、内存、硬盘、显卡、等等。
下面我就通过建造者模式，来模拟这个过程。
涉及到的类有：
ComputerProduct 电脑产品

@Data
public class ComputerProduct {
    private String cpu;
    private String ram;
    private String hardDisk;
    private String videoCard;

    public String showConfig() {
        return "电脑 " +
                "[" + cpu + ']' +
                "+[" + ram + ']' +
                "+[" + hardDisk + ']' +
                "+[" + videoCard + ']' ;
    }
}

Director 组装指挥者

public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
	//独立显卡
    public ComputerProduct construct(){
        builder.buildCpu()
                .buildRam()
                .buildHardDisk()
                .buildVideoCard();
        return builder.getResult();
    }
	//集成显卡
    public ComputerProduct construct2(){
        builder.buildCpu()
                .buildRam()
                .buildHardDisk();
        return builder.getResult();
    }
}

Builder 抽象建造者

public abstract class Builder {
    protected ComputerProduct computerProduct = new ComputerProduct();

    public abstract Builder buildCpu();
    public abstract Builder buildRam();
    public abstract Builder buildHardDisk();
    public abstract Builder buildVideoCard();
    public abstract ComputerProduct getResult();

}

BuiderUser 具体电脑建造者

/**
 * 组装人员
 */
public class BuiderUser extends Builder{

    public Builder buildCpu() {
        computerProduct.setCpu("cpu");
        return this;
    }

    public Builder buildRam() {
        computerProduct.setRam("内存");
        return this;
    }

    public Builder buildHardDisk() {
        computerProduct.setHardDisk("硬盘");
        return this;
    }

    public Builder buildVideoCard() {
        computerProduct.setVideoCard("显卡");
        return this;
    }

    public ComputerProduct getResult() {
        return this.computerProduct;
    }
}

ClientTest 测试代码

public class ClientTest {
    public static void main(String[] args) {
        //装机人员
        Director user = new Director(new BuiderUser());
        ComputerProduct computer = user.construct();
        System.out.println(computer.showConfig());
    }
}

输出结果：

电脑 [cpu]+[内存]+[硬盘]+[显卡]

以上就是 建造者模式全部内容，感谢阅读。