设计模式学习笔记（二）—工厂方法模式

• 概念

工厂方法模式是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品。

• 优缺点

优点：

1、 工厂方法模式中，客户端只需要知道所要产品的具体工厂，不用关心具体的创建过程，甚至不需要知道具体产品类的类名。

2、 当我们新增产品的时候，我们只需要添加一个具体产品类和对应的实现工厂，无需对原工厂进行任何修改，很好地符合了“开闭原则”。

缺点：

1、 由于每次增加一个产品，我们都需要增加一个具体类和对象实现工厂，当我们增加的产品比较多得时候，这样类的个数也就成倍的增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

• 实现

下面我们通过一个具体的例子来更好的了解工厂方法模式。

说明：

常用的数据库有SQL Server、Oracle、MySql、Access、Sybase等。他们中有很多共通的方法，如：insert，update，delete，select等等，这里我们就可以用一个工厂方法模式来实现。首先我们设计一个产品接口类IDataBase（就是四个角色里面的抽象产品角色），然后是三个具体产品实现类（具体产品角色）：CSqlServer、COracle、CMySql，各个实现类实现自己通用语法下面的各个方法。然后是我们的抽象工厂接口类（抽象工厂角色）：IDataBaseFactory。最后就是我们的具体工厂类（具体工厂角色）：CSqlServerFactory、COracleFactory、CMySqlFactory。

类图：

实现代码：

IDataBase.h：

class IDataBase
{
public:
    IDataBase(void);
    virtual ~IDataBase(void);
    
    virtual void Insert() = 0;
    virtual void Update() = 0;
    virtual void Delete() = 0;
};

SqlServer.h

#pragma once
#include "IDataBase.h"

class CSqlServer : public IDataBase
{
public:
    CSqlServer(void);
    virtual ~CSqlServer(void);

    virtual void Insert();
    virtual void Update();
    virtual void Delete();
};

SqlServer.cpp

#include "StdAfx.h"
#include "SqlServer.h"

CSqlServer::CSqlServer(void)
{
}

CSqlServer::~CSqlServer(void)
{
}

void CSqlServer::Insert()
{
    printf("SqlServer Insert Function.
");
}

void CSqlServer::Update()
{
    printf("SqlServer Update Function.
");
}

void CSqlServer::Delete()
{
    printf("SqlServer Delete Function.
");
}

Oracle.h

#pragma once
#include "IDataBase.h"

class COracle : public IDataBase
{
public:
    COracle(void);
    ~COracle(void);

    virtual void Insert();
    virtual void Update();
    virtual void Delete();
};

Oracle.cpp

#include "StdAfx.h"
#include "Oracle.h"

COracle::COracle(void)
{
}

COracle::~COracle(void)
{
}

void COracle::Insert()
{
    printf("Oracle Insert Function.
");
}

void COracle::Update()
{
    printf("Oracle Update Function.
");
}

void COracle::Delete()
{
    printf("Oracle Delete Function.
");
}

MySql.h

#pragma once
#include "IDataBase.h"

class CMySql : public IDataBase
{
public:
    CMySql(void);
    ~CMySql(void);

    virtual void Insert();
    virtual void Update();
    virtual void Delete();
};

MySql.cpp

#include "StdAfx.h"
#include "MySql.h"

CMySql::CMySql(void)
{
}

CMySql::~CMySql(void)
{
}

void CMySql::Insert()
{
    printf("MySql Insert Function.
");
}

void CMySql::Update()
{
    printf("MySql Update Function.
");
}

void CMySql::Delete()
{
    printf("MySql Delete Function.
");
}

IDataBaseFactory.h

#pragma once
#include "IDataBase.h"

class IDataBaseFactory
{
public:
    IDataBaseFactory(void);
    ~IDataBaseFactory(void);

    virtual IDataBase* CreateInstance() = 0;
};

SqlServerFactory.h

#pragma once
#include "IDataBaseFactory.h"

class CSqlServerFactory : public IDataBaseFactory
{
public:
    CSqlServerFactory(void);
    ~CSqlServerFactory(void);

    virtual IDataBase* CreateInstance();
};

SqlServerFactory.cpp

#include "StdAfx.h"
#include "SqlServerFactory.h"
#include "SqlServer.h"

CSqlServerFactory::CSqlServerFactory(void)
{
}

CSqlServerFactory::~CSqlServerFactory(void)
{
}

IDataBase* CSqlServerFactory::CreateInstance()
{
    return new CSqlServer();
}

OracleFactory.h

#pragma once
#include "IDataBaseFactory.h"

class COracleFactory : public IDataBaseFactory
{
public:
    COracleFactory(void);
    ~COracleFactory(void);

    virtual IDataBase* CreateInstance();
};

OracleFactory.cpp

#include "StdAfx.h"
#include "OracleFactory.h"
#include "Oracle.h"

COracleFactory::COracleFactory(void)
{
}

COracleFactory::~COracleFactory(void)
{
}

IDataBase* COracleFactory::CreateInstance()
{
    return new COracle();
}

MySqlFactory.h

#pragma once
#include "IDataBaseFactory.h"

class CMySqlFactory : public IDataBaseFactory
{
public:
    CMySqlFactory(void);
    ~CMySqlFactory(void);

    virtual IDataBase* CreateInstance();
};

MySqlFactory.cpp

#include "StdAfx.h"
#include "MySqlFactory.h"
#include "MySql.h"

CMySqlFactory::CMySqlFactory(void)
{
}

CMySqlFactory::~CMySqlFactory(void)
{
}

IDataBase* CMySqlFactory::CreateInstance()
{
    return new CMySql();
}

main函数：

#include "stdafx.h"
#include "stdlib.h"
#include "IDataBase.h"
#include "IDataBaseFactory.h"
#include "MySql.h"
#include "Oracle.h"
#include "SqlServer.h"
#include "MySqlFactory.h"
#include "OracleFactory.h"
#include "SqlServerFactory.h"

void TestMySql()
{
    IDataBaseFactory *pDataBaseFactory = new CMySqlFactory();
    IDataBase *pDataBase = pDataBaseFactory->CreateInstance();

    pDataBase->Insert();
    pDataBase->Update();
    pDataBase->Delete();

    delete pDataBase;
    delete pDataBaseFactory;
}

void TestSqlServer()
{
    IDataBaseFactory *pDataBaseFactory = new CSqlServerFactory();
    IDataBase *pDataBase = pDataBaseFactory->CreateInstance();

    pDataBase->Insert();
    pDataBase->Update();
    pDataBase->Delete();

    delete pDataBase;
    delete pDataBaseFactory;
}

void TestOracle()
{
    IDataBaseFactory *pDataBaseFactory = new COracleFactory();
    IDataBase *pDataBase = pDataBaseFactory->CreateInstance();

    pDataBase->Insert();
    pDataBase->Update();
    pDataBase->Delete();

    delete pDataBase;
    delete pDataBaseFactory;
}

int _tmain(int argc, _TCHAR* argv[])
{
    TestMySql();
    TestSqlServer();
    TestOracle();

    system("pause");
    return 0;
}

输出结果：