springboot 建造者设计模式

一、什么是建造者模式

　　建造者模式又叫生成器模式，是一种对象构建模式，可以将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。

　　建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

二、角色组成

　　product(产品角色)：一个具体的产品对象

　　builder（抽象建造者）：创建一个product对象的各个部件指定的接口（抽象类），（接口和抽象类都可以做抽象层）抽象建造者只需要指定建造一个产品的流程，并不管具体的建造细节。

　　concreteBuilder(具体建造者)：实现接口/抽象类，构建和装配各个部件。负责具体的建造细节。

　　director（指挥者）：构建一个使用builder接口的对象，它主要用于创建一个复杂的对象，主要有两个作用：隔离客户与对象生产的过程，负责控制产品对象的过程。

三、应用场景

　　盒饭套餐：餐厅有多种菜品，顾客可以选择不同的菜，服务员按照顾客户的要求，将这些菜组合起来，最终构建出一个完整的套餐。

　　盖房子：需要分多个阶段进行，比如准备材料、打地基、盖围墙…。建造者模式可以将房屋的建造分解成多个步骤，每个步骤对应一个具体的建造者，最终由包　　工头（指导者）来调用不同的建造者，完成整个房子的建造。
　　Stream API（Java）：将集合类转为stream流，通过一系列的中间操作和终止操作来生成最终结果。
总的来说是：当创建一个复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。 当构造过程必须允许被构造的对象有不同的表示时。

四、实现

　　4.1 产品类

　　

public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;
    public Phone(String cpu, String screen, String memory, String mainboard) {
        this.cpu = cpu;
        this.screen = screen;
        this.memory = memory;
        this.mainboard = mainboard;
    }
    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getScreen() {
        return screen;
    }
    public void setScreen(String screen) {
        this.screen = screen;
    }
    public String getMemory() {
        return memory;
    }
    public void setMemory(String memory) {
        this.memory = memory;
    }
    public String getMainboard() {
        return mainboard;
    }
    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }
    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                '}';
    }
}

4.2 抽象建造者

public interface Builder {
    void buildBoard(String board);
    void buildCpu(String cpu);
    void buildRam(String ram);
    void buildHardDisk(String hardDisk);
    Phone createPhone();
}

4.3 具体建造者

public class AsusBuilder implements Builder {
    private Phone mPhone = new AsusPhone();

    @Override
    public void buildBoard(String board) {
        mPhone.setBoard(board);
    }

    @Override
    public void buildCpu(String cpu) {
        mPhone.setCpu(cpu);
    }

    @Override
    public void buildRam(String ram) {
        mPhone.setRam(ram);
    }

    @Override
    public void buildHardDisk(String hardDisk) {
        mPhone.setHardDisk(hardDisk);
    }

    @Override
    public Phone createPhone() {
        return mPhone;
    }
}

public class DellBuilder implements Builder {
    private Phone mPhone = new DellPhone();

    @Override
    public void buildBoard() {
        mPhone.setBoard("Asus Board");
    }

    @Override
    public void buildCpu() {
        mPhone.setCpu("Intel i7-8700K");
    }

    @Override
    public void buildRam() {
        mPhone.setRam("16GB DDR4");
    }

    @Override
    public void buildHardDisk() {
        mPhone.setHardDisk("1TB SSD");
    }

    @Override
    public Phone createPhone() {
        return mPhone;
    }
}

public class HPBuilder implements Builder {
    private Phone mPhone = new HPPhone();

    @Override
    public void buildBoard() {
        mPhone.setBoard("djkfj");
    }

    @Override
    public void buildCpu() {
        mPhone.setCpu("麒麟9000");
    }

    @Override
    public void buildRam() {
        mPhone.setRam("kdk22 ");
    }

    @Override
    public void buildHardDisk() {
        mPhone.setHardDisk("威海");
    }

    @Override
    public Phone createPhone() {
        return mPhone;
    }
}

4.4 指挥者

public class Director {
    private Builder mBuilder;

    public Director(Builder builder) {
        this.mBuilder = builder;
    }

    public Phone buildPhone(String board, String cpu, String ram, String hardDisk) {
        mBuilder.buildBoard(board);
        mBuilder.buildCpu(cpu);
        mBuilder.buildRam(ram);
        mBuilder.buildHardDisk(hardDisk);
        return mBuilder.createPhone();
    }
}

4.5 测试类

public class Client {
    public static void main(String[] args) {
        Builder asusBuilder = new AsusBuilder();
        Builder dellBuilder = new DellBuilder();
        // 指挥者创建对应的手机
        Director director = new Director(asusBuilder);
        Phone asusPhone = director.buildPhone();
        
        director = new Director(dellBuilder);
         Phone asusPhone =  director.buildPhone();
    }
}

分析：

　　可以看到，根据不同的需求，建造者模式可以构造出不同的手机对象。每个手机对象的构建过程都由不同的建造者实现，在构建过程中可定制相应的属性。最终，因为手机的构建过程和表示分离，所以同样的构建过程可以创建出不同的表示。

优缺点
建造者模式的优点：
1. 将构建复杂对象的过程封装起来，简化了代码结构和逻辑。
2. 不同的具体构造者可以实现不同的构建流程，使得同样的构建过程可以创建不同的表示。
3. 指导者类可以根据需要按照特定的顺序执行构建流程，从而达到更好的控制和管理对象的构建。

建造者模式的缺点：
1. 添加新的部件需要修改抽象类和具体构造者的代码。
2. 如果对象的属性较少，使用建造者模式可能会显得过于复杂，不如直接使用工厂方法模式或简单工厂模式。

总之，建造者模式适用于需要创建对象复杂且变化多端的情景，它能够将对象的构建过程标准化，从而达到代码重用和简化的目的

原文链接：https://blog.csdn.net/Shine19/article/details/147023802