[创建型模式]设计模式之建造者模式(Builder Pattern)

短命女 2022-04-11 04:19 185阅读 0赞

转自\[url\]http://www.cnblogs.com/jiese/p/3161076.html\[/url\]  
  
  
\[color=red\]\[b\]作用:\[/b\]\[/color\]  
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。  
  
Builder模式和AbstractFactory模式在功能上很相似，因为都是用来创建大的复杂的对象，它们的区别是：Builder模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说Builder模式中对象不是直接返回的。而在AbstractFactory模式中对象是直接返回的，AbstractFactory模式强调的是为创建多个相互依赖的对象提供一个同一的接口。  
  
  
\[color=red\]建造者模式和工厂模式非常相似呀，但是记住一点你就可以游刃有余的使用了：  
  
建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了；  
  
而工厂方法则重点是创建，你要什么对象我创造一个对象出来，组装顺序则不是他关心的。  
  
建造者模式使用的场景，一是产品类非常的复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式是非常合适  
  
1、  
工厂：产品类、抽象产品类、工厂类、抽象工厂类、客户端  
抽象工厂：产品类、抽象产品类、工厂类、抽象工厂类、客户端  
建造者：产品类、工厂类、抽象工厂类、指导者、客户端  
2、  
工厂：抽象工厂类只包含一个方法(创建一个产品)  
抽象工厂：抽象工厂类包含多个方法(创建多个产品)，多个方法可以使用可以不用  
建造者：抽象工厂类包含多个方法(创建多个产品),多个方法必须按一定顺序使用。  
\[/color\]  
  
  
适用于以下情况:  
  
1)当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。  
  
2)当构造过程必须允许被构造的对象有不同的表示时。  
  
\[b\]\[color=red\]UML图如下：\[/color\]\[/b\]  
\[img\]http://images.cnitblog.com/blog/159936/201306/28160817-01ce325337ff4e629180cd26c6c9b2ef.x-png\[/img\]  
  
  
Builder：定义创建对象过程的抽象，提供构建不同组成部分的接口  
  
其中：BuildPartA,BuildPartB,BuildPartC是对一个对象不同部分的构建函数接口,由Builder的派生类ConcreteBuilder1、ConcreteBuilder2来具体实现.  
另外还有一个需要注意的函数,就是Director::Construct函数,这个函数里面通过调用上面的接口函数完成对象的构建--也就是说各个不同部分装配的过程都是一致的(同样的调用的Construct函数),但是不同的构建方式会有不同的表示(根据Builder的实际类型来决定如何构建,也就是多态)  
  
Builder模式是基于这样的一个情况:一个对象可能有不同的组成部分,这几个部分的不同的创建对象会有不同的表示,但是各个部分之间装配的方式是一致的.比方说一辆单车,都是由车轮车座等等的构成的(一个对象不同的组成部分),不同的品牌生产出来的也不一样(不同的构建方式).虽然不同的品牌构建出来的单车不同,但是构建的过程还是一样的  
  
也就是说,Director::Construct函数中固定了各个组成部分的装配方式,而具体是装配怎样的组成部分由Builder的派生类实现.  
  
\[color=red\]\[b\]实现:\[/b\]\[/color\]  
Builder模式的实现基于以下几个面向对象的设计原则:  
  
1)把变化的部分提取出来形成一个基类和对应的接口函数,在这里不会变化的是都会创建PartA和PartB,变化的则是不同的创建方法,于是就抽取出这里的Builder基类和BuildPartA,BuildPartB接口函数  
  
2)采用聚合的方式聚合了会发生变化的基类,就是这里Director聚合了Builder类的指针.  
  
以上，通过两个派生类ConcreteBuilder1、ConcreteBuilder2定义了两种不同的建造细节（建造步骤是一样的，由Construct函数确定），通过两个派生类所建造出来的对象，对外部所展现出来的属性或者功能是不一样的，由各自Builder派生类中的建造方法（BuildPartA、BuildPartB、BuildPartC）决定。  
  
\[color=red\]\[b\]代码如下：\[/b\]\[/color\]

#ifndef _BUILDER_H_
    #define _BUILDER_H_
    
    #include <string>
    #include <vector>
    
    using namespace std;
    
    //产品类
    class Product
    {
       
    private:
        string m_partA;
        string m_partB;
        string m_partC;
    public:
        void setPartA(const string& s);
        void setPartB(const string& s);
        void setPartC(const string& s);
        Product();
        ~Product();
    };
    
    //抽象Builder基类，定义不同部分的创建接口
    class Builder
    {
       
    public:
        virtual void BuildPartA()=0;
        virtual void BuildPartB()=0;
        virtual void BuildPartC()=0;
        virtual Product* GetProduct()=0;
        Builder();
        virtual ~Builder();
    };
    
    //  Builder的派生类,实现BuilderPartA和BuilderPartB和BuildPartC接口函数 
    class ConcreteBuilder1:public Builder
    {
       
    public:
        ConcreteBuilder1();
        ~ConcreteBuilder1();
        virtual void BuildPartA();
        virtual void BuildPartB();
        virtual void BuildPartC();
        virtual Product* GetProduct();
    private:
        Product* m_pProduct;
    };
    
    //  Builder的派生类,实现BuilderPartA和BuilderPartB和BuildPartC接口函数 
    class ConcreteBuilder2:public Builder
    {
       
    public:
        ConcreteBuilder2();
        ~ConcreteBuilder2();
        virtual void BuildPartA();
        virtual void BuildPartB();
        virtual void BuildPartC();
        virtual Product* GetProduct();
    private:
        Product* m_pProduct;
    };
    
    //ConcreteBuilder1与ConcreteBuilder2是Builder的两个派生类，用于实现两种不同的建造细节
    
     // 使用Builder构建产品,构建产品的过程都一致,但是不同的builder有不同的实现
     // 这个不同的实现通过不同的Builder派生类来实现,存有一个Builder的指针,通过这个来实现多态调用 
    class Director
    {
       
    public:
        Director(Builder* pBuilder);
        ~Director();
    
        //Construct函数定义一个对象的整个构建过程,不同的部分之间的装配方式都是一致的,
        //首先构建PartA其次是PartB,只是根据不同的构建者会有不同的表示 
        void Construct();
        //void Construct(const string& buildPara);
    private:
        Builder* m_pBuilder;
    };
    
    #endif

#include "Builder.h"
    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    Product::~Product()
    {
       
    }
    
    Product::Product()
    {}
    
    void Product::setPartA(const string& s)
    {
       
        this->m_partA = s;
    }
    
    void Product::setPartB(const string& s)
    {
       
        this->m_partB = s;
    }
    
    void Product::setPartC(const string& s)
    {
       
        this->m_partC = s;
    }
    
    Builder::Builder()
    {}
    
    Builder::~Builder()
    {}
    
    ConcreteBuilder1::ConcreteBuilder1()
    {
       
        this->m_pProduct = new Product();
        cout<<"Create empty product!"<<endl;
    }
    
    void ConcreteBuilder1::BuildPartA()
    {
       
        this->m_pProduct->setPartA("A");
        cout<<"BuildPartA"<<endl;
    }
    
    void ConcreteBuilder1::BuildPartB()
    {
       
        this->m_pProduct->setPartB("B");
        cout<<"BuildPartB"<<endl;
    }
    
    void ConcreteBuilder1::BuildPartC()
    {
       
        this->m_pProduct->setPartC("C");
        cout<<"BuildPartC"<<endl;
    }
    
    Product* ConcreteBuilder1::GetProduct()
    {
       
        return this->m_pProduct;
    }
    
    ConcreteBuilder1::~ConcreteBuilder1()
    {
       
        delete this->m_pProduct;
        this->m_pProduct = NULL;
    }
    
    ConcreteBuilder2::ConcreteBuilder2()
    {
       
        this->m_pProduct = new Product();
        cout<<"Create empty product!"<<endl;
    }
    
    void ConcreteBuilder2::BuildPartA()
    {
       
        this->m_pProduct->setPartA("A");
        cout<<"BuildPartA"<<endl;
    }
    
    void ConcreteBuilder2::BuildPartB()
    {
       
        this->m_pProduct->setPartB("B");
        cout<<"BuildPartB"<<endl;
    }
    
    void ConcreteBuilder2::BuildPartC()
    {
       
        this->m_pProduct->setPartC("C");
        cout<<"BuildPartC"<<endl;
    }
    
    Product* ConcreteBuilder2::GetProduct()
    {
       
        return this->m_pProduct;
    }
    
    ConcreteBuilder2::~ConcreteBuilder2()
    {
       
        delete this->m_pProduct;
        this->m_pProduct = NULL;
    }
    
    Director::Director(Builder* pBuilder)
    {
       
        this->m_pBuilder = pBuilder;
    }
    
    void Director::Construct()
    {
       
        this->m_pBuilder->BuildPartA();
        this->m_pBuilder->BuildPartB();
        this->m_pBuilder->BuildPartC();
    }
    
    Director::~Director()
    {
       
        delete this->m_pBuilder;
        this->m_pBuilder = NULL;
    }

#include "Builder.h"
    #include <iostream>
    
    using namespace std;
    
    int main()
    {
       
        Director* pDirector = new Director(new ConcreteBuilder1());
        pDirector->Construct();
    
        Director* pDirector1 = new Director(new ConcreteBuilder2());
        pDirector1->Construct();
    
        return 0;
    }

以下转自\[url\]http://www.cnblogs.com/BeyondAnyTime/archive/2012/07/19/2599980.html\[/url\]  
  
  
设计模式之建造者模式（Builder）  
一个人活到70岁以上，都会经历这样的几个阶段：婴儿，少年，青年，中年，老年。并且每个人在各个阶段肯定是不一样的呀，我觉得可以说世界上不存在两个人在人生的这5个阶段的生活完全一样，但是活到70岁以上的人，都经历了这几个阶段是肯定的。实际上这是一个比较经典的建造者模式的例子了。  
  
\[color=red\]\[b\]1.初识建造者模式\[/b\]\[/color\]  
  
建造者模式实际上是常用的设计模式。顾名思义，builder的意思是建造者或者建筑工人，谈到建造自然会想到楼房。楼房是千差万别的，楼房的外形、层数、内部房间的数量、房间的装饰等等都不一样，但是对于建造者来说，抽象出来的建筑流程是确定的，往往建筑一座楼房包括下面的步骤：（1）打桩，建立基础（2）建立框架等。建造者模式的本质和建造楼房是一致的：即流程不变，但每个流程实现的具体细节则是经常变化的。建造者模式的好处就是保证了流程不会变化，流程即不会增加、也不会遗漏或者产生流程次序错误，这是非常重要的。我们熟知的楼歪歪事件，官方的解释就是由于先建立楼房后，再建设停车场造成的，这是典型的建造次序错乱。（看来这些人儿不知道建造者模式啊！！！）  
  
我生活的地方有一个菜叫“锅包肉”。基本每个餐馆都有，但是每个餐馆的味道都不一样，原因是什么呢？因为这道菜的作法没有形成标准呗！每个人的作法都不一样，所以味道就不一样了。这实际上通过“建造者模式”让每个馆子的“锅包肉”都一样。同样的KFC做出来的东西，不论是全国哪家店做出来就都一个味，因为KFC内部有很严格的规定，做巨无霸有做巨无霸的流程，必须严格遵守，这样做出来的东西当然一致了。KFC就是采用了建造者模式！！  
  
说了这么多，到底什么是建造者模式呢？这么神奇。看看GoF怎么说。  
  
  
\[quote\]建造者模式：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。\[/quote\]  
  
  
建造者模式通常包括下面几个角色：  
1. builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。  
2. ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。  
3. Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。  
4. Product：要创建的复杂对象。  
  
　　按照惯例，还是给出建造者模式的结构图  
\[img\]http://pic002.cnblogs.com/images/2012/406683/2012071919460471.jpg\[/img\]  
  
  
\[color=red\]\[b\]2.一个建造者模式例子实现\[/b\]\[/color\]  
  
　　不妨就实现《大话设计模式》上的建造小人的例子吧！！在游戏开发中建造小人是经常的事了，要求是：小人必须包括，头，身体，手和脚。现在系统要包括的分为胖人和瘦人。写出建造者模式的代码如下：

#include <iostream>
    #include <vector>
    #include <string>
    
    using namespace std;
    //Product类
    class Product
    {
       
        vector<string> parts;
    public:
        void Add(const string part)
        {
       
            parts.push_back(part);
        }
        void Show()const
        {
       
            for(int i = 0 ; i < parts.size() ; i++)
            {
       
                cout<<parts[i]<<endl;
            }
        }
    };
    //抽象builder类
    class Builder
    {
       
    public:
        virtual void BuildHead() = 0;
        virtual void BuildBody() = 0;
        virtual void BuildHand() = 0;
        virtual void BuildFeet() = 0;
        virtual Product GetResult() = 0; 
    };
    //具体胖人创建类
    class FatPersonBuilder :public Builder
    {
       
    private:
        Product product;
    public:
        virtual void BuildHead()
        {
       
            product.Add("胖人头");//创建瘦人的头
        }
        virtual void BuildBody()
        {
       
            product.Add("胖人身体");//创建瘦人的身体
        }
        virtual void BuildHand()
        {
       
            product.Add("胖人手");//创建瘦人的手
        }
        virtual void BuildFeet()
        {
       
            product.Add("胖人脚");//创建瘦人的脚
        }
        virtual Product GetResult()
        {
       
            return product;
        }
    };
    //具体瘦人人创建类
    class ThinPersonBuilder :public Builder
    {
       
    private:
        Product product;
    public:
        virtual void BuildHead()
        {
       
            product.Add("瘦人人头");//创建瘦人的头
        }
        virtual void BuildBody()
        {
       
            product.Add("瘦人身体");//创建瘦人的身体
        }
        virtual void BuildHand()
        {
       
            product.Add("瘦人手");//创建瘦人的手
        }
        virtual void BuildFeet()
        {
       
            product.Add("瘦人脚");//创建瘦人的脚
        }
        virtual Product GetResult()
        {
       
            return product;
        }
    };
    //Director类
    class Director
    {
       
    public:
        void Construct(Builder &builder)
        {
       
            builder.BuildHead();
            builder.BuildBody();
            builder.BuildHand();
            builder.BuildFeet();
        }
    };
    
    int main()
    {
       
        Director *director = new Director();
        Builder *b1 = new FatPersonBuilder();
        Builder *b2 = new ThinPersonBuilder();
    
        director->Construct(*b1);
        Product p1 = b1->GetResult();
        p1.Show(); 
        return 0;
    }

看过上面代码发现使用建造者模式有什么好处了吗？上面的例子，通过建造者模式，使得建造过程通过Director类的Construct函数固定了，即建造过程不会变，也就是满足上面要求中红色字体的“必须包括”。但是具体的头，身体，手脚这些身体的各个部分会变化，基类Builder中将各种Build函数定义为抽象方法，必须在子类中实现。这样不仅仅使得建造小人的过程不变，而且很利于系统的扩展，一旦出现其他种类的人根本不需要改动之前的FatPersonBuider，ThinPersonBuilder，Director，Product等类，只需要新添加新的类。符合OCP原则。  
  
到这里不知道大家有没有这样的疑问，建造者模式和工厂模式非常相似啊，确实是非常的相似，建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程。两者也有结合使用：比如众神造人，女娲利用建造者模式负责把灵魂、耳目、手臂等组合成一个完整的人，而皇帝、桑林等人各自利用工厂方法模式创造出灵魂，耳目，手臂等。女娲不必考虑灵魂、耳目、手臂是什么样子的，怎么创造出来的，这就成为了一个由建造者模式和工厂方法模式组合而成的系统。  
  
  
\[color=red\]\[b\]3.使用建造者模式的场合和好处\[/b\]\[/color\]  
  
\[color=green\]使用建造者模式的好处：\[/color\]  
1.使用建造者模式可以使客户端不必知道产品内部组成的细节。  
2.具体的建造者类之间是相互独立的，对系统的扩展非常有利。  
3.由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。  
  
\[color=green\]使用建造模式的场合\[/color\]：  
1.创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。  
2.要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。