[设计模式]创建型-抽象工厂模式

简介

抽象工厂模式是一种创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式将一组具有共同主题的单个工厂封装起来，它提供接口用于创建相关或依赖对象的家族，而不需要指定具体的类。
抽象工厂模式包含以下几个核心角色：

• 抽象工厂（Abstract Factory）：声明了一组用于创建产品对象的方法，每个方法对应一种产品类型。抽象工厂可以是接口或抽象类。
  
• 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体产品对象的实例。
  
• 抽象产品（Abstract Product）：定义了一组产品对象的共同接口或抽象类，描述了产品对象的公共方法。
  
• 具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
  

适用场景：

• 当一个系统需要独立于它的产品的创建、组合和表示时
  
• 当一个系统需要多个系列的产品族，而不希望依赖于具体类时
  

优点：

• 将客户端与具体的产品类解耦，使得客户端可以轻松切换不同的具体工厂
  
• 符合开闭原则，易于扩展，添加新的产品族和产品等级结构
  

缺点：

• 增加新的产品族和产品等级结构比较复杂，需要修改抽象工厂和所有具体工厂的接口
  
• 对于新添加的产品族，需要修改所有的具体工厂类，这增加了系统的复杂度
  

示例代码

Go

本例使用RDB和XML存储订单信息，抽象工厂分别能生成相关的著订单信息和订单详情信息。如果业务逻辑中需要替换其他存储方式，使用的时候只需要改动工厂函数相关的类即可。

• abstractfactory/demo.go
  

1. package abstractfactory  
2.   
3. // OrderMainDAO 为订单主记录, 抽象产品  
4. type OrderMainDAO interface {  
5.     SaveOrderMain() string  
6. }  
7.   
8. // OrderDetailDAO 为订单详情记录, 抽象产品  
9. type OrderDetailDAO interface {  
10.     SaveOrderDetail() string  
11. }  
12.   
13. // DAOFactory DAO 抽象工厂接口  
14. type DAOFactory interface {  
15.     CreateOrderMainDAO() OrderMainDAO  
16.     CreateOrderDetailDAO() OrderDetailDAO  
17. }  
18.   
19. // RDBMainDAO 关系型数据库的OrderMainDAO实现, 具体产品  
20. type RDBMainDAO struct{}  
21.   
22. func (*RDBMainDAO) SaveOrderMain() string {  
23.     return "RDB main save"  
24. }  
25.   
26. // RDBDetailDAO 是关系型数据库的OrderDetailDAO实现, 具体产品  
27. type RDBDetailDAO struct{}  
28.   
29. func (*RDBDetailDAO) SaveOrderDetail() string {  
30.     return "RDB detail save"  
31. }  
32.   
33. // RDBDAOFactory 是RDB抽象工厂实现, 具体工厂类  
34. type RDBDAOFactory struct{}  
35.   
36. func (*RDBDAOFactory) CreateOrderMainDAO() OrderMainDAO {  
37.     return &RDBMainDAO{}  
38. }  
39.   
40. func (*RDBDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {  
41.     return &RDBDetailDAO{}  
42. }  
43.   
44. // XMLMainDAO 是XML存储的OrderMainDAO 实现, 具体产品  
45. type XMLMainDAO struct{}  
46.   
47. func (*XMLMainDAO) SaveOrderMain() string {  
48.     return "XML main save"  
49. }  
50.   
51. // XMLDetailDAO 是XML存储的OrderDetailDAO实现, 具体产品  
52. type XMLDetailDAO struct{}  
53.   
54. func (*XMLDetailDAO) SaveOrderDetail() string {  
55.     return "XML detail save"  
56. }  
57.   
58. // XMLDAOFactory 是XML抽象工厂实现, 具体工厂类  
59. type XMLDAOFactory struct{}  
60.   
61. func (*XMLDAOFactory) CreateOrderMainDAO() OrderMainDAO {  
62.     return &XMLMainDAO{}  
63. }  
64.   
65. func (*XMLDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {  
66.     return &XMLDetailDAO{}  
67. }

复制代码

• 单元测试：abstractfactory/demo_test.go
  

1. package abstractfactory  
2.   
3. import (  
4.     "testing"  
5. )  
6.   
7. func TestDAO(t *testing.T) {  
8.     var factory DAOFactory  
9.   
10.     factory = &RDBDAOFactory{}  
11.     if factory.CreateOrderMainDAO().SaveOrderMain() != "RDB main save" {  
12.        t.Fatal("error with abstract factory pattern. RDB Main DAO")  
13.     }  
14.   
15.     if factory.CreateOrderDetailDAO().SaveOrderDetail() != "RDB detail save" {  
16.        t.Fatal("error with abstract factory pattern. RDB Detail DAO")  
17.     }  
18.   
19.     factory = &XMLDAOFactory{}  
20.     if factory.CreateOrderMainDAO().SaveOrderMain() != "XML main save" {  
21.        t.Fatal("error with abstract factory pattern. XML Main DAO")  
22.     }  
23.     if factory.CreateOrderDetailDAO().SaveOrderDetail() != "XML detail save" {  
24.        t.Fatal("error with abstract factory pattern. XML Detail DAO")  
25.     }  
26. }

复制代码

Python

1. from abc import ABC, abstractmethod
4. class OrderMainDAO(ABC):
5.     """订单主要记录, 抽象产品类
6.     """
8.     @abstractmethod
9.     def save_order_main(self) -> str:
10.         pass
13. class OrderDetailDAO(ABC):
14.     """订单详情, 抽象产品类
15.     """
17.     @abstractmethod
18.     def save_order_detail(self) -> str:
19.         pass
22. class DAOFactory(ABC):
23.     """抽象工厂类
24.     """
26.     @abstractmethod
27.     def create_order_main_dao(self):
28.         pass
30.     def create_order_detail_dao(self):
31.         pass
34. class RDBMainDAO(OrderMainDAO):
35.     """RDB存储订单主要记录, 具体产品类, 实现抽象产品类OrderMainDAO
36.     """
38.     def save_order_main(self) -> str:
39.         return "RDB Main DAO"
42. class RDBDetailDAO(OrderDetailDAO):
43.     """RDB存储订单详情, 具体产品类, 实现抽象产品类OrderDetailDAO
44.     """
46.     def save_order_detail(self) -> str:
47.         return "RDB Detail DAO"
50. class RDBDAOFactory(DAOFactory):
51.     """RDB存储, 具体工厂类, 实现抽象工厂类DAOFactory
52.     """
54.     def create_order_main_dao(self):
55.         return RDBMainDAO()
57.     def create_order_detail_dao(self):
58.         return RDBDetailDAO()
61. class XMLMainDAO(OrderMainDAO):
62.     """XML存储订单主要记录, 具体产品类, 实现抽象产品OrderMainDAO
63.     """
65.     def save_order_main(self):
66.         return "XML Main DAO"
69. class XMLDetailDAO(OrderDetailDAO):
70.     """XML存储订单详情, 具体产品类, 实现抽象产品 OrderDetailDAO
71.     """
73.     def save_order_detail(self):
74.         return "XML Detail DAO"
77. class XMLDAOFactory(DAOFactory):
78.     """XML存储, 实现抽象工厂类DAOFactory
79.     """
81.     def create_order_main_dao(self):
82.         return XMLMainDAO()
84.     def create_order_detail_dao(self):
85.         return XMLDetailDAO()
88. if __name__ == "__main__":
89.     factory = RDBDAOFactory()
90.     print(factory.create_order_main_dao().save_order_main())
91.     print(factory.create_order_detail_dao().save_order_detail())
93.     factory = XMLDAOFactory()
94.     print(factory.create_order_main_dao().save_order_main())
95.     print(factory.create_order_detail_dao().save_order_detail())

复制代码

参考

• 菜鸟教程 - 抽象工厂模式
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！