设计模式之建造者模式

一、原理

1、建造者模式是一种创建型设计模式，用于创建复杂对象。它通过将对象的构建过程分解为多个简单的步骤，并且使用相同的构建过程可以创建不同的表示。

2、建造者模式通过将对象的构建过程分解为多个步骤，每个步骤由一个Builder类负责。建造者类通常包含一些方法用于设置对象的各个部分，并且返回自身。最后，客户端通过调用建造者类的方法来构建对象。

二、使用场景：

1.场景1：

当需要创建一个包含多个组成部分或者参数较多的对象时，可以使用建造者模式。例如，创建一个汽车对象时需要设置引擎、车身、轮胎、内饰等多个部分。

2. 场景2：

当需要创建一个对象的构建过程可以灵活组装时，可以使用建造者模式。例如，可以根据客户的需求动态地组装一个自定义的电脑。

三、代码示例：

下面是一个简单的示例代码，展示了如何使用建造者模式创建一个电脑对象：

1. 创建Computer 类，表示要构建的复杂对象。

package org.storemanage.regestercenter.bulidermode;

/**
 * @CreateTime: 2024-08-27
 * @Description: 电脑信息
 * @Version: 1.0
 * @Author: hkf
 */

public class Computer {

    private  String  name;

    private  String cpu;

    private String hardDisk;

    private String  Memory;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCpu() {
        return cpu;
    }

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

    public String getHardDisk() {
        return hardDisk;
    }

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

    public String getMemory() {
        return Memory;
    }

    public void setMemory(String memory) {
        Memory = memory;
    }


    @Override
    public String toString() {
        return "Computer{" +
                "name='" + name + '\'' +
                ", cpu='" + cpu + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", Memory='" + Memory + '\'' +
                '}';
    }
}

2. 创建Builder接口，定义构建对象的各个步骤。

package org.storemanage.regestercenter.bulidermode;

/**
 * @CreateTime: 2024-08-27
 * @Description: 设置电脑属性的接口
 * @Version: 1.0
 * @Author: hkf
 */

public interface Builder {

     void   setName();

     void   setCpu();

     void  setHarDisk();

     void setMemory();

     Computer builder();

}

3. 创建具体的Builder类，实现Builder接口，并具体实现构建对象的各个步骤。

package org.storemanage.regestercenter.bulidermode;

/**
 * @CreateTime: 2024-08-27
 * @Description: 具体电脑实现类
 * @Version: 1.0
 * @Author: hkf
 */


public class ConcreteBuilder  implements Builder{

    private Computer computer = new Computer();
    @Override
    public void setName() {
        computer.setName("Lenovo Computer");
    }

    @Override
    public void setCpu() {
        computer.setCpu("i9 13代");

    }

    @Override
    public void setHarDisk() {
        computer.setHardDisk("固态硬盘2T");

    }

    @Override
    public void setMemory() {
        computer.setMemory("内存48G");

    }

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

4. 创建Director类，负责使用Builder对象构建复杂对象。

package org.storemanage.regestercenter.bulidermode;

/**
 * @CreateTime: 2024-08-27
 * @Description: 负责使用Builder对象构建复杂对象
 * @Version: 1.0
 * @Author: hkf
 */

public class Director {

    private  Builder builder;

    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    public Computer  createObject(){
        builder.setCpu();
        builder.setName();
        builder.setMemory();
        builder.setHarDisk();
        return  builder.builder();
    }
}

5. 在客户端中使用Director来构建复杂对象。

package org.storemanage.regestercenter.bulidermode;

/**
 * @CreateTime: 2024-08-27
 * @Description: 计算机测试类
 * @Version: 1.0
 * @Author: hkf
 */

public class ComputerDemo {
    public static void main(String[] args) {
        Director director = new Director();
        ConcreteBuilder concreteBuilder = new ConcreteBuilder();
        director.setBuilder(concreteBuilder);
        Computer computer = director.createObject();

        System.err.println("获取电脑名称name:\n"+computer.getName());
        System.err.println("获取电脑信息Cpu：\n"+computer.getCpu());
        System.err.println("获取电脑内存信息Memory:\n"+computer.getMemory());
        System.err.println("获取硬盘信息hardDis:\n"+computer.getHardDisk());
    }
}

6、运行以上代码，可以输出以下结果：

获取电脑名称name:
Lenovo Computer
获取电脑信息Cpu：
i9 13代
获取电脑内存信息Memory:
内存48G
获取硬盘信息hardDis:
固态硬盘2T

以上就是使用建造者模式的示例代码和详解。建造者模式将对象的构建过程分解为多个步骤，使得创建复杂对象变得灵活和可扩展。

四、总结

1、建造者模式的优点：

1. 提供了将复杂对象的构建过程和表示分离的能力，使得构建过程可以独立于表示而变化。
2. 可以隐藏复杂对象的创建细节，使得客户端代码可以直接使用已经构建好的对象，而不需要知道具体的构建过程。
3. 可以通过改变具体的建造者和指导者来创建不同的产品，使得客户端代码可以使用不同的建造者来构建不同的产品实例。
4. 可以避免在客户端代码中直接创建复杂对象，从而提高代码的可维护性和可扩展性。

2、建造者模式的缺点：

1. 建造者模式会增加代码的复杂度，需要定义多个类和接口来实现建造者和指导者，增加了系统的抽象层次。
2. 如果产品的构建过程相对简单，或者产品的结构相对稳定，使用建造者模式可能会显得过于复杂和冗余。
3. 建造者模式在创建对象时需要一定的性能开销，因为需要额外的对象构建过程和对象组装操作。

如有不足欢迎指出，期待与大家一起进步--------------