设计模式之建造者模式

最新推荐文章于 2024-03-25 09:55:38 发布

codingXT

最新推荐文章于 2024-03-25 09:55:38 发布

阅读量5.8k

点赞数

文章标签：设计模式

本文链接：https://blog.csdn.net/qq_37774171/article/details/121648821

版权

定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象（依赖倒转原则，细节依赖于抽象），通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

类型

创建型

角色

Builder（抽象建造者）：它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。

ConcreteBuilder（具体建造者）：它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。

Product（产品角色）：它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程。

Director（指挥者）：负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象（也可以通过配置文件和反射机制），然后通过指挥者类的构造函数或者Setter方法将该对象传入指挥者类中。

在建造者模式的定义中提到了复杂对象，那么什么是复杂对象？简单来说，复杂对象是指那些包含多个成员属性的对象，这些成员属性也称为部件或零件，如汽车包括方向盘、发动机、轮胎等部件，电子邮件包括发件人、收件人、主题、内容、附件等部件。

为啥要使用建造者模式？
一个产品的创建细节太多，如果细节不依赖于抽象（按我的理解就是制定约束的话，代码形式就是接口和抽象类），如果一个具体的产品创建少了一个零件，我们无从知晓，而继承了抽象类和实现接口之后，如果具体产品缺少零件，就会编译不通过。这样来确保一个完整产品的成功生产。
一个产品，也就是一个具体类的创建，需要通过构造方法或者Setter方法的方式，会需要使用者知道大量具体产品的构建细节，如果多个地方要使用这个具体产品，就会产生大量的代码或者每个地方都要了解具体产品的创建细节。并且通过Setter的方式因为属性是分开赋值的，还容易出现错误，我们应当将这个产品的所有零件创建过程视为一个整体，当成一个事务。所以应该使用一个第三方来为我们创建一个完整的产品，我们只需要找第三方帮我们创建完整产品即可，这里的第三方就是建造者Builder模式

例子（电脑组装）

产品角色

public class Computer {

    private String brand; //品牌
    private String cpu;   //cpu
    private String mainBoard;  //主板
    private String hardDisk;   //硬盘
    private String displayCard;   //显卡
    private String power;  //电源
    private String memory;  //内存

    @Override
    public String toString() {
        return "Computer{" +
                "brand='" + brand + '\'' +
                ", cpu='" + cpu + '\'' +
                ", mainBoard='" + mainBoard + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", displayCard='" + displayCard + '\'' +
                ", power='" + power + '\'' +
                ", memory='" + memory + '\'' +
                '}';
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMainBoard() {
        return mainBoard;
    }

    public void setMainBoard(String mainBoard) {
        this.mainBoard = mainBoard;
    }

    public String getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String getDisplayCard() {
        return displayCard;
    }

    public void setDisplayCard(String displayCard) {
        this.displayCard = displayCard;
    }

    public String getPower() {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }
}

抽象建造者 Builder（制定规范，让细节依赖于抽象，给细节制定规范）

public abstract class Builder {

    protected Computer computer = new Computer();

    public abstract void buildBrand();
    public abstract void buildCPU();
    public abstract void buildMainBoard();
    public abstract void buildHardDisk();
    public abstract void buildDisplayCard();
    public abstract void buildPower();
    public abstract void buildMemory();

    public Computer createComputer() {
        return computer;
    }
}

依赖抽象规范的具体建造者：DellComputerBuilder和AcerComputerBuilder（多态的需要，抽象类是提取共性）

public class AcerComputerBuilder extends Builder{

    @Override
    public void buildBrand() {
        computer.setBrand("宏碁电脑");
    }
    @Override
    public void buildCPU() {
        computer.setCpu("Intel 第9代 酷睿");
    }
    @Override
    public void buildMainBoard() {
        computer.setMainBoard("宏碁主板");
    }
    @Override
    public void buildHardDisk() {
        computer.setHardDisk("512GB SSD");
    }
    @Override
    public void buildDisplayCard() {
        computer.setDisplayCard("1650 独立4GB");
    }
    @Override
    public void buildPower() {
        computer.setPower("3芯 锂离子电池 125W AC适配器");
    }
    @Override
    public void buildMemory() {
        computer.setMemory("2 x SAMSUNG  8GB");
    }
}

public class DellComputerBuilder extends Builder{


    @Override
    public void buildBrand() {
        computer.setBrand("戴尔电脑");
    }
    @Override
    public void buildCPU() {
        computer.setCpu("i5-10300H 八核");
    }
    @Override
    public void buildMainBoard() {
        computer.setMainBoard("戴尔主板");
    }
    @Override
    public void buildHardDisk() {
        computer.setHardDisk("1T + 256GB SSD");
    }
    @Override
    public void buildDisplayCard() {
        computer.setDisplayCard("GTX1060Ti 独立6GB");
    }
    @Override
    public void buildPower() {
        computer.setPower("4芯 锂离子电池 180W AC适配器");
    }
    @Override
    public void buildMemory() {
        computer.setMemory("2*Kingston 8G");
    }

}

指挥者 Director，指挥构建过程

public class Director {

    public Computer construct(Builder builder) {
        // 逐步构建复杂产品对象
        Computer computer;
        builder.buildBrand();
        builder.buildCPU();
        builder.buildDisplayCard();
        builder.buildHardDisk();
        builder.buildMainBoard();
        builder.buildMemory();
        builder.buildPower();
        computer = builder.createComputer();
        return computer;
    }

}

客户端测试

public class Test {


    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Director director = new Director();

        Builder asusBuilder = new AcerComputerBuilder();
        Computer asusComputer = director.construct(asusBuilder);
        System.out.println(asusComputer.toString());

        Builder dellBuilder = new DellComputerBuilder();
        Computer dellComputer = director.construct(dellBuilder);
        System.out.println(dellComputer.toString());


        // 从数据库或者配置文件中读取具体建造者类名,使用反射机制创建具体产品
        Class c = Class.forName("com.xt.designmode.creational.builder.AcerComputerBuilder");
        Builder acerBuilder = (Builder) c.newInstance();
        Computer acerComputer = director.construct(asusBuilder);
        System.out.println(asusComputer.toString());

    }

}

还有一种写法，可以省略掉指挥者 Director角色，而改由客户端创建产品，是builder简化的一种写法，在产品里面写一个静态内部类，由静态内部类来创建组装产品。

public class Computer {

    private String brand; //品牌  必造
    private String cpu;   //cpu  必造
    private String mainBoard;  //主板
    private String hardDisk;   //硬盘
    private String displayCard;   //显卡
    private String power;  //电源
    private String memory;  //内存

    public Computer(Builder builder){

        this.brand = builder.brand;
        this.cpu = builder.cpu;
        this.mainBoard = builder.mainBoard;
        this.hardDisk = builder.hardDisk;
        this.displayCard = builder.displayCard;
        this.power = builder.power;
        this.memory = builder.memory;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "brand='" + brand + '\'' +
                ", cpu='" + cpu + '\'' +
                ", mainBoard='" + mainBoard + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", displayCard='" + displayCard + '\'' +
                ", power='" + power + '\'' +
                ", memory='" + memory + '\'' +
                '}';
    }

    static class Builder {
        private String brand; //品牌
        private String cpu;   //cpu
        private String mainBoard;  //主板
        private String hardDisk;   //硬盘
        private String displayCard;   //显卡
        private String power;  //电源
        private String memory;  //内存

        public Builder(String brand,String cpu){
            this.brand = brand;
            this.cpu = cpu;
        }

        public Builder setMainBoard(String mainBoard) {
            this.mainBoard = mainBoard;
            return this;
        }

        public Builder setHardDisk(String hardDisk) {
            this.hardDisk = hardDisk;
            return this;
        }

        public Builder setDisplayCard(String displayCard) {
            this.displayCard = displayCard;
            return this;
        }

        public Builder setPower(String power) {
            this.power = power;
            return this;
        }

        public Builder setMemory(String memory) {
            this.memory = memory;
            return this;
        }

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

客户端代码：

public class Test {

    public static void main(String[] args){
        Computer computer=new Computer.Builder("惠普","九代I5")
                .setDisplayCard("GTX1080").setMainBoard("技嘉").setHardDisk("三星").setMemory("海力士")
                .build();
        System.out.println(computer.toString());
    }

}

建造者模式总结

优点：

在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合“开闭原则”。
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。