模式設計之創建對象：建造者模式（Builder模式）詳解

在軟件開發過程中有時需要創建一個複雜的對象，這個複雜對象通常由多個子部件按一定的步驟組合而成。例如，計算機是由 CPU、主板、內存、硬盤、顯卡、機箱、顯示器、鍵盤、鼠標等部件組裝而成的，採購員不可能自己去組裝計算機，而是將計算機的配置要求告訴計算機銷售公司，計算機銷售公司安排技術人員去組裝計算機，然後再交給要買計算機的採購員。

生活中這樣的例子很多，如遊戲中的不同角色，其性別、個性、能力、臉型、體型、服裝、髮型等特性都有所差異；還有汽車中的方向盤、發動機、車架、輪胎等部件也多種多樣；每封電子郵件的發件人、收件人、主題、內容、附件等內容也各不相同。

以上所有這些產品都是由多個部件構成的，各個部件可以靈活選擇，但其創建步驟都大同小異。這類產品的創建無法用前面介紹的工廠模式描述，只有建造者模式可以很好地描述該類產品的創建。

模式的定義與特點

建造者（Builder）模式的定義：指將一個複雜對象的構造與它的表示分離，使同樣的構建過程可以創建不同的表示，這樣的設計模式被稱爲建造者模式。它是將一個複雜的對象分解爲多個簡單的對象，然後一步一步構建而成。它將變與不變相分離，即產品的組成部分是不變的，但每一部分是可以靈活選擇的。

該模式的主要優點如下：

封裝性好，構建和表示分離。
擴展性好，各個具體的建造者相互獨立，有利於系統的解耦。
客戶端不必知道產品內部組成的細節，建造者可以對創建過程逐步細化，而不對其它模塊產生任何影響，便於控制細節風險。

其缺點如下：

產品的組成部分必須相同，這限制了其使用範圍。
如果產品的內部變化複雜，如果產品內部發生變化，則建造者也要同步修改，後期維護成本較大。

應用場景：

生成的產品對象有複雜的內部結構，且這些產品對象都有相同的構造。
隔離複雜對象的創建和使用過程，而且相同的創建流程，不同的參數設置生成不同的產品。
適合一個有較多零件（屬性設置）的產品（對象）創建過程。

建造者與抽象工廠模式的比較：

建造者模式返回的是一個完整的產品，抽象工廠模式返回的是一系列相關的產品，這些產品處在不同的產品等級，構成了產品族。
抽象工廠模式中，客戶端實例化工廠類並調用工廠方法，生成相應的產品；在建造者模式中，客戶端不直接調用建造者的方法生成產品，而是由指揮者調用生產者生成產品，指揮者在生成過程中控制建造者的步驟和參數設置，建造者模式側重一步步構造出一個複雜對象，最後返回一個完整的對象。
對比抽象工廠和建造者，抽象工廠生產的是一系列產品，例如小米生產的手機，空氣清新器，路由器，監控攝像頭，這是一系列產品；建造者就是一條生產線，生產一個複雜的產品，通過生產輪胎，軸承，車架，車門等，最後組裝成一輛汽車。

建造者（Builder）模式和工廠模式的關注點不同：建造者模式注重零部件的組裝過程，而工廠方法模式更注重零部件的創建過程，但兩者可以結合使用。

模式的結構與實現

建造者（Builder）模式由產品、抽象建造者、具體建造者、指揮者等 4 個要素構成，現在我們來分析其基本結構和實現方法。

1. 模式的結構

建造者（Builder）模式的主要角色如下。

產品角色（Product）：它是包含多個組成部件的複雜對象，由具體建造者來創建其各個零部件。
抽象建造者（Builder）：它是一個包含創建產品各個子部件的抽象方法的接口，通常還包含一個返回複雜產品的方法 getResult()。
具體建造者(Concrete Builder）：實現 Builder 接口，完成複雜產品的各個部件的具體創建方法。
指揮者（Director）：它調用建造者對象中的部件構造與裝配方法完成複雜對象的創建，在指揮者中不涉及具體產品的信息。

其結構圖如圖 1 所示。

圖1 建造者模式的結構圖

2. 模式的實現

圖 1 給出了建造者（Builder）模式的主要結構，其相關類的代碼如下。

(1) 產品角色：包含多個組成部件的複雜對象。

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() {
        //顯示產品的特性
    }
}

(2) 抽象建造者：包含創建產品各個子部件的抽象方法。

abstract class Builder {
    //創建產品對象
    protected Product product = new Product();

    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract void buildPartC();

    //返回產品對象
    public Product getResult() {
        return product;
    }
}

(3) 具體建造者：實現了抽象建造者接口。

public class ConcreteBuilder extends Builder {
    public void buildPartA() {
        product.setPartA("建造 PartA");
    }

    public void buildPartB() {
        product.setPartB("建造 PartB");
    }

    public void buildPartC() {
        product.setPartC("建造 PartC");
    }
}

(4) 指揮者：調用建造者中的方法完成複雜對象的創建。

class Director {
    private Builder builder;

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

    //產品構建與組裝方法
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

(5) 客戶類。

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();
    }
}

模式的應用實例

【例1】用建造者（Builder）模式描述客廳裝修。

分析：客廳裝修是一個複雜的過程，它包含牆體的裝修、電視機的選擇、沙發的購買與佈局等。客戶把裝修要求告訴項目經理，項目經理指揮裝修工人一步步裝修，最後完成整個客廳的裝修與佈局，所以本實例用建造者模式實現比較適合。

這裏客廳是產品，包括牆、電視和沙發等組成部分。具體裝修工人是具體建造者，他們負責裝修與牆、電視和沙發的佈局。項目經理是指揮者，他負責指揮裝修工人進行裝修。

另外，客廳類中提供了 show() 方法，可以將裝修效果圖顯示出來（點此下載裝修效果圖的圖片）。客戶端程序通過對象生成器類 ReadXML 讀取 XML 配置文件中的裝修方案數據（點此下載 XML 文件），調用項目經理進行裝修。其類圖如圖 2 所示。

圖2 客廳裝修的結構圖

程序代碼如下：

package Builder;

import java.awt.*;
import javax.swing.*;

public class ParlourDecorator {
    public static void main(String[] args) {
        try {
            Decorator d;
            d = (Decorator) ReadXML.getObject();
            ProjectManager m = new ProjectManager(d);
            Parlour p = m.decorate();
            p.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

//產品：客廳
class Parlour {
    private String wall;    //牆
    private String TV;    //電視
    private String sofa;    //沙發 

    public void setWall(String wall) {
        this.wall = wall;
    }

    public void setTV(String TV) {
        this.TV = TV;
    }

    public void setSofa(String sofa) {
        this.sofa = sofa;
    }

    public void show() {
        JFrame jf = new JFrame("建造者模式測試");
        Container contentPane = jf.getContentPane();
        JPanel p = new JPanel();
        JScrollPane sp = new JScrollPane(p);
        String parlour = wall + TV + sofa;
        JLabel l = new JLabel(new ImageIcon("src/" + parlour + ".jpg"));
        p.setLayout(new GridLayout(1, 1));
        p.setBorder(BorderFactory.createTitledBorder("客廳"));
        p.add(l);
        contentPane.add(sp, BorderLayout.CENTER);
        jf.pack();
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

//抽象建造者：裝修工人
abstract class Decorator {
    //創建產品對象
    protected Parlour product = new Parlour();

    public abstract void buildWall();

    public abstract void buildTV();

    public abstract void buildSofa();

    //返回產品對象
    public Parlour getResult() {
        return product;
    }
}

//具體建造者：具體裝修工人1
class ConcreteDecorator1 extends Decorator {
    public void buildWall() {
        product.setWall("w1");
    }

    public void buildTV() {
        product.setTV("TV1");
    }

    public void buildSofa() {
        product.setSofa("sf1");
    }
}

//具體建造者：具體裝修工人2
class ConcreteDecorator2 extends Decorator {
    public void buildWall() {
        product.setWall("w2");
    }

    public void buildTV() {
        product.setTV("TV2");
    }

    public void buildSofa() {
        product.setSofa("sf2");
    }
}

//指揮者：項目經理
class ProjectManager {
    private Decorator builder;

    public ProjectManager(Decorator builder) {
        this.builder = builder;
    }

    //產品構建與組裝方法
    public Parlour decorate() {
        builder.buildWall();
        builder.buildTV();
        builder.buildSofa();
        return builder.getResult();
    }
}

package Builder;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;

class ReadXML {
    public static Object getObject() {
        try {
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("src/Builder/config.xml"));
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = "Builder." + classNode.getNodeValue();
            System.out.println("新類名：" + cName);
            Class<?> c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

運行結果如下：

圖3 客廳裝修的運行結果

模式的應用場景

建造者模式唯一區別於工廠模式的是針對複雜對象的創建。也就是說，如果創建簡單對象，通常都是使用工廠模式進行創建，而如果創建複雜對象，就可以考慮使用建造者模式。

當需要創建的產品具備複雜創建過程時，可以抽取出共性創建過程，然後交由具體實現類自定義創建流程，使得同樣的創建行爲可以生產出不同的產品，分離了創建與表示，使創建產品的靈活性大大增加。

建造者模式主要適用於以下應用場景：

相同的方法，不同的執行順序，產生不同的結果。
多個部件或零件，都可以裝配到一個對象中，但是產生的結果又不相同。
產品類非常複雜，或者產品類中不同的調用順序產生不同的作用。
初始化一個對象特別複雜，參數多，而且很多參數都具有默認值。

建造者模式和工廠模式的區別

通過前面的學習，我們已經瞭解了建造者模式，那麼它和工廠模式有什麼區別呢？

建造者模式更加註重方法的調用順序，工廠模式注重創建對象。
創建對象的力度不同，建造者模式創建複雜的對象，由各種複雜的部件組成，工廠模式創建出來的對象都一樣
關注重點不一樣，工廠模式只需要把對象創建出來就可以了，而建造者模式不僅要創建出對象，還要知道對象由哪些部件組成。
建造者模式根據建造過程中的順序不一樣，最終對象部件組成也不一樣。

模式的擴展

建造者（Builder）模式在應用過程中可以根據需要改變，如果創建的產品種類只有一種，只需要一個具體建造者，這時可以省略掉抽象建造者，甚至可以省略掉指揮者角色。

C++版建造者模式

#ifndef BUILDER_CLIENT_H
#define BUILDER_CLIENT_H


class Builder_client
{
public:
    explicit Builder_client();
    virtual ~Builder_client();

    virtual void run();
};

#endif // BUILDER_CLIENT_H


#include <QString>
#include "builder_client.h"
#include "builder_director.h"
#include "builder_concretea_builder.h"
#include "builder_product.h"

Builder_client::Builder_client()
{

}

Builder_client::~Builder_client()
{

}

void Builder_client::run()
{
    Builder_director* director = new Builder_director(new Builder_concreteA_builder());
    Builder_product* product =director->set_data("hello", "qiaowei");

     product->show();
}



#ifndef BUILDER_BUILDER_H
#define BUILDER_BUILDER_H

#include <QString>

class Builder_product;

class Builder_builder
{
public:
    explicit Builder_builder();
    virtual ~Builder_builder();

    Builder_product* get_result();

    virtual void set_groupA(QString groupA) = 0;
    virtual void set_groupB(QString groupB) = 0;

protected:
    Builder_product* product_;
};

#endif // BUILDER_BUILDER_H

#include "builder_builder.h"
#include "builder_product.h"

Builder_builder::Builder_builder()
    : product_(new Builder_product())
{
}

Builder_builder::~Builder_builder()
{
    if (nullptr != product_) {
        delete product_;
        product_ = nullptr;
    }
}

Builder_product *Builder_builder::get_result()
{
    return product_;
}


#ifndef BUILDER_CONCRETEA_BUILDER_H
#define BUILDER_CONCRETEA_BUILDER_H

#include "builder_builder.h"

class Builder_concreteA_builder : public Builder_builder
{
public:
    explicit Builder_concreteA_builder();
    virtual ~Builder_concreteA_builder();

    virtual void set_groupA(QString groupA);
    virtual void set_groupB(QString groupB);
};

#endif // BUILDER_CONCRETEA_BUILDER_H


#include "builder_concretea_builder.h"
#include "builder_product.h"

Builder_concreteA_builder::Builder_concreteA_builder()
{

}

Builder_concreteA_builder::~Builder_concreteA_builder()
{
    Builder_builder::~Builder_builder();
}

void Builder_concreteA_builder::set_groupA(QString groupA)
{
    product_->set_groupA(groupA);
}

void Builder_concreteA_builder::set_groupB(QString groupB)
{
    product_->set_groupB(groupB);
}


#ifndef BUILDER_DIRECTOR_H
#define BUILDER_DIRECTOR_H

#include <QString>

class Builder_builder;
class Builder_product;

class Builder_director
{
public:
    explicit Builder_director(Builder_builder* builder);
    virtual ~Builder_director();

    virtual Builder_product* set_data(QString a, QString b);

private:
    Builder_builder* builder_;
};

#endif // BUILDER_DIRECTOR_H

#include "builder_director.h"
#include "builder_builder.h"
#include "builder_product.h"

Builder_director::Builder_director(Builder_builder* builder)
{
    builder_ = builder;
}

Builder_director::~Builder_director()
{

}

Builder_product* Builder_director::set_data(QString a, QString b)
{
    builder_->set_groupA(a);
    builder_->set_groupB(b);

    return builder_->get_result();
}


#ifndef BUILDER_PRODUCT_H
#define BUILDER_PRODUCT_H

#include <QString>

class Builder_product
{
public:
    explicit Builder_product();
    virtual ~Builder_product();

    void set_groupA(const QString& groupA);

    void set_groupB(const QString& groupB);

    void show();

private:
    QString groupA_;
    QString groupB_;
};

#endif // BUILDER_PRODUCT_H


#include <QtDebug>
#include "builder_product.h"

Builder_product::Builder_product()
{

}

Builder_product::~Builder_product()
{

}

void Builder_product::set_groupA(const QString &groupA)
{
    groupA_ = groupA;
}

void Builder_product::set_groupB(const QString &groupB)
{
    groupB_ = groupB;
}

void Builder_product::show()
{
    qDebug()<< groupA_ << endl;
    qDebug()<< groupB_ << endl;
}

模式設計之創建對象：建造者模式（Builder模式）詳解

模式的定義與特點

模式的結構與實現

1. 模式的結構

2. 模式的實現

模式的應用實例

模式的應用場景

建造者模式和工廠模式的區別

模式的擴展

C++版建造者模式

2024年DataOps趨勢預測：AI不會取代數據工程師

雲原生週刊：K8s 中的服務和網絡｜ 2024.4.29

[轉帖]cpupower

今天，昨天，近七天，近30天，近90天，js封裝

華爲云云原生FinOps解決方案，釋放雲原生最大價值

模式設計之創建對象：建造者模式（Builder模式）詳解

模式設計之創建對象：原型模式（Prototype）詳解

Vim 項目重要維護者去世，Vim 之父以 Vim 9 悼念摯友

模式設計之結構型模式：外觀模式（Facade模式）詳解

模式設計之行爲模式：適配器模式（Adapter模式）詳解

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結