设计模式之简单工厂

来源：互联网发布：北大青鸟网络培训学校编辑：程序博客网时间：2024/06/09 16:18

GoF的设计模式一经推出，就引起了各路诸侯的严重关注。从JAVA到C#再到C++，甚至连面向过程为主的C都想染指一番。今天，就从C#出发，推导出C++的代码，并用一个C++的ATM模拟程序来实作（这个词好像是从侯捷先生那学来的，如果我记错了，希望他不会怪我，呵呵）。
我们首先看看简单工厂来描述一个四则运算的UML类图。

呵呵，发现在Ubuntu下使用Firefox上传图片会失败。看来在中国，使用Linux确实面临不少障碍！只能切换到Window Xp下再试一下了。后来发现原来是我把图片格式搞错了。CSDN支持的格式为gif,jpg,png，我开始传的是bmp。现在改为jpg就好了，错怪它了。
从图中信息可知，运算类为一个抽象基类，声明了一个基本接口，和两个运算参数，这里为double类型。其实可以用模板方式来扩展该基类，这样就不仅仅处理double类型了。C++代码如下：

//Operation.h
/** /brief COperator
 * Description:运算基类
 */
template<typename T>
class COperator
{
private:
    T NumberA;    /*!< 第一个运算变量 */
    T NumberB;    /*!< 第二个运算变量，处理两个相同类型的运算 */
public:
    COperator();
    virtual ~COperator() = 0;    /*!< 没什么好说的，必须的 */
    T GetResult() = 0;           /*!< 抽象类接口 */
    void SetNumberA(T t);
    void SetNumberB(T t);
};

下面是各运算子类：

// OperationChild.h
#include "Operation.h"
/** /brief COperatorAdd
 * Description:加法运算子类
 */
template<typename T>
class COperatorAdd : public COperator
{
public:
    COperatorAdd();
    ~COperatorAdd();
    virtual T GetResult();    /*!< 在cpp文件中实现，此略 */
};
/** /brief COperatorSub
 * Description:减法运算子类
 */
template<typename T>
class COperatorSub : public COperator
{
public:
    COperatorSub();
    ~COperatorSub();
    virtual T GetResult();    /*!< 在cpp文件中实现，此略 */
};
/** /brief COperatorMul
 * Description:乘法运算子类
 */
template<typename T>
class COperatorMul : public COperator
{
public:
    COperatorMul();
    ~COperatorMul();
    virtual T GetResult();    /*!< 在cpp文件中实现，此略 */
};
/** /brief COperatorDiv
 * Description:除法运算子类
 */
template<typename T>
class COperatorDiv : public COperator
{
public:
    COperatorDiv();
    ~COperatorDiv();
    virtual T GetResult();    /*!< 在cpp文件中实现，此略 */
    /*!< 记得在此接口实现中要判断除数为零的情况 */
};

接下来是简单工厂类：

// OperatorFactory.h
#include "Operation.h"
/** /brief COperatorFactory
 * Description:简单工厂类，用于产生运算对象
 */
enum operator_sign
{
    SIGN_ADD,
    SIGN_SUB,
    SIGN_MUL,
    SIGN_DIV,
};
class COperatorFactory
{
private:
    COperator* m_pOper;
public:
    COperatorFactory();
    ~COperatorFactory();
    /** /brief CreateOperator接口
     * 接收输入的运算符，生成运算对象
     */
    COperator* CreateOperator(operator_sign param = SIGN_ADD);
};

以上代码，我都没有写出实现部分，大家可以自己完成这部分，很简单的。下面来分析一下ATM模拟程序中可以使用该设计模式的部分。熟悉ATM程序的人员知道，在ATM交易过程中，查询、取款、转帐、改密等等交易其实都是类似的，唯一不同的地方在于每个交易数据包中个别域数据不相同；或者是某些域只有某个交易才有，其他交易数据包中没有。每增加一个交易，就必须配置一个交易数据，同时增加处理该交易数据的处理部分。因历史原因，这些处理交易数据的部分都在一个地方，而每个银行的交易有不尽相同。所以ATM软件在每个银行实施其实都变成了一个项目，而不是产品。如果能将各交易单独提出来做成子类处理，这样，可以形成一个交易子类库。每次根据不同银行的不同交易，找出对应的交易子类就可以满足客户需求，代码也不需要作大的变动。
下面按照上面的思路来仿照简单工厂类来设计ATM模拟软件的交易处理:
C＃版：

// transaction.cs
public class TransactionBase
{
    // 产生交易数据包接口
    public virtual string GenPacket
    {
        return "";
    }
    
    // 解析交易数据包接口
    public virtual bool ParsePacket(string strPacket)
    {
        return true;
    }
}

// QueryBalance.cs
class QueryBalance : TransactionBase
{
    // 产生的查询余额交易数据包处理
    public override string GenPacket()
    {
        // ...
    }
    // 解析查询余额交易数据包处理
    public override bool ParsePacket(string strPacket)
    {
        // ...
    }
}

// transactionFactory.cs

public class TransactionFactory
{
    public static TransactionBase CreateTransaction(string transCode)
    {
        TransactionBase trans = null;
        // 交易类型判断分支
        switch(transCode)
        {
        case "123456":    /*!< 查询余额交易 */
            trans = new QueryBalance();
            break;
        // ...
        default:
            // ...
            break;
        }
        return trans;
    }
}

客户端调用：

// client.cs
TransactionBase trans;
trans = TransactionFactory.CreateTransaction("123456");
string packetData = trans.GenPacket();    // 产生交易数据包
packetData.ParsePacket(recvPacket);    // 解析交易数据包

C＋＋版：

// transaction.h
#include <string>
using std::string;
/** /brief CTransaction
 * Description:交易基类
 */
class CTransaction
{
public:
    CTransaction();
    virtual ~CTransaction() = 0;
    /*!< 组交易数据报 */
    string GenPacket() = 0;
    /*!< 解析收到的交易数据报 */
    bool ParsePacket(const string& strPacket) = 0;
};

交易处理子类：

// query.h
// 查询其实又可以分为很多种查询交易，如查询余额，查询明细、查询第三方交// 易等信息的交易。这里我只简单的处理查询余额。

#include "transaction.h"
#include <string>
using std::string;
class CQueryBalance : public CTransaction
{
private:
public:
    CQueryBalance();
    ~CQueryBalance();
    string GenPacket();
    bool ParsePacket(const string& strPacket);
};

查询余额子类的实现：

#include "query.h"
CQueryBalance::CQueryBalance()
{
}
CQueryBalance::~CQueryBalance()
{
}
string CQueryBalance::GenPacket()
{
    /*!< 组交易代码、交易日期、交易时间等信息到string变量 */
    string strPacketData;
    // ......
    return strPacketData;
}
bool CQueryBalance::ParsePacket(const string& strPacket)
{
    /*!< 解析出数据包中各域的数据，并作相应处理 */
    //......
    return true;
}

其他交易类型可仿照完成。此略！
下面是简单工厂类的声明：

// transactionFactory.h
/** /brief CTransactionFactory
 * Description: ATM交易处理简单工厂类
 */
#include "transcation.h"
#include <string>
using std::string;
class CTransactionFactory
{
private:
    CTransaction* m_pTrans;
public:
    CTransactionFactory();
    ~CTransactionFactory();
    CTransaction* CreateTransaction(const string& transCode);
};

对应的实现文件：

// transactionFactory.cpp
CTransactionFactory::CTransactionFactory()
{
}

CTransactionFactory::~CTransactionFactory()
{
}

CTransaction* CTransactionFactory::CreateTransaction(const string& transCode)
{
    if (transCode == "123456")
    {
        // 生长查询余额交易的对象
        m_pTrans = new CQueryBalance();
    }
    else if ()    // 其他交易代码
    {
        // ...
    }
    return m_pTrans;
}

客户端调用代码如下：

// Client.cpp
#include "transaction.h"
#include "transactionFactory.h"
void Function()
{
    CTransaction* pTrans = CreateTransaction("123456");
    pTrans->GenPacket();  /*!< 生成交易数据包 */
    pTrans->ParsePacket(strPacket);  /*!< 解析交易数据包 */
    delete pTrans;    /*!< 关键！千万别忘了！ */

以后每增加新的交易，则只需要增加交易子类和修改transactionFactory.cpp文件即可。客户调用代码和主体结构不需要作太大变动。