Python中Abstract Factory模式实现异常问题排查与修复

核心问题分析 #

• 参数类型不匹配：客户端代码调用interact2_car时错误传入引擎对象，但该方法需要的是车轮对象，运行时会抛出AttributeError（引擎类无get_wheel方法）。
• 抽象类方法定义不规范：AbstractProductCar中的interact1_car和interact2_car未标记为抽象方法，不符合抽象工厂模式的强制约束原则。
• 字符串格式不一致：Toyota和Mercedes类的interact2_car方法中，字符串拼接缺少空格，导致输出文本格式混乱。

修复后的完整代码 #

from __future__ import annotations
from abc import ABC, abstractmethod

# AbstractFactory
class AbstractCarFactory(ABC):
    @abstractmethod
    def create_product_car(self) -> AbstractProductCar:
        pass

    @abstractmethod
    def create_product_engine(self) -> AbstractProductEngine:
        pass

    @abstractmethod
    def create_product_wheel(self) -> AbstractProductWheel:
        pass


class FordFactory(AbstractCarFactory):
    def create_product_car(self) -> AbstractProductCar:
        return Ford()

    def create_product_engine(self) -> AbstractProductEngine:
        return FordEngine()

    def create_product_wheel(self) -> AbstractProductWheel:
        return FordWheel()


class ToyotaFactory(AbstractCarFactory):
    def create_product_car(self) -> AbstractProductCar:
        return Toyota()

    def create_product_engine(self) -> AbstractProductEngine:
        return ToyotaEngine()

    def create_product_wheel(self) -> AbstractProductWheel:
        return ToyotaWheel()


class MercedesFactory(AbstractCarFactory):
    def create_product_car(self) -> AbstractProductCar:
        return Mercedes()

    def create_product_engine(self) -> AbstractProductEngine:
        return MercedesEngine()

    def create_product_wheel(self) -> AbstractProductWheel:
        return MercedesWheel()


class AbstractProductCar(ABC):
    @abstractmethod
    def info_car(self) -> str:
        pass

    @abstractmethod
    def interact1_car(self, collaborator: AbstractProductEngine) -> str:
        pass

    @abstractmethod
    def interact2_car(self, collaborator: AbstractProductWheel) -> str:
        pass


class AbstractProductEngine(ABC):
    @abstractmethod
    def get_power(self) -> str:
        pass


class FordEngine(AbstractProductEngine):
    def get_power(self) -> str:
        return "Ford Engine"


class ToyotaEngine(AbstractProductEngine):
    def get_power(self) -> str:
        return "Toyota Engine"


class MercedesEngine(AbstractProductEngine):
    def get_power(self) -> str:
        return "Mercedes Engine"


class AbstractProductWheel(ABC):
    @abstractmethod
    def get_wheel(self) -> str:
        pass


class FordWheel(AbstractProductWheel):
    def get_wheel(self) -> str:
        return "Ford Wheel"


class ToyotaWheel(AbstractProductWheel):
    def get_wheel(self) -> str:
        return "Toyota Wheel"


class MercedesWheel(AbstractProductWheel):
    def get_wheel(self) -> str:
        return "Mercedes Wheel"


class Ford(AbstractProductCar):
    def info_car(self) -> str:
        return "Ford"

    def interact1_car(self, collaborator: AbstractProductEngine) -> str:
        result1 = self.info_car() + " set Engine " + collaborator.get_power()
        return f"Result of setting engine to the body: ({result1})"

    def interact2_car(self, collaborator: AbstractProductWheel) -> str:
        result2 = self.info_car() + " set Wheels " + collaborator.get_wheel()
        return f"Result of final assembly: {result2}"


class Toyota(AbstractProductCar):
    def info_car(self) -> str:
        return "Toyota"

    def interact1_car(self, collaborator: AbstractProductEngine) -> str:
        result1 = self.info_car() + " set Engine " + collaborator.get_power()
        return f"Result of setting engine to the body: ({result1})"

    def interact2_car(self, collaborator: AbstractProductWheel) -> str:
        result2 = self.info_car() + " set Wheels " + collaborator.get_wheel()
        return f"Result of final assembly: {result2}"


class Mercedes(AbstractProductCar):
    def info_car(self) -> str:
        return "Mercedes"

    def interact1_car(self, collaborator: AbstractProductEngine) -> str:
        result1 = self.info_car() + " set Engine " + collaborator.get_power()
        return f"Result of setting engine to the body: ({result1})"

    def interact2_car(self, collaborator: AbstractProductWheel) -> str:
        result2 = self.info_car() + " set Wheels " + collaborator.get_wheel()
        return f"Result of final assembly: {result2}"

def client_code(factory: AbstractCarFactory) -> None:
    product_car = factory.create_product_car()
    product_engine = factory.create_product_engine()
    product_wheel = factory.create_product_wheel()

    print(f"{product_car.interact1_car(product_engine)}\n"
          f"{product_car.interact2_car(product_wheel)}")


if __name__ == "__main__":
    print("Client: Testing first factory:")
    client_code(FordFactory())

    print("\nClient: Testing second factory:")
    client_code(ToyotaFactory())

    print("\nClient: Testing third factory:")
    client_code(MercedesFactory())

修复说明 #

1. 修正参数传递错误：在client_code中新增创建车轮对象的逻辑，调用interact2_car时传入正确的车轮对象，解决类型不匹配问题。
2. 规范抽象类方法：给AbstractProductCar中的interact1_car和interact2_car添加@abstractmethod装饰器，强制子类实现这些方法，符合抽象类设计规范。
3. 统一输出格式：修复Toyota和Mercedes类中字符串拼接的空格缺失问题，保证输出文本格式一致。

内容的提问来源于stack exchange，提问作者Yanka Smetanka