設計模式學習筆記（二）—工廠方法模式

• 概念

工廠方法模式是一種經常使用的對象建立型設計模式,此模式的核心精神是封裝類中不變的部分，提取其中個性化善變的部分爲獨立類，經過依賴注入以達到解耦、複用和方便後期維護拓展的目的。它的核心結構有四個角色，分別是抽象工廠；具體工廠；抽象產品；具體產品。

• 優缺點

優勢：

一、 工廠方法模式中，客戶端只須要知道所要產品的具體工廠，不用關心具體的建立過程，甚至不須要知道具體產品類的類名。

二、 當咱們新增產品的時候，咱們只須要添加一個具體產品類和對應的實現工廠，無需對原工廠進行任何修改，很好地符合了「開閉原則」。

缺點：

一、 因爲每次增長一個產品，咱們都須要增長一個具體類和對象實現工廠，當咱們增長的產品比較多得時候，這樣類的個數也就成倍的增長，在必定程度上增長了系統的複雜度，同時也增長了系統具體類的依賴。

• 實現

下面咱們經過一個具體的例子來更好的瞭解工廠方法模式。

說明：

經常使用的數據庫有SQL Server、Oracle、MySql、Access、Sybase等。他們中有不少共通的方法，如：insert，update，delete，select等等，這裏咱們就能夠用一個工廠方法模式來實現。首先咱們設計一個產品接口類IDataBase（就是四個角色裏面的抽象產品角色），而後是三個具體產品實現類（具體產品角色）：CSqlServer、COracle、CMySql，各個實現類實現本身通用語法下面的各個方法。而後是咱們的抽象工廠接口類（抽象工廠角色）：IDataBaseFactory。最後就是咱們的具體工廠類（具體工廠角色）：CSqlServerFactory、COracleFactory、CMySqlFactory。

類圖：

實現代碼：

IDataBase.h：

 1 class IDataBase
 2 {
 3 public:
 4     IDataBase(void);
 5     virtual ~IDataBase(void);
 6     
 7     virtual void Insert() = 0;
 8     virtual void Update() = 0;
 9     virtual void Delete() = 0;
10 };

SqlServer.h

 1 #pragma once
 2 #include "IDataBase.h"
 3 
 4 class CSqlServer : public IDataBase
 5 {
 6 public:
 7     CSqlServer(void);
 8     virtual ~CSqlServer(void);
 9 
10     virtual void Insert();
11     virtual void Update();
12     virtual void Delete();
13 };

SqlServer.cpp

 1 #include "StdAfx.h"
 2 #include "SqlServer.h"
 3 
 4 CSqlServer::CSqlServer(void)
 5 {
 6 }
 7 
 8 CSqlServer::~CSqlServer(void)
 9 {
10 }
11 
12 void CSqlServer::Insert()
13 {
14     printf("SqlServer Insert Function.\n");
15 }
16 
17 void CSqlServer::Update()
18 {
19     printf("SqlServer Update Function.\n");
20 }
21 
22 void CSqlServer::Delete()
23 {
24     printf("SqlServer Delete Function.\n");
25 }

Oracle.h

 1 #pragma once
 2 #include "IDataBase.h"
 3 
 4 class COracle : public IDataBase
 5 {
 6 public:
 7     COracle(void);
 8     ~COracle(void);
 9 
10     virtual void Insert();
11     virtual void Update();
12     virtual void Delete();
13 };

Oracle.cpp

 1 #include "StdAfx.h"
 2 #include "Oracle.h"
 3 
 4 COracle::COracle(void)
 5 {
 6 }
 7 
 8 COracle::~COracle(void)
 9 {
10 }
11 
12 void COracle::Insert()
13 {
14     printf("Oracle Insert Function.\n");
15 }
16 
17 void COracle::Update()
18 {
19     printf("Oracle Update Function.\n");
20 }
21 
22 void COracle::Delete()
23 {
24     printf("Oracle Delete Function.\n");
25 }

MySql.h

 1 #pragma once
 2 #include "IDataBase.h"
 3 
 4 class CMySql : public IDataBase
 5 {
 6 public:
 7     CMySql(void);
 8     ~CMySql(void);
 9 
10     virtual void Insert();
11     virtual void Update();
12     virtual void Delete();
13 };

MySql.cpp

 1 #include "StdAfx.h"
 2 #include "MySql.h"
 3 
 4 CMySql::CMySql(void)
 5 {
 6 }
 7 
 8 CMySql::~CMySql(void)
 9 {
10 }
11 
12 void CMySql::Insert()
13 {
14     printf("MySql Insert Function.\n");
15 }
16 
17 void CMySql::Update()
18 {
19     printf("MySql Update Function.\n");
20 }
21 
22 void CMySql::Delete()
23 {
24     printf("MySql Delete Function.\n");
25 }

IDataBaseFactory.h

 1 #pragma once
 2 #include "IDataBase.h"
 3 
 4 class IDataBaseFactory
 5 {
 6 public:
 7     IDataBaseFactory(void);
 8     ~IDataBaseFactory(void);
 9 
10     virtual IDataBase* CreateInstance() = 0;
11 };

SqlServerFactory.h

 1 #pragma once
 2 #include "IDataBaseFactory.h"
 3 
 4 class CSqlServerFactory : public IDataBaseFactory
 5 {
 6 public:
 7     CSqlServerFactory(void);
 8     ~CSqlServerFactory(void);
 9 
10     virtual IDataBase* CreateInstance();
11 };

SqlServerFactory.cpp

 1 #include "StdAfx.h"
 2 #include "SqlServerFactory.h"
 3 #include "SqlServer.h"
 4 
 5 CSqlServerFactory::CSqlServerFactory(void)
 6 {
 7 }
 8 
 9 CSqlServerFactory::~CSqlServerFactory(void)
10 {
11 }
12 
13 IDataBase* CSqlServerFactory::CreateInstance()
14 {
15     return new CSqlServer();
16 }

OracleFactory.h

 1 #pragma once
 2 #include "IDataBaseFactory.h"
 3 
 4 class COracleFactory : public IDataBaseFactory
 5 {
 6 public:
 7     COracleFactory(void);
 8     ~COracleFactory(void);
 9 
10     virtual IDataBase* CreateInstance();
11 };

OracleFactory.cpp

 1 #include "StdAfx.h"
 2 #include "OracleFactory.h"
 3 #include "Oracle.h"
 4 
 5 COracleFactory::COracleFactory(void)
 6 {
 7 }
 8 
 9 COracleFactory::~COracleFactory(void)
10 {
11 }
12 
13 IDataBase* COracleFactory::CreateInstance()
14 {
15     return new COracle();
16 }

MySqlFactory.h

 1 #pragma once
 2 #include "IDataBaseFactory.h"
 3 
 4 class CMySqlFactory : public IDataBaseFactory
 5 {
 6 public:
 7     CMySqlFactory(void);
 8     ~CMySqlFactory(void);
 9 
10     virtual IDataBase* CreateInstance();
11 };

MySqlFactory.cpp

 1 #include "StdAfx.h"
 2 #include "MySqlFactory.h"
 3 #include "MySql.h"
 4 
 5 CMySqlFactory::CMySqlFactory(void)
 6 {
 7 }
 8 
 9 CMySqlFactory::~CMySqlFactory(void)
10 {
11 }
12 
13 IDataBase* CMySqlFactory::CreateInstance()
14 {
15     return new CMySql();
16 }

main函數：

 1 #include "stdafx.h"
 2 #include "stdlib.h"
 3 #include "IDataBase.h"
 4 #include "IDataBaseFactory.h"
 5 #include "MySql.h"
 6 #include "Oracle.h"
 7 #include "SqlServer.h"
 8 #include "MySqlFactory.h"
 9 #include "OracleFactory.h"
10 #include "SqlServerFactory.h"
11 
12 void TestMySql()
13 {
14     IDataBaseFactory *pDataBaseFactory = new CMySqlFactory();
15     IDataBase *pDataBase = pDataBaseFactory->CreateInstance();
16 
17     pDataBase->Insert();
18     pDataBase->Update();
19     pDataBase->Delete();
20 
21     delete pDataBase;
22     delete pDataBaseFactory;
23 }
24 
25 void TestSqlServer()
26 {
27     IDataBaseFactory *pDataBaseFactory = new CSqlServerFactory();
28     IDataBase *pDataBase = pDataBaseFactory->CreateInstance();
29 
30     pDataBase->Insert();
31     pDataBase->Update();
32     pDataBase->Delete();
33 
34     delete pDataBase;
35     delete pDataBaseFactory;
36 }
37 
38 void TestOracle()
39 {
40     IDataBaseFactory *pDataBaseFactory = new COracleFactory();
41     IDataBase *pDataBase = pDataBaseFactory->CreateInstance();
42 
43     pDataBase->Insert();
44     pDataBase->Update();
45     pDataBase->Delete();
46 
47     delete pDataBase;
48     delete pDataBaseFactory;
49 }
50 
51 int _tmain(int argc, _TCHAR* argv[])
52 {
53     TestMySql();
54     TestSqlServer();
55     TestOracle();
56 
57     system("pause");
58     return 0;
59 }

輸出結果：