目录
建造者模式（Builder Pattern）是一种创建型设计模式，它通过将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。该模式将对象的构建过程封装在一个独立的建造者类中，客户端通过指定不同的建造者来构建不同的对象。
在建造者模式中，有以下几个主要角色：
- 产品（Product）：表示被构建的复杂对象。
- 建造者（Builder）：定义了构建产品的抽象方法，可以有多个具体的建造者实现类。
- 指挥者（Director）：负责使用建造者对象构建复杂对象，它并不知道具体的构建过程。
- 具体建造者（Concrete Builder）：实现了建造者接口，负责具体产品的构建过程和组装。
代码
简单实现
java
// Product class
class Product {
private String partA;
private String partB;
private String partC;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
public void setPartC(String partC) {
this.partC = partC;
}
public void show() {
System.out.println("Product Parts:");
System.out.println("Part A: " + partA);
System.out.println("Part B: " + partB);
System.out.println("Part C: " + partC);
}
}
// Builder interface
interface Builder {
void buildPartA();
void buildPartB();
void buildPartC();
Product getResult();
}
// Concrete Builder
class ConcreteBuilder implements Builder {
private Product product;
public ConcreteBuilder() {
this.product = new Product();
}
@Override
public void buildPartA() {
product.setPartA("Part A");
}
@Override
public void buildPartB() {
product.setPartB("Part B");
}
@Override
public void buildPartC() {
product.setPartC("Part C");
}
@Override
public Product getResult() {
return product;
}
}
// Director
class Director {
public Product construct(Builder builder) {
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
return builder.getResult();
}
}
// Example usage
public class Main {
public static void main(String[] args) {
Builder builder = new ConcreteBuilder();
Director director = new Director();
Product product = director.construct(builder);
product.show();
}
}以上是建造者模式在Java中的实现示例。通过使用建造者接口和具体建造者类，将复杂对象的构建过程与其表示分离。指挥者类负责使用建造者对象构建产品对象。最终通过调用建造者的getResult()方法获取构建好的产品对象，并进行展示。
常用使用方法
当对象中参数过多时，频繁的get和set很麻烦，我们可以用建造者模式改造
java
public class Test {
private String partA;
private String partB;
private String partC;
private String partD;
private Test(Builder builder) {
partA = builder.partA;
partB = builder.partB;
partC = builder.partC;
partD = builder.partD;
}
public static final class Builder {
private String partA;
private String partB;
private String partC;
private String partD;
public Builder() {}
public Builder partA(String val) {
partA = val;
return this;
}
public Builder partB (String val) {
partB = val;
return this;
}
public Builder partC (String val) {
partC = val;
return this;
}
public Builder partD (String val) {
partD = val;
return this;
}
public Test build() {
return new Test(this);}
}
@Override
public String toString() {
return "Test{" +
"partA ='" + partA + '\'' +
", partB ='" + partB + '\'' +
", partC ='" + partC + '\'' +
", partD ='" + partD + '\'' +
'}';
}
}
public class Client {
public static void main(String[] args) {
Test test = new Test.Builder()
.partA ("partA")
.partB ("partB ")
.partC ("partC")
.partD ("partD ")
.build();
System.out.println(test);
}
}注解方法使用建造者模式
我们可以使用lombok.Builder注解使用构造者模式
java
@Data
@Builder
public class Test {
private String partA;
private String partB;
private String partC;
private String partD;
}
public class Client {
public static void main(String[] args) {
Test test = new Test.Builder()
.partA ("partA")
.partB ("partB ")
.partC ("partC")
.partD ("partD ")
.build();
System.out.println(test);
}
}总结
建造者模式的优点：
- 将复杂对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。
- 隐藏了产品的内部结构，使得客户端只需要关注产品的高层接口。
- 可以更加精细地控制产品的构建过程，灵活性高。
建造者模式的缺点：
- 是增加了代码的复杂度，需要创建多个类来实现建造者、产品和指挥者角色，增加了系统的抽象性和理解难度。
总结来说，建造者模式适用于需要创建复杂对象，且创建过程中涉及多个步骤和部件的场景。它提供了一种灵活、可扩展的对象构建方式，并且可以隐藏产品的内部细节。