Python中如何实现模板方法模式 设计模式在框架设计中的应用

from abc import ABC, abstractmethod

class AbstractClass(ABC):
    def template_method(self):
        self.step_one()
        self.step_two()
        self.step_three()

    @abstractmethod
    def step_one(self):
        pass

    @abstractmethod
    def step_two(self):
        pass

    def step_three(self):
        print("默认的步骤三")

class ConcreteClassA(AbstractClass):
    def step_one(self):
        print("A：步骤一")

    def step_two(self):
        print("A：步骤二")

class ConcreteClassB(AbstractClass):
    def step_one(self):
        print("B：步骤一")

    def step_two(self):
        print("B：步骤二")

a = ConcreteClassA()
a.template_method()

b = ConcreteClassB()
b.template_method()

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory:
    def create_animal(self, animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError("Invalid animal type")

factory = AnimalFactory()
dog = factory.create_animal("dog")
print(dog.speak())

cat = factory.create_animal("cat")
print(cat.speak())

class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self, event):
        for observer in self._observers:
            observer.update(event)

class Observer(ABC):
    @abstractmethod
    def update(self, event):
        pass

class ConcreteObserverA(Observer):
    def update(self, event):
        print(f"Observer A received event: {event}")

class ConcreteObserverB(Observer):
    def update(self, event):
        print(f"Observer B received event: {event}")

subject = Subject()

observer_a = ConcreteObserverA()
observer_b = ConcreteObserverB()

subject.attach(observer_a)
subject.attach(observer_b)

subject.notify("Button Clicked")

subject.detach(observer_a)

subject.notify("Data Changed")

class ConfigLoaderStrategy(ABC):
    @abstractmethod
    def load_config(self, file_path):
        pass

class JsonConfigLoader(ConfigLoaderStrategy):
    def load_config(self, file_path):
        import json
        with open(file_path, 'r') as f:
            return json.load(f)

class YamlConfigLoader(ConfigLoaderStrategy):
    def load_config(self, file_path):
        import yaml
        with open(file_path, 'r') as f:
            return yaml.safe_load(f)

class ConfigManager:
    def __init__(self, strategy: ConfigLoaderStrategy):
        self.strategy = strategy

    def load_config(self, file_path):
        return self.strategy.load_config(file_path)

# 使用示例
json_loader = JsonConfigLoader()
config_manager = ConfigManager(json_loader)
config = config_manager.load_config("config.json")
print(config)

yaml_loader = YamlConfigLoader()
config_manager.strategy = yaml_loader # 更换策略
config = config_manager.load_config("config.yaml")
print(config)