AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2024-08-08 33
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： [设计模式]创建型模式-抽象工厂模式

简介

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

抽象工厂模式包含以下几个核心角色：

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

适用场景：

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

优点：

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

缺点：

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

示例代码

Go

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

  • abstractfactory/demo.go
package abstractfactory  
  
// OrderMainDAO 为订单主记录, 抽象产品  
type OrderMainDAO interface {  
    SaveOrderMain() string  
}  
  
// OrderDetailDAO 为订单详情记录, 抽象产品  
type OrderDetailDAO interface {  
    SaveOrderDetail() string  
}  
  
// DAOFactory DAO 抽象工厂接口  
type DAOFactory interface {  
    CreateOrderMainDAO() OrderMainDAO  
    CreateOrderDetailDAO() OrderDetailDAO  
}  
  
// RDBMainDAO 关系型数据库的OrderMainDAO实现, 具体产品  
type RDBMainDAO struct{}  
  
func (*RDBMainDAO) SaveOrderMain() string {  
    return "RDB main save"  
}  
  
// RDBDetailDAO 是关系型数据库的OrderDetailDAO实现, 具体产品  
type RDBDetailDAO struct{}  
  
func (*RDBDetailDAO) SaveOrderDetail() string {  
    return "RDB detail save"  
}  
  
// RDBDAOFactory 是RDB抽象工厂实现, 具体工厂类  
type RDBDAOFactory struct{}  
  
func (*RDBDAOFactory) CreateOrderMainDAO() OrderMainDAO {  
    return &RDBMainDAO{}  
}  
  
func (*RDBDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {  
    return &RDBDetailDAO{}  
}  
  
// XMLMainDAO 是XML存储的OrderMainDAO 实现, 具体产品  
type XMLMainDAO struct{}  
  
func (*XMLMainDAO) SaveOrderMain() string {  
    return "XML main save"  
}  
  
// XMLDetailDAO 是XML存储的OrderDetailDAO实现, 具体产品  
type XMLDetailDAO struct{}  
  
func (*XMLDetailDAO) SaveOrderDetail() string {  
    return "XML detail save"  
}  
  
// XMLDAOFactory 是XML抽象工厂实现, 具体工厂类  
type XMLDAOFactory struct{}  
  
func (*XMLDAOFactory) CreateOrderMainDAO() OrderMainDAO {  
    return &XMLMainDAO{}  
}  
  
func (*XMLDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {  
    return &XMLDetailDAO{}  
}
  • 单元测试：abstractfactory/demo_test.go
package abstractfactory  
  
import (  
    "testing"  
)  
  
func TestDAO(t *testing.T) {  
    var factory DAOFactory  
  
    factory = &RDBDAOFactory{}  
    if factory.CreateOrderMainDAO().SaveOrderMain() != "RDB main save" {  
       t.Fatal("error with abstract factory pattern. RDB Main DAO")  
    }  
  
    if factory.CreateOrderDetailDAO().SaveOrderDetail() != "RDB detail save" {  
       t.Fatal("error with abstract factory pattern. RDB Detail DAO")  
    }  
  
    factory = &XMLDAOFactory{}  
    if factory.CreateOrderMainDAO().SaveOrderMain() != "XML main save" {  
       t.Fatal("error with abstract factory pattern. XML Main DAO")  
    }  
    if factory.CreateOrderDetailDAO().SaveOrderDetail() != "XML detail save" {  
       t.Fatal("error with abstract factory pattern. XML Detail DAO")  
    }  
}

Python

from abc import ABC, abstractmethod
class OrderMainDAO(ABC):
    """订单主要记录, 抽象产品类
    """
    @abstractmethod
    def save_order_main(self) -> str:
        pass
class OrderDetailDAO(ABC):
    """订单详情, 抽象产品类
    """
    @abstractmethod
    def save_order_detail(self) -> str:
        pass
class DAOFactory(ABC):
    """抽象工厂类
    """
    @abstractmethod
    def create_order_main_dao(self):
        pass
    def create_order_detail_dao(self):
        pass
class RDBMainDAO(OrderMainDAO):
    """RDB存储订单主要记录, 具体产品类, 实现抽象产品类OrderMainDAO
    """
    def save_order_main(self) -> str:
        return "RDB Main DAO"
class RDBDetailDAO(OrderDetailDAO):
    """RDB存储订单详情, 具体产品类, 实现抽象产品类OrderDetailDAO
    """
    def save_order_detail(self) -> str:
        return "RDB Detail DAO"
class RDBDAOFactory(DAOFactory):
    """RDB存储, 具体工厂类, 实现抽象工厂类DAOFactory
    """
    def create_order_main_dao(self):
        return RDBMainDAO()
    def create_order_detail_dao(self):
        return RDBDetailDAO()
class XMLMainDAO(OrderMainDAO):
    """XML存储订单主要记录, 具体产品类, 实现抽象产品OrderMainDAO
    """
    def save_order_main(self):
        return "XML Main DAO"
class XMLDetailDAO(OrderDetailDAO):
    """XML存储订单详情, 具体产品类, 实现抽象产品 OrderDetailDAO
    """
    def save_order_detail(self):
        return "XML Detail DAO"
class XMLDAOFactory(DAOFactory):
    """XML存储, 实现抽象工厂类DAOFactory
    """
    def create_order_main_dao(self):
        return XMLMainDAO()
    def create_order_detail_dao(self):
        return XMLDetailDAO()
if __name__ == "__main__":
    factory = RDBDAOFactory()
    print(factory.create_order_main_dao().save_order_main())
    print(factory.create_order_detail_dao().save_order_detail())
    factory = XMLDAOFactory()
    print(factory.create_order_main_dao().save_order_main())
    print(factory.create_order_detail_dao().save_order_detail())

参考

文章标签：
设计模式
存储
Go
测试技术
XML
关键词：
设计模式抽象工厂模式
设计模式创建型模式
花酒锄作田
目录
相关文章
东方睿赢
|
5月前
|
设计模式
**工厂模式与抽象工厂模式**都是创建型设计模式，用于封装对象创建，减少耦合
【6月更文挑战第23天】**工厂模式与抽象工厂模式**都是创建型设计模式，用于封装对象创建，减少耦合。工厂模式专注于单个对象，通过具体工厂创建具体产品，适用于简单对象创建；抽象工厂则关注一系列相关产品，提供创建一族对象的接口，适用于处理多个不兼容产品族。选择模式基于问题域的复杂性，单个产品需求时用工厂模式，多产品族时用抽象工厂模式。
东方睿赢
32 5
艾利克斯冰
|
2月前
|
设计模式 Java
Java设计模式-抽象工厂模式（5）
Java设计模式-抽象工厂模式（5）
艾利克斯冰
31 1
热爱技术的小郑
|
3月前
|
设计模式 存储 负载均衡
【五】设计模式~~~创建型模式~~~单例模式（Java）
文章详细介绍了单例模式（Singleton Pattern），这是一种确保一个类只有一个实例，并提供全局访问点的设计模式。文中通过Windows任务管理器的例子阐述了单例模式的动机，解释了如何通过私有构造函数、静态私有成员变量和公有静态方法实现单例模式。接着，通过负载均衡器的案例展示了单例模式的应用，并讨论了单例模式的优点、缺点以及适用场景。最后，文章还探讨了饿汉式和懒汉式单例的实现方式及其比较。
热爱技术的小郑
42 1
【五】设计模式~~~创建型模式~~~单例模式（Java）
土木林森
|
3月前
|
设计模式 Java
Java 设计模式之谜：工厂模式与抽象工厂模式究竟隐藏着怎样的神奇力量？
【8月更文挑战第30天】在Java编程中，设计模式为常见问题提供了高效解决方案。工厂模式与抽象工厂模式是常用的对象创建型设计模式，能显著提升代码的灵活性、可维护性和可扩展性。工厂模式通过定义创建对象的接口让子类决定实例化哪个类；而抽象工厂模式则进一步提供了一个创建一系列相关或相互依赖对象的接口，无需指定具体类。这种方式使得系统更易于扩展和维护。
土木林森
42 1
热爱技术的小郑
|
3月前
|
设计模式 XML 存储
【三】设计模式~~~创建型模式~~~抽象工厂模式（Java）
文章详细介绍了抽象工厂模式，这是一种创建型设计模式，用于提供一个接口以创建一系列相关或相互依赖的对象，而不指定它们具体的类。通过代码示例和结构图，文章展示了抽象工厂模式的动机、定义、结构、优点、缺点以及适用场景，并探讨了如何通过配置文件和反射机制实现工厂的动态创建。
热爱技术的小郑
38 0
【三】设计模式~~~创建型模式~~~抽象工厂模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 XML 存储
【二】设计模式~~~创建型模式~~~工厂方法模式（Java）
文章详细介绍了工厂方法模式（Factory Method Pattern），这是一种创建型设计模式，用于将对象的创建过程委托给多个工厂子类中的某一个，以实现对象创建的封装和扩展性。文章通过日志记录器的实例，展示了工厂方法模式的结构、角色、时序图、代码实现、优点、缺点以及适用环境，并探讨了如何通过配置文件和Java反射机制实现工厂的动态创建。
热爱技术的小郑
58 0
【二】设计模式~~~创建型模式~~~工厂方法模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 XML Java
【一】设计模式~~~创建型模式~~~简单工厂模式（Java）
文章详细介绍了简单工厂模式（Simple Factory Pattern），这是一种创建型设计模式，用于根据输入参数的不同返回不同类的实例，而客户端不需要知道具体类名。文章通过图表类的实例，展示了简单工厂模式的结构、时序图、代码实现、优缺点以及适用环境，并提供了Java代码示例和扩展应用，如通过配置文件读取参数来实现对象的创建。
热爱技术的小郑
42 0
【一】设计模式~~~创建型模式~~~简单工厂模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 Java C语言
设计模式-----------工厂模式之抽象工厂模式（创建型）
抽象工厂模式是一种创建型设计模式，它提供了一个接口用于创建一系列相关或相互依赖的对象，而无需指定具体类，从而增强了程序的可扩展性并确保客户端只使用同一产品族的产品。
热爱技术的小郑
38 0
设计模式-----------工厂模式之抽象工厂模式（创建型）
花酒锄作田
|
3月前
|
设计模式 测试技术 Go
[设计模式]创建型模式-简单工厂模式
[设计模式]创建型模式-简单工厂模式
花酒锄作田
38 1
热爱技术的小郑
|
3月前
|
设计模式 XML 存储
【四】设计模式~~~创建型模式~~~建造者模式（Java）
文章详细介绍了建造者模式（Builder Pattern），这是一种创建型设计模式，用于将复杂对象的构建与其表示分离，允许分步骤创建一个复杂的对象而无需指定其内部的具体构造细节。通过定义抽象建造者、具体建造者、指挥者和产品角色，建造者模式允许通过相同的构建过程创建不同的产品表示，提高了系统的灵活性和扩展性。
热爱技术的小郑
39 0