抽象工厂
提供一个接口，让该接口负责创建一系列相关或者相互依赖的对象，无需指定他们具体的类。
使用场景
有应对“多系列对象构建”的需求变化。“系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。
主要应对“新系列”的需求变动。
系列对象如：
举例
未使用
这里的对象都写死了，当需求的数据库从 SQL Server 变更为 MySQL 时，修改起来很麻烦。
1
2
3
4
5
6
7
8
9
10
11
12
| class EmployeeDAO {
public:
vector<EmployeeDAO> getEmployees() {
SQLConnection *connection = new SQLConnection();
SQLCommand *command = new SQLCommand();
command->setConnection(connection);
SQLReader *reader = command->executeReader();
...
}
};
|
使用抽象工厂
因为三个接口类必须都是同一个系列，如果其中某个是其他系列则报错。所以三个接口类可以合成一个工厂类，同一个工厂保证了关联性。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
class IDBConnection {
virtual fn() = 0;
};
class IDBCommand {
virtual fn() = 0;
};
class IDBReader {
virtual fn() = 0;
};
class IDBFactory {
virtual createConnection() = 0;
virtual createCommand() = 0;
virtual createReader() = 0;
};
class SQLConnection : public IDBConnection {
};
class SQLCommand : public IDBCommand {
};
class SQLReader : public IDBReader {
};
class SQLFactory : public IDBFactory {
};
class OracleConnection : public IDBConnection {
};
class OracleCommand : public IDBCommand {
};
class OracleReader : public IDBReader {
};
class OracleFactory : public IDBFactory {
};
class EmployeeDAO {
IDBFactory *dbFactory;
public:
vector<EmployeeDAO> getEmployees() {
IDBConnection *connection = dbFactory->createConnection();
IDBCommand *command = dbFactory->createCommand();
command->setConnection(connection);
IDBReader *reader = command->executeReader();
...
}
};
|
