建造者模式（创建型）

目录

一、前言

二、建造者模式

三、链式编程实现建造者模式

四、总结

---

一、前言

        当我们开发一个软件应用时，我们通常需要创建各种对象。有些对象是简单的，可以直接实例化，但有些对象则比较复杂，需要多个步骤才能创建完成。这时候，建造者模式就派上用场了。        

        建造者模式是一种创建型设计模式，它允许我们逐步构造一个复杂的对象，而且可以控制整个构造过程。

        建造者模式中有四个重要的角色：

产品（Product）：表明需要构建的产品对象
抽象建造者（Builder）：抽象出来的构建者类，用于定义创建对象所需的步骤以及创建的步骤的调用过程
具体建造者（ConcreteBuilder）：抽象建造者的具体实现，对于不同的创建过程可以用不同的类进行实现
指挥者（Director）：使用 Builder 的类，提供给调用方使用，调用方通过使用指挥者来获取产品

        整个建造者模式的类图：

        

二、建造者模式

        首先建立Product类：

public class Product {
    private String part1;
    private String part2;
    private String part3;
    private String part4;
 
    public void setPart1(String part1) {
        this.part1 = part1;
    }
 
    public void setPart2(String part2) {
        this.part2 = part2;
    }
 
    public void setPart3(String part3) {
        this.part3 = part3;
    }
 
    public void setPart4(String part4) {
        this.part4 = part4;
    }
 
    @Override
    public String toString() {
        return "Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", part4='" + part4 + '\'' +
                '}';
    }
}

        创建抽象的Builder类：

public abstract class Builder {
 
    public abstract void buildPart1(String part1);
 
    public abstract void buildPart2(String part2);
 
    public abstract void buildPart3(String part3);
 
    public abstract void buildPart4(String part4);
 
 
    public abstract Product getProduct();
}

        创建具体的建造者类ConcreteBuilder：

public class ConcreteBuilder extends Builder{
    private Product product = new Product();
 
    @Override
    public void buildPart1(String part1) {
        product.setPart1(part1);
    }
 
    @Override
    public void buildPart2(String part2) {
        product.setPart2(part2);
    }
 
    @Override
    public void buildPart3(String part3) {
        product.setPart3(part3);
    }
 
    @Override
    public void buildPart4(String part4) {
        product.setPart4(part4);
    }
 
    @Override
    public Product getProduct() {
        return product;
    }
}

        指挥者类Director：

public class Director {
    private Builder builder;
 
    public Director(Builder builder) {
        this.builder = builder;
    }
 
    public Product construct(String part1, String part2) {
        builder.buildPart1(part1);
        builder.buildPart2(part2);
        return builder.getProduct();
    }
}

        进行测试：

public class TestBuilder {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct("part1", "part2");
        builder.buildPart3("part3");
        Product product = builder.getProduct();
        System.out.println(product);
    }
}

        运行结果：

        这里我是假设其中part1、part2是必须传的参数，其余两个参数非必传。

三、链式编程实现建造者模式

        链式编程中，我们只需要创建一个Product类，然后在里面创建静态的ConcreteBuilder类，并创建一个构造方法：

public class Product {
    private String part1;
    private String part2;
    private String part3;
    private String part4;
 
 
    public Product(ConcreteBuilder concreteBuilder) {
        this.part1 = concreteBuilder.part1;
        this.part2 = concreteBuilder.part2;
        this.part3 = concreteBuilder.part3;
        this.part4 = concreteBuilder.part4;
    }
 
    @Override
    public String toString() {
        return "Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", part4='" + part4 + '\'' +
                '}';
    }
 
    public static class ConcreteBuilder {
        private String part1;
        private String part2;
        private String part3;
        private String part4;
 
 
        public ConcreteBuilder(String part1, String part2){
            this.part1 = part1;
            this.part2 = part2;
        }
 
        public ConcreteBuilder builderPart3(String part3) {
            this.part3 = part3;
            return this;
        }
 
        public ConcreteBuilder builderPart4(String part4) {
            this.part4 = part4;
            return this;
        }
 
        public Product build() {
            return new Product(this);
        }
    }
 
}

        最后编写调用类：

public class TestBuilder {
    public static void main(String[] args) {
        Product product = new Product.ConcreteBuilder("part1", "part2")
                .builderPart4("part4")
                .build();
        System.out.println(product);
    }
}

        运行结果：

四、总结

        本文中的示例对象都是比较简单的，实际开发中这种简单的对象创建并不会使用到建造者模式，只有当对象比较复杂的时候才会使用到。

        实际使用的代码中，比如alibaba的Excel操作，com.alibaba.excel.write.builder就使用了建造者模式，ExcelWriterBuilder充当了具体的构建者，该类继承AbstractExcelWriterParameterBuilder。整个的产品就是一个WriteWorkbook对象。

        再比如org.springframework.web.reactive.function.client的WebClient也是使用建造者模式，使用WebClient.Builder类来构建WebClient对象。WebClient.Builder类封装了创建WebClient对象的细节，提供了一系列的方法来设置WebClient的属性，例如设置连接超时时间、设置请求头、设置代理等。最终，WebClient.Builder通过build()方法来返回一个完整的WebClient对象。使用建造者模式可以使得WebClient的构建过程更加灵活，易于使用和扩展。同时，建造者模式将对象构建的过程和具体实现分离开来，使得代码更加清晰简洁