Spring框架之建造者模式 (Builder Pattern)

🕗 发布于 2024-11-15 19:33 建造者模式 java 开发语言

建造者模式（Builder Pattern）详解

建造者模式（Builder Pattern）是一种 创建型设计模式，它的主要作用是将一个复杂对象的构建过程与其表示分离，使得相同的构建过程可以创建不同的表示。建造者模式尤其适用于创建过程复杂但组成对象相对稳定的场景，如：构建具有多个步骤的复杂对象、构建不可变对象（immutable objects）等。

1. 建造者模式的定义

1.1 什么是建造者模式？

建造者模式将一个复杂对象的构建过程封装到不同的 Builder 对象 中，使得客户端不必关心对象的构建细节。客户端通过指挥者（Director）来指导建造者生成对象。通过使用建造者模式，可以提高代码的可读性和可维护性，减少构建过程中潜在的错误。

1.2 建造者模式的特点

封装复杂的创建过程：将复杂对象的创建过程封装到建造者类中，从而简化对象的创建。
提高代码的灵活性和可扩展性：通过定义不同的建造者，可以创建不同类型的对象。
遵循开闭原则：可以方便地增加新的建造者类，而无需修改现有的代码。

2. 建造者模式的结构

建造者模式通常由以下几个角色组成：

Builder（抽象建造者）：
- 定义创建复杂对象的各个步骤的接口，通常包括多个部件的构建方法。
ConcreteBuilder（具体建造者）：
- 实现 Builder 接口，构建并组装各个部件，最终返回产品对象。
Product（产品类）：
- 最终要创建的复杂对象。
Director（指挥者）：
- 负责安排构建的步骤。它通过调用 Builder 中的方法来构建最终的产品对象。
Client（客户端）：
- 决定使用哪个 ConcreteBuilder 来生成所需的 Product。

类图

    +-------------------+
    |     Director      |
    +-------------------+
           |
           |
           v
    +-------------------+
    |     Builder       |<-----------------+
    +-------------------+                  |
    | + buildPartA()    |                  |
    | + buildPartB()    |                  |
    | + getResult()     |                  |
    +-------------------+                  |
           ^                               |
           |                               |
  +-------------------+          +-------------------+
  | ConcreteBuilderA  |          | ConcreteBuilderB  |
  +-------------------+          +-------------------+
  | + buildPartA()    |          | + buildPartA()    |
  | + buildPartB()    |          | + buildPartB()    |
  | + getResult()     |          | + getResult()     |
  +-------------------+          +-------------------+
           |
           |
           v
    +-------------------+
    |     Product       |
    +-------------------+

3. 建造者模式的实现

为了更好地理解建造者模式，我们使用一个简单的示例来演示其工作原理。假设我们要构建一辆汽车 Car 对象，它具有引擎、轮胎和车门等多个部分。不同的汽车类型（如运动型汽车、SUV）会有不同的组件配置。

3.1 Java 示例代码

// 产品类：Car
class Car {
    private String engine;
    private String wheels;
    private String doors;

    // Setters
    public void setEngine(String engine) {
        this.engine = engine;
    }

    public void setWheels(String wheels) {
        this.wheels = wheels;
    }

    public void setDoors(String doors) {
        this.doors = doors;
    }

    @Override
    public String toString() {
        return "Car [Engine=" + engine + ", Wheels=" + wheels + ", Doors=" + doors + "]";
    }
}

// 抽象建造者接口
interface CarBuilder {
    void buildEngine();
    void buildWheels();
    void buildDoors();
    Car getResult();
}

// 具体建造者：运动型汽车建造者
class SportsCarBuilder implements CarBuilder {
    private Car car = new Car();

    @Override
    public void buildEngine() {
        car.setEngine("V8 Engine");
    }

    @Override
    public void buildWheels() {
        car.setWheels("Sports Wheels");
    }

    @Override
    public void buildDoors() {
        car.setDoors("2 Doors");
    }

    @Override
    public Car getResult() {
        return car;
    }
}

// 具体建造者：SUV 建造者
class SUVCarBuilder implements CarBuilder {
    private Car car = new Car();

    @Override
    public void buildEngine() {
        car.setEngine("V6 Engine");
    }

    @Override
    public void buildWheels() {
        car.setWheels("All-terrain Wheels");
    }

    @Override
    public void buildDoors() {
        car.setDoors("4 Doors");
    }

    @Override
    public Car getResult() {
        return car;
    }
}

// 指挥者类
class Director {
    private CarBuilder builder;

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

    public Car construct() {
        builder.buildEngine();
        builder.buildWheels();
        builder.buildDoors();
        return builder.getResult();
    }
}

// 测试客户端
public class BuilderPatternDemo {
    public static void main(String[] args) {
        Director director = new Director();

        // 生产运动型汽车
        CarBuilder sportsCarBuilder = new SportsCarBuilder();
        director.setBuilder(sportsCarBuilder);
        Car sportsCar = director.construct();
        System.out.println(sportsCar);

        // 生产 SUV 汽车
        CarBuilder suvCarBuilder = new SUVCarBuilder();
        director.setBuilder(suvCarBuilder);
        Car suvCar = director.construct();
        System.out.println(suvCar);
    }
}

输出结果：

Car [Engine=V8 Engine, Wheels=Sports Wheels, Doors=2 Doors]
Car [Engine=V6 Engine, Wheels=All-terrain Wheels, Doors=4 Doors]

4. 建造者模式的应用场景

建造者模式适合以下场景：

需要生成的对象具有复杂的内部结构，或者需要对其生成过程进行分步控制。
产品类的创建步骤稳定，但产品内部的组成部分面临复杂变化时。
当创建对象的算法独立于该对象的组成部分以及装配方式时。
避免构造函数过多参数的情况，尤其是很多参数是可选的或有默认值时。

5. 建造者模式的优缺点

5.1 优点

更好的控制对象创建过程：允许对象的构建过程被细化，使得构建过程更清晰。
代码更具可读性和可维护性：通过分离构建过程和表示，可以清晰地表达如何创建复杂对象。
更好的扩展性：可以通过引入新的具体建造者来创建不同的产品，而无需修改现有代码。

5.2 缺点

增加系统的复杂性：需要引入多个新的类（如 Builder 和 Director），可能导致类数量增加。
适用于复杂对象的创建：如果产品过于简单，则使用建造者模式可能会显得小题大做。

6. 建造者模式的扩展

6.1 链式调用（Fluent Interface）

在实际开发中，建造者模式经常与链式调用（Fluent Interface）结合使用，使得客户端代码更加简洁。例如：

// 产品类：Car
class Car {
    private String engine;
    private String wheels;
    private String doors;

    public Car setEngine(String engine) {
        this.engine = engine;
        return this;
    }

    public Car setWheels(String wheels) {
        this.wheels = wheels;
        return this;
    }

    public Car setDoors(String doors) {
        this.doors = doors;
        return this;
    }

    @Override
    public String toString() {
        return "Car [Engine=" + engine + ", Wheels=" + wheels + ", Doors=" + doors + "]";
    }
}

// 测试客户端
public class FluentBuilderDemo {
    public static void main(String[] args) {
        Car car = new Car()
                .setEngine("V6 Engine")
                .setWheels("All-terrain Wheels")
                .setDoors("4 Doors");
        System.out.println(car);
    }
}

6.2 结合抽象工厂模式（Abstract Factory）

建造者模式可以与抽象工厂模式结合使用，以构建更复杂的对象体系。

7. 建造者模式的实际应用

Java StringBuilder 类：
- Java 中的 StringBuilder 和 StringBuffer 就是建造者模式的一个应用实例，用于高效地创建和拼接字符串。
数据库查询构造器：
- 如 MyBatis 中的 SqlBuilder、Hibernate 的 CriteriaBuilder，都使用了建造者模式来构建复杂的查询语句。
GUI 构建器：
- 在创建复杂的用户界面时，可以使用建造者模式来一步步构建 UI 组件。

8. 总结

建造者模式是一种非常实用的设计模式，尤其适用于需要分步骤创建复杂对象的场景。它通过将对象的构建过程与其表示分离，提供了一种灵活的对象创建方式。

优点：封装复杂创建、提高可读性和可扩展性。
缺点：增加类的复杂度，适用于复杂对象。
适用场景：对象创建复杂、多步骤创建、不希望使用庞大的构造函数。

原文地址：https://blog.csdn.net/m0_61840987/article/details/143625374

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：C++_priority_queue(优先级队列)
下一篇：Java中的时间类型：从java.util.Date到java.time

关于强化学习的一份介绍
假设你在一家赌场里面对一台有 k 个摇臂的老虎机，每个摇臂都有不同的中奖概率。每次拉其中一个摇臂，你都会得到一个奖励（通常是金钱）。你的目标是在有限次尝试内最大化累计奖励。在这个问题中，“摇臂”代表不
阅读更多2024-11-17
ADS学习笔记 5. 微带天线设计
ADS学习笔记 5. 微带天线设计
阅读更多2024-11-17
D70【 python 接口自动化学习】- python 基础之数据库
1. 使用Python实现读取写入数据库操作ps.今天去看航展了，歼20简直不要太快，明天再来补作业~
阅读更多2024-11-17
AI写作（十）发展趋势与展望（10/10）
例如，在阅读一篇复杂的文章时，AI 写作工具可以提取出关键信息，让学生快速掌握文章的核心内容。AI 写作助手可以根据用户输入的主题和要求，自动生成文章的大纲和结构，帮助学生和教师快速了解文章的主要内容
阅读更多2024-11-17
用户自定义IP核——ZYNQ学习笔记6
通过自定义一个 LED IP 核，通过 PS 端的程序来控制底板上 PL 端 LED1 呈现呼吸灯的效果，并且 PS 可以通过 AXI 接口来控制呼吸灯的开关和呼吸的频率。
阅读更多2024-11-17
从零开始学习 sg200x 多核开发之 eth0 自动使能并配置静态IP
本文将介绍如何通过配置文件启动自动使能有线网络。
阅读更多2024-11-17
软考之RESTful 架构的特点
为了实现前后端分离，首先需要设计并定义 RESTful API。API 应该清晰地定义每个资源的 URI、支持的 HTTP 方法、请求和响应的格式等。资源建模：识别系统中需要哪些资源，并为每个资源分配
阅读更多2024-11-17
C++初阶——优先队列
/创建一个默认的优先队列//默认是priority_queue<int,vector<int>,less<int>()> pq1;//改为小根堆return 0;
阅读更多2024-11-17
【AI图像生成网站&Golang】JWT认证与令牌桶算法
在 JWT 中，Payload 就是 Token 的核心数据部分，用来存储那些需要在两方之间传递的信息。它包含了自定义的声明（Claims），例如用户的标识（user_id）或过期时间（exp）。单位
阅读更多2024-11-17
怎样遵守编程规范，减少和控制C++编程中出现的bug？
通过遵循 C++ 标准和最佳实践、编写规范的代码、进行防御性编程、使用静态分析和代码审查、编写单元测试和回归测试，以及记录日志和使用调试工具，你可以有效地减少和控制 C++ 编程中出现的 bug。这些
阅读更多2024-11-17