四、建造者模式

设计模式

四、建造者模式

解决问题：在运行期建立和删除原型

优点：

1. 各个具体的建造者相互独立，有利于系统的扩展
2. 客户端不必知道产品内部组成的细节，便于控制细节风险

缺点：

1. 产品的组成部分必须相同，这限制了其使用范围
2. 如果产品的内部变化复杂，该模式会增加很多的建造者类

主要角色：

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个滅部件。
2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 build()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

1. 传统模式

UML类图

实现

// 产品类 由A、B、C构成
public 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;
    }
    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}

// 建造者抽象类 用户创建不同组成产品
public abstract class Builder {
    protected Product product=new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public Product build() {
        return product;
    }
}

// modal1 建造者
public class Modal1Builder extends Builder {
    @Override
    public void buildPartA() {
        product.setPartA("A1");
    }
    @Override
    public void buildPartB() {
        product.setPartB("B1");
    }
    @Override
    public void buildPartC() {
        product.setPartC("C1");
    }
}

// modal2 建造者
public class Modal2Builder extends Builder {
    @Override
    public void buildPartA() {
        product.setPartA("A2");
    }
    @Override
    public void buildPartB() {
        product.setPartB("B2");
    }
    @Override
    public void buildPartC() {
        product.setPartC("C2");
    }
}

// 指挥者 传入不同建造者 得到不同类型产品
public class Director {
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.build();
    }
}

2. 简单模式

public class Person {
    // 必要变量
    private String name;
    private Integer age;
    // 非必须变量
    private String gun;
    private String phone;
    private String watch;

    // 忽略getter setter toString
    ...
	
    // 根据不同builder构建不同对象
    public Person(Builder builder){
        this.name = builder.name;
        this.age = builder.age;
        this.gun = builder.gun;
        this.phone = builder.phone;
        this.watch = builder.watch;
    }

    // 内部静态类构建者
    public static class Builder{
        private String name;
        private Integer age;

        private String gun;
        private String phone;
        private String watch;

        public Builder(String name, Integer age){
            this.name = name;
            this.age = age;
        }
        public Builder setGun(String gun){
            this.gun = gun;
            return this;
        }
        public Builder setPhone(String phone){
            this.phone = phone;
            return this;
        }
        public Builder setWatch(String watch){
            this.watch = watch;
            return this;
        }
        public Person build(){
            return new Person(this);
        }
    }
}

// 测试代码
Person person = new Person.Builder("zhangsan", 18).setWatch("huawei seris 3").build();

3. 总结

1. 建造者模式注重零部件的组装过程，工厂模式更注重零部件的创建过程
2. lombok @Builder 注解可以实现简单模式（推荐）