复杂对象的创建与组装 - 建造者模式（Builder Pattern）

建造者模式（Builder Pattern）

建造者模式（Builder Pattern）是一种创建型设计模式，它允许你分步骤构建复杂对象。该模式将一个复杂对象的构造与它的表示分离，使得同样的构建过程可以创建不同的表示。通过使用建造者模式，你可以避免大量参数化构造函数或多个重载构造函数带来的代码混乱，并且能够更容易地管理复杂的对象创建逻辑。

概念还是有一点抽象的
举个例子，作为一个平时打打游戏的同学，有时候会玩一种赛车游戏。赛车是可以自己定义与组装的。游戏中提供了各种各样的轮子，车体，引擎，悬架。。。 我们可以通过使用这些组件灵活地拼装出我们想要地自定义赛车。那么对这款游戏来说，我们自定义出来地车会有很多种类，那我们怎么实现这个效果呢？ 使用建造者模式，具体细节请继续往下阅读。

建造者模式（Builder Pattern）概述

建造者模式结构图

代码

1. 产品（Product）： 最终被构建出来的复杂对象。它可以是一个具体的类，也可以是包含多个组件的对象。产品对象并不知道如何创建自己；相反，它依赖于建造者来完成其组装。

public class Product {
    private List<String> parts = new ArrayList<>();

    public void add(String part) {
        parts.add(part);
    }

    public void show() {
        System.out.println("Product contains the following parts:");
        for (String part : parts) {
            System.out.println(part);
        }
    }
}

2. 抽象建造者（Builder）：接口或抽象类，声明了用于构建各个组件的方法。具体建造者必须实现这些方法，以提供特定类型的对象构建逻辑。

public interface Builder {
    void buildPartA();
    void buildPartB();
    Product getResult();
}

3. 具体建造者（ConcreteBuilder）：实现了 Builder 接口的具体类。每个具体建造者都对应一种特定的产品类型，并负责一步一步地构建该产品的不同部分。

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

    @Override
    public void buildPartA() {
        product.add("PartA");
    }

    @Override
    public void buildPartB() {
        product.add("PartB");
    }

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

4. 指挥者（Director）：指挥者类负责控制和协调建造者的操作顺序。它不直接创建产品实例，而是调用建造者提供的方法来逐步构建产品。这样做的好处是可以改变构建过程中的步骤顺序，而不影响客户端代码。

public class Director {
    private Builder builder;

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

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
    }
}

talk is cheap， show you my code

我们还是实现我们开头举的那个例子，实现一个可以自定义组装汽车的建造者模式代码。

class Car {
    private String body;
    private String engine;
    private String wheels;
    private String seats;
 
    // 私有构造函数，防止外部直接实例化
    private Car(CarBuilder builder) {
        this.body = builder.body;
        this.engine = builder.engine;
        this.wheels = builder.wheels;
        this.seats = builder.seats;
    }
 
    // 静态内部类，用于创建CarBuilder实例
    public static class CarBuilder {
        // 汽车部件
        protected String body;
        protected String engine;
        protected String wheels;
        protected String seats;
 
        // 设置车身的方法
        public CarBuilder setBody(String body) {
            this.body = body;
            return this; // 返回当前对象，支持链式调用
        }
 
        // 设置发动机的方法
        public CarBuilder setEngine(String engine) {
            this.engine = engine;
            return this;
        }
 
        // 设置车轮的方法
        public CarBuilder setWheels(String wheels) {
            this.wheels = wheels;
            return this;
        }
 
        // 设置座椅的方法
        public CarBuilder setSeats(String seats) {
            this.seats = seats;
            return this;
        }
 
        // 构建汽车的方法
        public Car build() {
            return new Car(this);
        }
    }
 
    // 展示汽车信息的方法
    @Override
    public String toString() {
        return "Car{" +
                "body='" + body + '\'' +
                ", engine='" + engine + '\'' +
                ", wheels='" + wheels + '\'' +
                ", seats='" + seats + '\'' +
                '}';
    }
}
 
// 具体建造者类：豪华车建造者
class LuxuryCarBuilder extends Car.CarBuilder {
    @Override
    public CarBuilder setBody(String body) {
        super.setBody("Luxury Body");
        return this;
    }
 
    @Override
    public CarBuilder setEngine(String engine) {
        super.setEngine("V8 Engine");
        return this;
    }
 
    @Override
    public CarBuilder setWheels(String wheels) {
        super.setWheels("Alloy Wheels");
        return this;
    }
 
    @Override
    public CarBuilder setSeats(String seats) {
        super.setSeats("Leather Seats");
        return this;
    }
}
 
// 具体建造者类：经济型车建造者
class EconomyCarBuilder extends Car.CarBuilder {
    @Override
    public CarBuilder setBody(String body) {
        super.setBody("Economy Body");
        return this;
    }
 
    @Override
    public CarBuilder setEngine(String engine) {
        super.setEngine("4 Cylinder Engine");
        return this;
    }
 
    @Override
    public CarBuilder setWheels(String wheels) {
        super.setWheels("Steel Wheels");
        return this;
    }
 
    @Override
    public CarBuilder setSeats(String seats) {
        super.setSeats("Fabric Seats");
        return this;
    }
}
 
// 指挥者类：汽车工厂
class CarDirector {
    private Car.CarBuilder builder;
 
    public CarDirector(Car.CarBuilder builder) {
        this.builder = builder;
    }
 
    // 指挥构建汽车的方法
    public Car constructCar() {
        return builder
                .setBody("Default Body") // 可以被具体建造者覆盖
                .setEngine("Default Engine") // 可以被具体建造者覆盖
                .setWheels("Default Wheels") // 可以被具体建造者覆盖
                .setSeats("Default Seats") // 可以被具体建造者覆盖
                .build();
    }
}
 
// 客户端代码
public class Main {
    public static void main(String[] args) {
        // 创建豪华车
        CarDirector luxuryDirector = new CarDirector(new LuxuryCarBuilder());
        Car luxuryCar = luxuryDirector.constructCar();
        System.out.println(luxuryCar);
 
        // 创建经济型车
        CarDirector economyDirector = new CarDirector(new EconomyCarBuilder());
        Car economyCar = economyDirector.constructCar();
        System.out.println(economyCar);
    }
}

在这个例子中，Car类有一个私有构造函数，只能通过CarBuilder内部类来创建实例。CarBuilder是一个抽象建造者，提供了设置汽车各个部件的方法，并返回当前对象以支持链式调用。LuxuryCarBuilder和EconomyCarBuilder是具体建造者，它们覆盖了CarBuilder中的方法以提供不同类型的汽车部件。CarDirector是指挥者，它使用CarBuilder接口来构建汽车，但允许具体建造者提供特定的实现。

客户端代码通过创建CarDirector实例并传递具体的CarBuilder来构建不同类型的汽车。这样，客户端代码与具体的汽车构建过程解耦，只需要知道如何创建指挥者和选择具体的建造者即可。

总结

建造者模式优点：

• 减少大量的构造函数参数：当一个类有很多可选参数时，可以通过建造者模式来避免长而复杂的构造函数签名。
• 提高代码可读性：通过链式调用（Fluent Interface），可以使对象创建更加直观和易懂。
• 易于扩展：如果需要添加新的组件或改变构建逻辑，只需新增具体建造者类，而不需要修改现有代码。
• 符合单一职责原则：建造者模式让每个类只专注于一件事，即构建某个特定类型的产品。

建造者模式的应用场景

• 复杂对象创建
• 多步骤过程
• 变种对象

建造者模式是一个非常有用的设计模式，特别是在需要处理具有多个可选参数或复杂创建逻辑的对象时。它帮助开发者更好地组织代码，提高系统的灵活性和可维护性。