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

前言

在面向对象的软件开发中，构建复杂对象时经常会遇到许多挑战。一种常见的解决方案是使用设计模式，其中建造者模式是一个强大而灵活的选择。本文将深入探讨建造者模式的原理、结构、优点以及如何在实际项目中应用它。

一、复杂的对象

public class Computer {
    private String ram;
    private String hardDisk;
    private String cpu;
    // ...可能还有更多参数...

    public Computer(String ram, String hardDisk, String cpu) {
        this.ram = ram;
        this.hardDisk = hardDisk;
        this.cpu = cpu;
        // ...初始化更多参数...
    }

    // getters and setters...
}

// 使用构造函数创建对象，参数多且容易混淆
Computer computer = new Computer("16GB", "1TB", "Intel i7");

上面代码比较简单，但是如果 Computer 类有更多的参数，构造函数将会变得非常长，而且在创建 Computer 对象时，传递参数的顺序非常重要，一旦顺序错误，就会创建出一个配置错误的对象。此外，如果参数有默认值，那么用户还需要记住哪些参数是必须的，哪些是可选的，这增加了使用的复杂性。

我们可以总结出创建复杂对象时可能会遇到的问题包括：

参数过多：构造函数或者 setter 方法的参数可能会非常多，导致代码难以阅读和维护。
参数顺序：容易混淆参数的顺序，特别是当有多个相同类型的参数时。
不够灵活：如果创建过程中需要多个步骤，使用构造函数或 setter 方法就不够灵活。
不可读性：代码的可读性差，特别是在没有注释的情况下，很难理解每个参数的意义。

二、建造者模式

建造者模式是一种创建型设计模式，旨在将复杂对象的构建过程与其表示分离。通过使用建造者模式，可以使客户端代码与对象的内部结构解耦，从而使构建过程更加灵活，并且更易于维护和扩展。

三、建造者模式的核心组成部分

在这里插入图片描述

建造者模式通常包括以下几个关键组件：

产品（Product）：表示被构建的复杂对象。产品类通常包含多个属性，并且可能包含一些复杂的业务逻辑。
抽象建造者（Builder）：定义了构建产品所需的接口。抽象建造者通常包括一系列方法来构建产品的各个部分。
具体建造者（Concrete Builder）：实现了抽象建造者接口，负责实际构建产品的各个部分，并提供方法来获取最终的产品实例。
指挥者（Director）：负责调用建造者的方法来构建产品，但不直接创建产品的实例。指挥者通常根据一定的构建步骤来组织构建过程。

四、运用建造者模式

场景假设：我们要构建一台计算机，它有不同的部件，比如 CPU、内存、硬盘等。我们将使用建造者模式来构建这台计算机。

定义产品类：首先，确定需要构建的复杂对象的属性和方法，并创建相应的产品类。这个产品类应该包含对象的所有属性，并提供相应的 getter 和 setter 方法。

/**
 * 产品类：计算机
 */
public class Computer {
    private String cpu;       // CPU
    private String memory;    // 内存
    private String hardDisk;  // 硬盘

    // 省略构造函数和 getter/setter方法
}

创建抽象建造者接口：定义一个抽象建造者接口，该接口包含构建产品各个部件的抽象方法。这些方法代表构建产品所需的不同步骤。

/**
 * 抽象建造者接口
 */
public interface ComputerBuilder {
    // 构建CPU
    void buildCPU();

    // 构建内存
    void buildMemory();

    // 构建硬盘
    void buildHardDisk();

    // 构建计算机
    Computer build();
}

实现具体建造者类：创建一个或多个具体建造者类，实现抽象建造者接口。每个具体建造者类负责实现构建产品各个部件的具体方法，并在最后返回构建好的产品。

/**
 * 具体建造者类：桌面计算机建造者
 */
public class DesktopComputerBuilder implements ComputerBuilder {
    private Computer computer;  // 待构建的计算机对象

    public DesktopComputerBuilder() {
        this.computer = new Computer();
    }

    @Override
    public void buildCPU() {
        computer.setCpu("Intel Core i7");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("16GB DDR4");
    }

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

    @Override
    public Computer build() {
        // 返回构建好的计算机对象
        return computer;
    }
}

创建指挥者类：定义一个指挥者类，该类负责使用具体建造者对象构建最终的产品。指挥者类知道构建者的具体实现细节，但与产品的实际构建过程无关。

/**
 * 指挥者类：计算机指挥者
 */
public class ComputerDirector {
    private ComputerBuilder computerBuilder;  // 建造者对象

    public ComputerDirector(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    // 使用建造者构建计算机对象
    public Computer construct() {
        // 按照顺序调用建造者的方法来构建计算机
        computerBuilder.buildCPU();
        computerBuilder.buildMemory();
        computerBuilder.buildHardDisk();
        // 返回构建好的计算机对象
        return computerBuilder.build();
    }
}

使用建造者模式构建对象：在客户端代码中，创建具体的建造者对象，并将其传递给指挥者类。然后，通过指挥者类调用相应的方法来构建产品。最终，客户端代码可以获取构建好的产品并使用它。

public class Main {
    public static void main(String[] args) {
        // 创建桌面计算机的建造者对象
        ComputerBuilder desktopBuilder = new DesktopComputerBuilder();
        // 创建计算机指挥者对象，并传入桌面计算机的建造者
        ComputerDirector director = new ComputerDirector(desktopBuilder);
        // 使用指挥者构建计算机对象
        Computer desktop = director.construct();
        // 输出构建好的桌面计算机的配置信息
        System.out.println("Desktop Computer Configuration:");
        System.out.println(desktop);
    }
}

/*
    在一些简单的情况下，可以省略指挥者（Director）类。
    特别是当只有一个具体建造者（Concrete Builder）时，
    客户端代码可以直接调用具体建造者的方法来构建产品，而不需要指挥者类。
*/
public class Main {
    public static void main(String[] args) {
        // 创建桌面计算机的建造者对象
        ComputerBuilder desktopBuilder = new DesktopComputerBuilder();
        // 使用桌面计算机的建造者直接构建计算机对象
        Computer desktop = desktopBuilder.buildCPU()
                                        .buildMemory()
                                        .buildHardDisk()
                                        .build();
        // 输出构建好的桌面计算机的配置信息
        System.out.println("Desktop Computer Configuration:");
        System.out.println(desktop);
    }
}

在上面的例子中，我们定义了 Computer 类作为产品，ComputerBuilder 作为具体建造者来创建产品，ComputerDirector 作为指导者确定创建产品时遵循的步骤流程。客户端代码只需通过 ComputerDirector 便能构建 Computer 对象，这样就隐藏了构建细节，使得客户端代码更加简洁和易于维护。

五、建造者模式的应用场景

建造者模式适用于以下几种场景：

复杂对象的创建：当创建的对象非常复杂，包含多个组成部分时，建造者模式可以帮助管理复杂性，使得代码更加清晰。

// 假设我们需要创建一个复杂的 Pizza 对象，它包含多种配料和选项。
// 产品类
public class Pizza {
    private String dough;
    private String sauce;
    private String topping;

    // 私有构造器
    private Pizza(Builder builder) {
        this.dough = builder.dough;
        this.sauce = builder.sauce;
        this.topping = builder.topping;
    }

    // Builder类
    public static class Builder {
        private String dough;
        private String sauce;
        private String topping;

        public Builder withDough(String dough) {
            this.dough = dough;
            return this;
        }

        public Builder withSauce(String sauce) {
            this.sauce = sauce;
            return this;
        }

        public Builder withTopping(String topping) {
            this.topping = topping;
            return this;
        }

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

// 客户端代码
// 在创建 Pizza 时，可以根据需要选择是否设置 dough、sauce、topping
Pizza pizza = new Pizza.Builder()
                .withDough("cross")
                .withSauce("mild")
                .withTopping("ham and pineapple")
                .build();

构造过程需要分步骤进行：如果一个对象的构造过程需要分多个步骤或者阶段来完成，建造者模式允许你逐步构造对象，而不是一次性通过一个巨大的构造函数完成。

// 倘若 House 对象的构建，需要分步骤设置地基、结构、屋顶和内部装修。
// 产品类
public class House {
    private String foundation;
    private String structure;
    private String roof;
    private String interior;

    private House(Builder builder) {
        this.foundation = builder.foundation;
        this.structure = builder.structure;
        this.roof = builder.roof;
        this.interior = builder.interior;
    }

    // Builder类
    public static class Builder {
        private String foundation;
        private String structure;
        private String roof;
        private String interior;

        public Builder withFoundation(String foundation) {
            this.foundation = foundation;
            return this;
        }

        public Builder withStructure(String structure) {
            this.structure = structure;
            return this;
        }

        public Builder withRoof(String roof) {
            this.roof = roof;
            return this;
        }

        public Builder withInterior(String interior) {
            this.interior = interior;
            return this;
        }

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

// 客户端代码
// 在创建对象之前，可严格管控步骤的先后顺序
House house = new House.Builder()
                .withFoundation("concrete")
                .withStructure("wooden")
                .withRoof("shingle")
                .withInterior("painted")
                .build();

同一构建过程不同表示：当需要根据不同的需求和过程来创建不同的对象表示时，建造者模式提供了很好的解决方案。

// 如果我们有一个 Car 对象，它可以有不同的配置，例如经济型和豪华型。
// 产品类
public class Car {
    private String engine;
    private String seats;
    private String navigationSystem;

    private Car(Builder builder) {
        this.engine = builder.engine;
        this.seats = builder.seats;
        this.navigationSystem = builder.navigationSystem;
    }

    // Builder类
    public static class Builder {
        private String engine;
        private String seats;
        private String navigationSystem;

        public Builder withEngine(String engine) {
            this.engine = engine;
            return this;
        }

        public Builder withSeats(String seats) {
            this.seats = seats;
            return this;
        }

        public Builder withNavigationSystem(String navigationSystem) {
            this.navigationSystem = navigationSystem;
            return this;
        }

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

// 客户端代码
// 根据不同配置，满足不同需求
Car economyCar = new Car.Builder()
                    .withEngine("1.5L")
                    .withSeats("cloth")
                    .build();

Car luxuryCar = new Car.Builder()
                    .withEngine("3.0L V6")
                    .withSeats("leather")
                    .withNavigationSystem("advanced")
                    .build();

参数多且复杂：当构造函数的参数非常多，且有些可能是可选的，建造者模式可以帮助组织这些参数，使得构造函数不会过于庞大和复杂。

// 倘若 Order 对象可能包含多个可选的配置项，如礼品包装、快递服务、优惠券等，
// 使用建造者模式可以让客户端代码清晰地指定所需的配置。
// 产品类：具有多个配置参数，其中一些是可选的。
public class Order {
    private String product;
    private boolean giftWrap;
    private boolean expressDelivery;
    private String couponCode;

    // 私有构造器，只能通过Builder类构建Order对象
    private Order(Builder builder) {
        this.product = builder.product;
        this.giftWrap = builder.giftWrap;
        this.expressDelivery = builder.expressDelivery;
        this.couponCode = builder.couponCode;
    }

    // Builder 类：提供了一个链式 API 来设置 Order 对象的属性
    public static class Builder {
        private String product;
        private boolean giftWrap;
        private boolean expressDelivery;
        private String couponCode;

        public Builder(String product) {
            this.product = product;
        }

        public Builder setGiftWrap(boolean giftWrap) {
            this.giftWrap = giftWrap;
            return this;
        }

        public Builder setExpressDelivery(boolean expressDelivery) {
            this.expressDelivery = expressDelivery;
            return this;
        }

        public Builder setCouponCode(String couponCode) {
            this.couponCode = couponCode;
            return this;
        }

        // 构建方法：创建一个Order对象并返回
        public Order build() {
            return new Order(this);
        }
    }
}

// 客户端使用：创建一个 Order 对象
Order order = new Order.Builder("Product1")
                .setGiftWrap(true)
                .setExpressDelivery(true)
                .setCouponCode("DISCOUNT10")
                .build();

六、小结

建造者模式是一种创建复杂对象的有效方式，它允许我们按照步骤构建对象，从而使得构建过程更加灵活和可配置。例如，在 Java 中，StringBuilder 是建造者模式的一个典型应用，它允许我们通过多个方法调用来构建最终的字符串，而不是一次性传入所有的字符串内容。另一个例子是流式 API，如 Java 8 的 Stream API，它允许通过链式调用来构建复杂的查询。通过将构建过程与表示分离，建造者模式提高了代码的可读性和可维护性，同时也使得代码更加易于扩展和重用。