目录
一、前言
二、建造者模式
三、链式编程实现建造者模式
四、总结
当我们开发一个软件应用时,我们通常需要创建各种对象。有些对象是简单的,可以直接实例化,但有些对象则比较复杂,需要多个步骤才能创建完成。这时候,建造者模式就派上用场了。
建造者模式是一种创建型设计模式,它允许我们逐步构造一个复杂的对象,而且可以控制整个构造过程。
建造者模式中有四个重要的角色:
产品(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的构建过程更加灵活,易于使用和扩展。同时,建造者模式将对象构建的过程和具体实现分离开来,使得代码更加清晰简洁