当前位置：首页 > news >正文

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

news 来源：原创 2024/9/29 3:22:40

前言

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

一、复杂的对象

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;       // CPUprivate String memory;    // 内存private String hardDisk;  // 硬盘// 省略构造函数和 getter/setter方法
}

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

/*** 抽象建造者接口*/
public interface ComputerBuilder {// 构建CPUvoid buildCPU();// 构建内存void buildMemory();// 构建硬盘void buildHardDisk();// 构建计算机Computer build();
}

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

/*** 具体建造者类：桌面计算机建造者*/
public class DesktopComputerBuilder implements ComputerBuilder {private Computer computer;  // 待构建的计算机对象public DesktopComputerBuilder() {this.computer = new Computer();}@Overridepublic void buildCPU() {computer.setCpu("Intel Core i7");}@Overridepublic void buildMemory() {computer.setMemory("16GB DDR4");}@Overridepublic void buildHardDisk() {computer.setHardDisk("1TB SSD");}@Overridepublic 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，它允许通过链式调用来构建复杂的查询。通过将构建过程与表示分离，建造者模式提高了代码的可读性和可维护性，同时也使得代码更加易于扩展和重用。