【设计模式】-建造者模式

Java建造者模式：创建复杂对象的灵活构建者

在软件开发中，我们经常遇到需要创建一个复杂对象的情况。如果使用传统的构造函数进行对象创建，可能会导致构造函数参数过多，难以管理和维护。建造者模式（Builder  Pattern）通过引入建造者对象来逐步构建复杂对象，使得对象的构建过程更加灵活、可控，同时还能提供更好的代码可读性和维护性。

一、原理

建造者模式的核心思想是将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。具体来说，建造者模式通过将对象的构建过程委派给不同的建造者类，每个建造者类都负责创建对象的一部分，并最终将这些部分组装成完整的对象。

它由四个主要的角色组成：产品类（Product）、抽象建造者类（Builder）、具体建造者类（ConcreteBuilder）和指导者类（Director）

• 产品类（Product）：表示最终构建的对象。该类具有一些属性，可以通过设置相应的setter方法进行赋值，并且定义了一个展示产品的方法。
• 抽象建造者类（Builder）：定义了产品构建的抽象方法。包括构建不同部分的方法和获取最终产品的方法，由具体建造者类来实现。
• 具体建造者类（ConcreteBuilder）：继承自抽象建造者类，实现了具体的构建过程。包括构建不同部分和获取最终产品的方法。
• 指导者类（Director）：负责使用具体的建造者类来构建产品。通过调用具体建造者的方法来完成产品的构造，并最终返回一个完整的产品对象。

产品类

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    public void show() {
        System.out.println("Product: " + partA + ", " + partB + ", " + partC);
    }
}

抽象建造者类

public abstract class Builder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public abstract Product buildProduct();
}

具体建造者类

public class ConcreteBuilder extends Builder {
   private Product product = new Product();

    @Override
    public void buildPartA() {
        product.setPartA("生产线1>>>-------->产品A");
    }

    @Override
    public void buildPartB() {
        product.setPartB("生产线1>>>-------->产品B");
    }

    @Override
    public void buildPartC() {
        product.setPartC("生产线1>>>-------->产品C");
    }

    @Override
    public Product buildProduct() {
        return product;
    }
}

指导者类

public class Director {
   public Builder construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder;
    }
}

测试

public class Client {
    public static void main(String[] args) {
        // 指导者
        Director director = new Director();
        // 生产线1
        Builder construct = director.construct(new ConcreteBuilder());
        Product product = construct.buildProduct();

        // 显示生产了什么产品
        product.show();
    }
}

运行结果如下:

 观察代码，可以发现建造者模式的流程如下：

1. 第一步，创建指导者(Director)对象和具体建造者(ConcreteBuilder)对象来开始构建创建过程。
2. 第二步，指导者(Director)对象根据具体的建造者类完成建造过程，调用具体建造者的方法来构建产品的各个部分。也就是其方法中的builder.buildPartA();  builder.buildPartB(); builder.buildPartC();
3. 建造者将构建好的部分返回给指导者。
4. 指导者最终返回一个完整的产品对象，供客户端使用。

也就说，Product这个类属性的创建，不由它自身来控制，而是由具体的指导者(Director)对象来控制

那这样感觉把一个对象的创建变得复杂化了，为什么这么做呢? 这么做有什么好处和坏处呢??

优点：

• 可以将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

• 通过增加新的具体建造者类，可以轻松扩展和改变产品的建造过程，符合开闭原则。

• 使用建造者模式可以隐藏产品的内部细节，对客户端来说只关心如何创建对象，而不需要关心具体的构建过程。

缺点：

• 增加了类的数量，增加了代码的复杂性。

• 对于简单的对象，使用建造者模式可能会显得繁琐。如果一个对象就那么几个字段，且其字段的使用场景比较固定，再用建造者模式就很繁琐了，还不够费劲的呢...

适用场景

• 需要创建的对象具有复杂的内部结构，创建过程需要多个步骤。

• 需要创建的对象的属性之间有一定的依赖关系。

• 需要创建的对象的表示有多种方式，可以通过建造者模式灵活配置建造过程，得到不同的表示结果。

总结

建造者模式通过将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。它可以帮助我们创建复杂的对象，并保证对象的构建过程可配置和可扩展。在实际应用中，建造者模式具有较高的灵活性和可扩展性