抽象工厂模式

【1】什么是抽象工厂模式？

原文：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

所有专业书上都是这句话：“为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。”

逐级分解一下：

1、为创建一组相关的对象提供一个接口，而且无需指定他们的具体类。

2、为创建一组相互依赖的对象提供一个接口，而且无需指定他们的具体类。

3、为创建对象提供一个接口，而且无需指定他们的具体类。

4、为创建对象提供一个接口。

5、一个接口。

抽象工厂：抽象是指接口，工厂是指集合，其实是接口集合。

既然是接口集合，那么属于哪种类型的接口集合？即具体工厂类。

比如SqlFactory，是指Sql数据库的接口集合。

而Sql数据库的接口集合最终都可以创建出哪种类型的Sql产品？即具体产品类。

比如SqlUser,SqlDepartment，是指具体的Sql产品类。

所以，抽象工厂，即创建出产品类的接口集合。

比如，IFactory，创建出产品类的接口集合，不可以实例化对象，仅仅提供接口规范。

每个具体工厂，即创建出同一类产品的功能集合。

比如，SqlFactory，创建出同一类产品SqlUser、SqlDepartment的功能集合。

【2】抽象工厂模式的逻辑结构图及代码示例：

逻辑结构图：

代码示例：

#include <string>
#include <iostream>
using namespace std;

// 抽象产品类1
class IUser
{
public:
    virtual void getUser() = 0;
    virtual void setUser() = 0;
};

// 具体产品类1（SqlUser）
class SqlUser : public IUser
{
public:
    void getUser()
    {
        cout << "在sql中返回user" << endl;
    }
    void setUser()
    {
        cout << "在sql中设置user" << endl;
    }
};

// 具体产品类1（AccessUser）
class AccessUser : public IUser
{
public:
    void getUser()
    {
        cout << "在Access中返回user" << endl;
    }
    void setUser()
    {
        cout << "在Access中设置user" << endl;
    }
};

// 抽象产品类2
class IDepartment
{
public:
    virtual void getDepartment() = 0;
    virtual void setDepartment() = 0;
};

// 具体产品类2（SqlDepartment）
class SqlDepartment : public IDepartment
{
public:
    void getDepartment()
    {
        cout << "在sql中返回Department" << endl;
    }
    void setDepartment()
    {
        cout << "在sql中设置Department" << endl;
    }
};

// 具体产品类2（AccessDepartment）
class AccessDepartment : public IDepartment
{
public:
    void getDepartment()
    {
        cout << "在Access中返回Department" << endl;
    }
    void setDepartment()
    {
        cout << "在Access中设置Department" << endl;
    }
};

// 抽象工厂类
class IFactory
{
public:
    virtual IUser *createUser() = 0;
    virtual IDepartment *createDepartment() = 0;
};

// 具体工厂类（SqlFactory）
class SqlFactory : public IFactory
{
public:
    IUser *createUser() 
    {
        return new SqlUser(); // 创建具体产品1（SqlUser）
    }
    IDepartment *createDepartment() 
    {
        return new SqlDepartment(); // 创建具体产品2（SqlDepartment）
    }
};

// 具体工厂类（AccessFactory）
class AccessFactory : public IFactory
{
public:
    IUser *createUser()
    {
        return new AccessUser(); // 创建具体产品1（AccessUser）
    }
    IDepartment *createDepartment() 
    {
        return new AccessDepartment(); // 创建具体产品2（AccessDepartment）
    }
};

void main()
{
    IFactory *pFactory = NULL;
    IUser *pUser = NULL;
    IDepartment *pDepartment = NULL;

    pFactory = new AccessFactory();
    if (NULL == pFactory)
    {
        return;
    }

    pUser = pFactory->createUser();
    if (NULL == pUser)
    {
        return;
    }
    pDepartment = pFactory->createDepartment();
    if (NULL == pDepartment)
    {
        return;
    }

    pUser->getUser();
    pUser->setUser();
    pDepartment->getDepartment();
    pDepartment->setDepartment();
    
    delete pFactory;
    pFactory = NULL;
    delete pUser;
    pUser = NULL;
    delete pDepartment;
    pDepartment = NULL;

    system("pause");
}

// run out:
/*
在Access中返回user
在Access中设置user
在Access中返回Department
在Access中设置Department
请按任意键继续. . .
*/

抽象产品类、抽象工厂类、具体产品类、具体工厂类如上注释。

【3】抽象工厂模式结构图

结构图如下所示：

为了加深宏观的理解，特搜了这张图贴上。

【4】工厂方法模式与抽象工厂模式的区别

详细对比请参见下图：

抽象工厂模式更难理解，需要用心琢磨，仔细体会。

【5】抽象工厂模式的优点和缺点

抽象工厂模式的优点：

1、便于交换产品系。

由于具体工厂类，例如IFactory factory = new SqlFactory()，在一个应用中只需要在初始化时出现一次。

这就使得改变一个应用的具体工厂变得很简单，而想要使用不同的产品配置只需要改变具体工厂即可。

2、客户端与具体创建实例过程分离。

客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。

抽象工厂模式的缺点（程序也是很有原则性的，比如：开放-封闭原则）：

针对第一点优点，试想第一点（封闭原则，对于修改尽量关闭）：客户端程序显然不可能只有一处使用IUser或IDepartment。

而如此设计，如果有100处调用了数据库访问类呢？是不是就需要更改100次IFactory factory = new AccessFactory()这样的代码才行？

很明显，不能满足我们想改动一处就完全达到要求的目的。

第二点（开放原则，对于扩展尽量开放）：仅仅能很方便的切换数据库访问代码是很有局限性的，假设用户的需求改变需要增加功能，比如增加项目表Project。

先明确一下需要改动的地方。至少增加三个类，IProject、SqlserverProject、AccessProject，还需要更改IFactory、SqlserverFactory、AccessFactory才可以完全满足要求。

以上俩个缺点，又让我们陷入深深的沉思。

【6】改进方案1：简单工厂改进抽象工厂

代码示例如下：

#include <string>
#include <iostream>
using namespace std;

// 抽象产品类1
class IUser
{
public:
    virtual void getUser() = 0;
    virtual void setUser() = 0;
};

// 具体产品类1（SqlUser）
class SqlUser : public IUser
{
public:
    void getUser()
    {
        cout << "在sql中返回user" << endl;
    }
    void setUser()
    {
        cout << "在sql中设置user" << endl;
    }
};

// 具体产品类1（AccessUser）
class AccessUser : public IUser
{
public:
    void getUser()
    {
        cout << "在Access中返回user" << endl;
    }
    void setUser()
    {
        cout << "在Access中设置user" << endl;
    }
};

// 抽象产品类2
class IDepartment
{
public:
    virtual void getDepartment() = 0;
    virtual void setDepartment() = 0;
};

// 具体产品类2（SqlDepartment）
class SqlDepartment : public IDepartment
{
public:
    void getDepartment()
    {
        cout << "在sql中返回Department" << endl;
    }
    void setDepartment()
    {
        cout << "在sql中设置Department" << endl;
    }
};

// 具体产品类2（AccessDepartment）
class AccessDepartment : public IDepartment
{
public:
    void getDepartment()
    {
        cout << "在Access中返回Department" << endl;
    }
    void setDepartment()
    {
        cout << "在Access中设置Department" << endl;
    }
};

// 工厂方法类
class DataAccess
{
private:
    static string db;

public:
    static IUser *createUser()
    {
        if (db == "sql")
        {
            return new SqlUser();
        }
        else if (db == "access")
        {
            return new AccessUser();
        }

        return NULL;
    }

    static IDepartment *createDepartment()
    {
        if (db == "sql")
        {
            return new SqlDepartment();
        }
        else if (db == "access")
        {
            return new AccessDepartment();
        }

        return NULL;
    }
};

string DataAccess::db = "sql";

void main()
{
    IUser *pUser = NULL;
    IDepartment *pDepartment = NULL;

    pUser = DataAccess::createUser();
    if (NULL == pUser)
        return;

    pDepartment = DataAccess::createDepartment();
    if (NULL == pDepartment)
        return;

    pUser->getUser();
    pUser->setUser();
    pDepartment->getDepartment();
    pDepartment->setDepartment();

    delete pUser;
    pUser = NULL;
    delete pDepartment;
    pDepartment = NULL;

    system("pause");
}

// run out:
/*
在sql中返回user
在sql中设置user
在sql中返回Department
在sql中设置Department
请按任意键继续. . .
*/

利用DataAccess(数据访问)类替换掉了IFactory、SqlserverFactory、AccessFactory三个工厂类。

【7】改进方案2：配置文件 + 抽象工厂模式

Good Good Study, Day Day Up.

顺序 选择 循环 总结