生成器模式/建造者模式代码示例

生成器模式（Builder Pattern）是一种创建型设计模式，它的核心目的是将一个复杂对象的构建过程与其表示分离，使得构造过程和表示可以独立变化。这种模式尤其适用于那些构建过程复杂，且构造过程中可能有多种变化的情况。生成器模式通过一步步构建对象的各个部分，最后组合成一个完整对象，提供了更好的灵活性和可读性。

就是我们创建创建的对象如果比较复杂，里面包含的其他对象内容，为了简化业务方的调用，通过生成器模块可以简化调用方式。生成器模式又叫建造者模式

生成器模式主要包括以下几个角色：
Builder（生成器接口）：它声明了一个用于创建产品对象的抽象接口，一般包含创建产品所需的各种方法，但不涉及具体产品的表示。
ConcreteBuilder（具体生成器）：实现了Builder接口，负责创建并组装产品的各个部分，定义并明确它所创建的表示，并提供一个检索产品的接口。
Product（产品）：要创建的复杂对象，包含多个组成部件，由ConcreteBuilder逐步构建。
Director（指导者）：可选角色，负责调用生成器中的方法来创建产品。它隔离了客户端与生成过程的细节，使得客户端只关心所需的产品而非其创建过程。

以下是示例代码：

示例1：包含产品（复杂对象及简单对象）、具体生成器

package design;


/**
 * @program: dcms
 * @description: 生成器模式
 * @doc:
 **/
public class BuilderPatternTest {

    public static void main(String[] args) {

        //通过生成器输出一台普通电脑
        Computer basicComp = new Computer.ComputerBuilder()
                .setCpu("Intel i5")
                .setRam(8)
                .setHdd("500GB HDD")
                .build();
        System.out.println("Basic Computer Config: " + basicComp);


        // 通过生成器输出一台游戏主机
        Computer gamingComp = new Computer.ComputerBuilder()
                .setCpu("AMD Ryzen 7")
                .setRam(16)
                .setHdd("1TB SSD")
                .setGraphicsCard(true)
                .build();
        System.out.println("Gaming Computer Config: " + gamingComp);


    }

}

class Computer {
    private String cpu;
    private int ram;
    private String hdd;
    private boolean graphicsCard;

    // Private constructor to ensure object is created only through the builder.
    private Computer(Computer.ComputerBuilder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.hdd = builder.hdd;
        this.graphicsCard = builder.graphicsCard;
    }

    // Getters (no setters as we're using a builder pattern)

    public String getCpu() { return cpu; }
    public int getRam() { return ram; }
    public String getHdd() { return hdd; }
    public boolean hasGraphicsCard() { return graphicsCard; }

    // Builder inner class
    public static class ComputerBuilder {
        private String cpu;
        private int ram;
        private String hdd;
        private boolean graphicsCard;

        public ComputerBuilder() {}

        public Computer.ComputerBuilder setCpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Computer.ComputerBuilder setRam(int ram) {
            this.ram = ram;
            return this;
        }

        public Computer.ComputerBuilder setHdd(String hdd) {
            this.hdd = hdd;
            return this;
        }

        public Computer.ComputerBuilder setGraphicsCard(boolean graphicsCard) {
            this.graphicsCard = graphicsCard;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}

示例2：包含产品（复杂对象及简单对象）、生成器接口、具体生成器

package design;


import java.util.ArrayList;
import java.util.List;

/**
 * @program: dcms
 * @description: 生成器模式
 * @author: wangwenguan6
 * @date: 2024-05-27 13:53:12
 * @doc:
 **/
public class BuilderPatternTest2 {

    public static void main(String[] args) {
        Hamburger hamburger = new ClassicBurgerBuilder().setBun("优质面包").setPatty("肉饼").addTopping("胡椒粉").addTopping("番茄酱").build();
        System.out.println(hamburger.toString());
    }

}

//定义产品 汉堡
class Hamburger {
    //面包
    private String bun;
    //肉饼or蔬菜饼
    private String patty;
    //挑梁
    private List<String> toppings;

    public Hamburger(String bun, String patty, List<String> toppings) {
        this.bun = bun;
        this.patty = patty;
        this.toppings = toppings;
    }

    // Getters (no setters as we're using a builder pattern)

    public String getBun() {
        return bun;
    }

    public String getPatty() {
        return patty;
    }

    public List<String> getToppings() {
        return toppings;
    }

    @Override
    public String toString() {
        return "Hamburger{" +
                "bun='" + bun + '\'' +
                ", patty='" + patty + '\'' +
                ", toppings=" + toppings +
                '}';
    }
}

//以下是定义生成器接口及具体生成器

// 生成器接口
interface HamburgerBuilder {
    HamburgerBuilder setBun(String bun);

    HamburgerBuilder setPatty(String patty);

    HamburgerBuilder addTopping(String topping);

    Hamburger build();
}


// 具体生成器：经典汉堡
class ClassicBurgerBuilder implements HamburgerBuilder {
    //面包
    private String bun;
    //肉饼or蔬菜饼
    private String patty;
    //调料
    private List<String> toppings = new ArrayList<>();

    @Override
    public HamburgerBuilder setBun(String bun) {
        this.bun = bun;
        return this;
    }

    @Override
    public HamburgerBuilder setPatty(String patty) {
        this.patty = patty;
        return this;
    }

    @Override
    public HamburgerBuilder addTopping(String topping) {
        this.toppings.add(topping);
        return this;
    }

    @Override
    public Hamburger build() {
        // 添加经典汉堡特有的配料 (每个生成器可以有不同的配置)
        addTopping("Ketchup");
        addTopping("Mustard");
        return new Hamburger(bun, patty, toppings);
    }
}

示例3：包含产品（复杂对象及简单对象）、生成器接口、具体生成器、指导者

package design.builderpattern;

import java.util.ArrayList;
import java.util.List;

/**
 * @program: dcms
 * @description: BuildPatternTest3
 * @author: wangwenguan6
 * @date: 2024-05-27 15:05:04
 * @doc:
 **/
public class BuildPatternTest3 {
    public static void main(String[] args) {
        //指导者类
        Director director = new Director();

        //利用具体生成器创建build
        ComputerBuilder builder = new HighConfigBuilder();

        // 指导者指导生成器构建高配置计算机（这个时候使用指导者类影响具体生成器参数）
        director.constructHighConfigComputer(builder);

        //借助生成器的get方法获取具体的对象
        Computer computer = builder.getComputer();
        computer.showComponents();
    }
}


// 定义一个商品接口(计算机组件接口)
interface ComputerComponent {
    void show();
}

// 定义一个具体的简单产品：CPU实现类
class CPU implements ComputerComponent {
    @Override
    public void show() {
        System.out.println("Intel i7 CPU");
    }
}

// 定义一个具体的简单产品：RAM实现类
class RAM implements ComputerComponent {
    @Override
    public void show() {
        System.out.println("16GB DDR4 RAM");
    }
}

// 定义一个具体的简单产品：HDD实现类
class HDD implements ComputerComponent {
    @Override
    public void show() {
        System.out.println("1TB HDD");
    }
}

//创建的复杂对象，包含多个组成部件(cpu、ram等)
class Computer {
    private List<ComputerComponent> components = new ArrayList<>();

    void addComponent(ComputerComponent component) {
        components.add(component);
    }

    void showComponents() {
        for (ComputerComponent component : components) {
            component.show();
        }
    }
}


//定义生成器接口及具体生成器
// 计算机生成器接口（生成器接口）
interface ComputerBuilder {
    void buildCPU();
    void buildRAM();
    void buildHDD();
    Computer getComputer();
}

// 高配计算机生成器（具体生成器）
class HighConfigBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void buildCPU() {
        computer.addComponent(new CPU());
    }

    @Override
    public void buildRAM() {
        computer.addComponent(new RAM());
    }

    @Override
    public void buildHDD() {
        computer.addComponent(new HDD());
    }

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

//定义指导者类
class Director {
    void constructHighConfigComputer(ComputerBuilder builder) {
        builder.buildCPU();
        builder.buildRAM();
        builder.buildHDD();
    }
}

参考：refactoringguru.cn/design-patt…