建造者模式

建造者模式

建造者模式是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。用户只需指定需要建造的类型就可以获得对象，建造过程及细节不需要了解。

建造者（Builder）模式包含如下角色：

• 抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。
• 具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
• 产品类（Product）：要创建的复杂对象。
• 指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

1.常规写法

package com.zhen.studytotal.design.builder;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.Currency;

/**
 * Description:
 * User: zhen0w0
 * Date: 2025/3/11
 * Time: 00:28
 */
public class builder01 {

    public static void main(String[] args) {
        ComputerDirector director = new ComputerDirector(new MacComputerBuilder());
        Computer computer = director.buildComputer();
        System.out.println(computer);
    }

}

@Data
class Computer {
    private String cpu;
    private String gpu;
    private String memory;
    private String disk;
    private String power;
    private String mainboard;
    private String display;
    private String keyboard;
    private String mouse;
}
//抽象builder类，组装电脑
interface ComputerBuilder {
    Computer computer = new Computer();

    void buildCpu();
    void buildGpu();
    void buildMemory();
    void buildDisk();
    void buildPower();
    void buildMainboard();
    void buildDisplay();
    void buildKeyboard();
    void buildMouse();

    Computer build();
}

// 具体 builder类 MAC桶电脑
class MacComputerBuilder implements ComputerBuilder {

    @Override
    public void buildCpu() {
        computer.setCpu("i7");
    }

    @Override
    public void buildGpu() {
        computer.setGpu("NVIDIA");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("16G");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("1T");
    }

    @Override
    public void buildPower() {
        computer.setPower("220V");
    }

    @Override
    public void buildMainboard() {
        computer.setMainboard("华硕");
    }

    @Override
    public void buildDisplay() {
        computer.setDisplay("27寸");
    }

    @Override
    public void buildKeyboard() {
        computer.setKeyboard("苹果键盘");
    }

    @Override
    public void buildMouse() {
        computer.setMouse("苹果鼠标");
    }

    @Override
    public Computer build() {
        return computer;
    }
}

//指挥者类，负责组装电脑
@AllArgsConstructor
class ComputerDirector {
    private ComputerBuilder computerBuilder;

    public Computer buildComputer() {
        computerBuilder.buildCpu();
        computerBuilder.buildGpu();
        computerBuilder.buildMemory();
        computerBuilder.buildDisk();
        computerBuilder.buildPower();
        computerBuilder.buildMainboard();
        computerBuilder.buildDisplay();
        computerBuilder.buildKeyboard();
        computerBuilder.buildMouse();
        return computerBuilder.build();
    }
}

2.简化写法

指挥者类和抽象类融合

// 把指挥者类和抽象建造者合在一起的简化建造者类
public class SimpleComputerBuilder {
    private Computer computer = new Computer();
    public void buildMotherBoard(String motherBoard){
        computer.setMotherboard(motherBoard);
    }
    public void buildCpu(String cpu){
        computer.setCpu(cpu);
    }
    public void buildMemory(String memory){
        computer.setMemory(memory);
    }
    public void buildDisk(String disk){
        computer.setDisk(disk);
    }
    public void buildGpu(String gpu){
        computer.setGpu(gpu);
    }
    public void buildPower(String power){
        computer.setPower(power);
    }
    public void buildHeatSink(String heatSink){
        computer.setHeatSink(heatSink);
    }
    public void buildChassis(String chassis){
        computer.setChassis(chassis);
    }
    public Computer build(){
        return computer;
    }
}
    // 测试
    public static void main(String[] args) {
        SimpleComputerBuilder simpleComputerBuilder = new SimpleComputerBuilder();
        simpleComputerBuilder.buildMotherBoard("Extreme主板");
        simpleComputerBuilder.buildCpu("Inter 12900K");
        simpleComputerBuilder.buildMemory("芝奇幻峰戟 16G*2");
        simpleComputerBuilder.buildDisk("三星980Pro 2T");
        simpleComputerBuilder.buildGpu("华硕3090Ti 水猛禽");
        simpleComputerBuilder.buildPower("雷神二代1200W");
        simpleComputerBuilder.buildHeatSink("龙神二代一体式水冷");
        simpleComputerBuilder.buildChassis("太阳神机箱");
        // Computer(motherboard=Extreme主板, cpu=Inter 12900K, memory=芝奇幻峰戟 16G*2, disk=三星980Pro 2T, gpu=华硕3090Ti 水猛禽, power=雷神二代1200W, heatSink=龙神二代一体式水冷, chassis=太阳神机箱)
        System.out.println(simpleComputerBuilder.build());
    }

3.链式写法

class SimpleComputerBuilder {
    private Computer computer = new Computer();

    public SimpleComputerBuilder buildCpu(String cpu) {
        computer.setCpu(cpu);
        return this;
    }
    public SimpleComputerBuilder buildGpu(String gpu) {
        computer.setGpu(gpu);
        return this;
    }
    public SimpleComputerBuilder buildMemory(String memory) {
        computer.setMemory(memory);
        return this;
    }
    public SimpleComputerBuilder buildDisk(String disk) {
        computer.setDisk(disk);
        return this;
    }
    public SimpleComputerBuilder buildPower(String power) {
        computer.setPower(power);
        return this;
    }
    public SimpleComputerBuilder buildMainboard(String mainboard) {
        computer.setMainboard(mainboard);
        return this;
    }
    public SimpleComputerBuilder buildDisplay(String display) {
        computer.setDisplay(display);
        return this;
    }
    public SimpleComputerBuilder buildKeyboard(String keyboard) {
        computer.setKeyboard(keyboard);
        return this;
    }
    public SimpleComputerBuilder buildMouse(String mouse) {
        computer.setMouse(mouse);
        return this;
    }

    public Computer build() {
        return computer;
    }
}

4.总结

适用场景：

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

优点：

• 封装性好，创建和使用分离。
• 扩展性好，建造类之间独立、一定程度上解耦。

缺点：

• 产生多余的Builder对象。
• 产品内部发生变化，建造者都要修改，成本较大。