python设计模式3抽象工厂模式

Posted 2023-04-06 Htojk

设计哲学：

抽象工厂模式的哲学思想是面向接口编程（Interface Segregation Principle，ISP）。这一原则强调，客户端不应该依赖于它不需要的接口，而应该将接口尽可能地细化，只包含客户端所需的方法。

抽象工厂模式正是将这一原则体现得淋漓尽致。它定义了一组接口，用于创建一系列相关或依赖对象的产品族。客户端只需要与这一组接口交互，而不需要关心具体的实现细节，从而实现了客户端与具体实现之间的解耦。

这种解耦可以提高代码的可维护性和可扩展性，因为当需要添加新的产品族时，只需要新增对应的工厂类和产品类，而不需要修改客户端的代码。这样，抽象工厂模式可以帮助我们更好地遵循开闭原则（Open-Closed Principle，OCP），即对扩展开放，对修改关闭。

简介：

抽象工厂模式是工厂模式的扩展，它提供了一种创建一组相关或相互依赖对象的接口，而不需要指定它们具体的类。抽象工厂模式通过抽象工厂类和具体工厂类来实现。

在抽象工厂模式中，抽象工厂类定义了一组用于创建一系列产品的抽象方法，具体工厂类实现了这些抽象方法，从而创建出具体的产品对象。抽象工厂模式的结构如下：

其中，AbstractFactory 是抽象工厂类，它定义了一组用于创建一系列产品的抽象方法。具体工厂类 ConcreteFactory1 和 ConcreteFactory2 实现了这些抽象方法，从而创建出具体的产品对象。抽象产品类 AbstractProductA 和 AbstractProductB 定义了产品的抽象方法，具体产品类 ProductA1、ProductA2、ProductB1 和 ProductB2 实现了这些抽象方法，从而创建出具体的产品对象。

优点：

1. 将一组相关或相互依赖的对象创建过程封装在一个工厂中，使得客户端可以更加方便地创建对象。

2. 抽象工厂模式可以确保一组相关或相互依赖的对象都能够被创建出来，保证了对象之间的一致性。

3. 抽象工厂模式可以提供一种简单的方式来实现产品族的概念，从而使得客户端可以更加方便地创建一组相关的对象。

缺点：

1. 抽象工厂模式的扩展性比较差，如果需要增加新的产品，需要修改抽象工厂类的接口，这会导致所有的具体工厂类都需要进行修改，从而影响系统的稳定性。

2. 抽象工厂模式的层次结构比较复杂，增加了系统的复杂度，同时也增加了系统的维护成本。

实际应用场景：

1. 当需要创建一系列相关的对象时，可以使用抽象工厂模式来将它们封装起来。例如，一个 GUI 应用程序可能需要创建一系列相关的窗口控件，如按钮、文本框和复选框，我们可以使用抽象工厂模式来封装它们的创建过程。

2. 当需要一定程度的灵活性以适应变化时，可以使用抽象工厂模式来将变化隔离开来。例如，如果我们需要支持多种不同的数据库（如 mysql、Oracle 和 SQL Server）以及它们的不同版本，我们可以使用抽象工厂模式来封装这些不同数据库的创建过程，使得我们可以轻松地添加或删除某个数据库，而不会影响客户端代码。

3. 当需要保证产品族之间的一致性时，可以使用抽象工厂模式来创建它们。例如，在创建一个复杂的产品时，需要保证其各个部分之间的兼容性，我们可以使用抽象工厂模式来创建这些部分，以确保它们之间的一致性。

4. 当需要将产品的创建和使用分离开来时，可以使用抽象工厂模式。例如，在一个大型项目中，我们可能需要将产品的创建过程放到一个独立的模块中，以便于统一管理和维护。这时，我们可以使用抽象工厂模式来封装产品的创建过程，并将其作为一个单独的模块提供给客户端使用。

代码实现（最简）

首先定义抽象工厂类 AbstractFactory，它包含了两个抽象方法 create_product_a() 和 create_product_b()：

from abc import ABC, abstractmethod

class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self):
        pass
    
    @abstractmethod
    def create_product_b(self):
        pass

接着定义具体工厂类 ConcreteFactory1 和 ConcreteFactory2，它们实现了抽象工厂类中定义的抽象方法：

class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ProductA1()
    
    def create_product_b(self):
        return ProductB1()

class ConcreteFactory2(AbstractFactory):
    def create_product_a(self):
        return ProductA2()
    
    def create_product_b(self):
        return ProductB2()

定义抽象产品类 AbstractProductA 和 AbstractProductB，它们包含了一个抽象方法 do_something()：

class AbstractProductA(ABC):
    @abstractmethod
    def do_something(self):
        pass
    
class AbstractProductB(ABC):
    @abstractmethod
    def do_something(self):
        pass

定义具体产品类 ProductA1、ProductA2、ProductB1 和 ProductB2，它们实现了抽象产品类中定义的抽象方法：

class ProductA1(AbstractProductA):
    def do_something(self):
        return "Product A1"

class ProductA2(AbstractProductA):
    def do_something(self):
        return "Product A2"

class ProductB1(AbstractProductB):
    def do_something(self):
        return "Product B1"

class ProductB2(AbstractProductB):
    def do_something(self):
        return "Product B2"

最后，我们可以使用抽象工厂模式来创建一组相关的对象，代码如下：

# 创建工厂对象
factory1 = ConcreteFactory1()
factory2 = ConcreteFactory2()

# 使用工厂对象创建产品对象
product_a1 = factory1.create_product_a()
product_b1 = factory1.create_product_b()
product_a2 = factory2.create_product_a()
product_b2 = factory2.create_product_b()

# 调用产品对象的方法
print(product_a1.do_something()) # Output: Product A1
print(product_b1.do_something()) # Output: Product B1
print(product_a2.do_something()) # Output: Product A2
print(product_b2.do_something()) # Output: Product B2

《精通Python设计模式》学习之抽象工厂

这种工厂模式用得少，

可能在游戏类的编程中用得比较多吧。

这个思路清晰一定要OK的。

class Frog:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

    def interact_with(self, obstacle):
        print(‘{} the Frog encouners {} and {}!‘.format(self,
                                                        obstacle,
                                                        obstacle.action()))

class Bug:
    def __str__(self):
        return ‘a bug‘

    def action(self):
        return ‘eats it‘

class FrogWorld:
    def __init__(self, name):
        print(self)
        self.player_name =name

    def __str__(self):
        return ‘

	-------- Frog World ------‘

    def make_character(self):
        return Frog(self.player_name)

    def make_obstacle(self):
        return Bug()

class Wizard:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

    def interact_with(self, obstacle):
        print(‘{} the Wizard battles against {} and {}!‘.format(self,
                                                                obstacle,
                                                                obstacle.action()))

class Ork:
    def __str__(self):
        return ‘an evil ork‘

    def action(self):
        return ‘kills it‘

class WizardWorld:
    def __init__(self, name):
        print(self)
        self.player_name = name

    def __str__(self):
        return ‘

	-------- Wizard World ------‘

    def make_character(self):
        return Wizard(self.player_name)

    def make_obstacle(self):
        return Ork()

class GameEnvironment:
    def __init__(self, factory):
        self.hero = factory.make_character()
        self.obstacle = factory.make_obstacle()

    def play(self):
        self.hero.interact_with(self.obstacle)


def validate_age(name):
    try:
        age = input(‘Welcome {}. How old are you? ‘.format(name))
        age = int(age)
    except ValueError as err:
        print(‘Age {} is invalid, please try again...‘.format(age))
        return (False, age)
    return (True, age)

def main():
    name = input("Hello. What‘s your name? ")
    valid_input = False
    while not valid_input:
        valid_input, age = validate_age(name)
    game = FrogWorld if age < 18 else WizardWorld
    environment = GameEnvironment(game(name))
    environment.play()

if __name__ == ‘__main__‘:
    main()