常用设计模式

最新推荐文章于 2025-02-22 21:36:56 发布

原创最新推荐文章于 2025-02-22 21:36:56 发布 · 529 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式

1. 单例模式 (Singleton)

概念：确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。

何时使用：

当你需要一个全局共享的对象，例如数据库连接池、日志管理器、配置管理器等。
需要避免多个实例浪费资源或者产生不一致的状态时。

实现方式：

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

# 使用方式
obj1 = Singleton()
obj2 = Singleton()

print(obj1 is obj2)  # True, obj1 和 obj2 是同一个实例

在实际工作中的应用：

数据库连接池：你不希望每次请求时都创建新的数据库连接，而是希望复用现有连接。
配置管理：系统的配置文件通常在应用启动时加载一次，之后需要在不同模块中共享，使用单例模式避免重复加载。

2. 工厂模式 (Factory Pattern)

概念：通过定义一个接口来创建对象，让子类决定实例化哪个类。

何时使用：

当创建对象的过程复杂，或者当你希望将对象的创建与使用分离时。
当系统中有多个相关的对象需要创建，并且创建过程可能发生变化时。

实现方式：

class Animal:
    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: str):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        return None

# 使用方式
factory = AnimalFactory()
dog = factory.create_animal("dog")
print(dog.speak())  # Woof

在实际工作中的应用：

API客户端：如果你的后端服务需要对接多个第三方API，不同API的客户端实现不同，你可以使用工厂模式来根据配置动态生成适当的API客户端实例。
消息队列：如果你使用不同的消息队列系统（如RabbitMQ、Kafka等），可以通过工厂模式来创建不同类型的队列客户端。

3. 策略模式 (Strategy Pattern)

概念：定义一系列的算法，把它们封装成一个个独立的策略对象，允许客户端在运行时选择不同的策略。

何时使用：

当系统中有多个算法或操作，且希望根据不同的条件来动态选择其中一个时。
需要避免条件语句（如 if-else）的繁琐，并使得算法可以灵活切换。

实现方式：

class DiscountStrategy:
    def apply_discount(self, price: float) -> float:
        pass

class NoDiscount(DiscountStrategy):
    def apply_discount(self, price: float) -> float:
        return price

class TenPercentDiscount(DiscountStrategy):
    def apply_discount(self, price: float) -> float:
        return price * 0.9

class ShoppingCart:
    def __init__(self, strategy: DiscountStrategy):
        self.strategy = strategy

    def checkout(self, price: float):
        return self.strategy.apply_discount(price)

# 使用方式
cart1 = ShoppingCart(NoDiscount())
print(cart1.checkout(100))  # 100

cart2 = ShoppingCart(TenPercentDiscount())
print(cart2.checkout(100))  # 90

在实际工作中的应用：

支付系统：不同的支付方式（支付宝、微信支付等）可以使用策略模式来统一接口，便于后期增加新的支付方式。
缓存策略：在后端开发中，缓存策略（例如 LRU 缓存、FIFO 缓存等）可以通过策略模式进行切换，确保根据业务需求选择最合适的缓存策略。

4. 观察者模式 (Observer Pattern)

概念：定义对象之间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会自动收到通知并更新。

何时使用：

当一个对象的状态改变需要同时影响多个其他对象时。
常用于事件驱动系统或者GUI系统中。

实现方式：

class Observer:
    def update(self, message: str):
        pass

class ConcreteObserver(Observer):
    def update(self, message: str):
        print(f"Received message: {message}")

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

    def add_observer(self, observer: Observer):
        self._observers.append(observer)

    def remove_observer(self, observer: Observer):
        self._observers.remove(observer)

    def notify_observers(self, message: str):
        for observer in self._observers:
            observer.update(message)

# 使用方式
subject = Subject()
observer1 = ConcreteObserver()
subject.add_observer(observer1)

subject.notify_observers("Hello Observers!")  # observer1 will receive the message

在实际工作中的应用：

事件通知系统：例如，当某个事件（如订单状态变更）发生时，系统需要通知多个模块（如短信、邮件、后台任务）来进行处理。
实时消息系统：当数据变化时，客户端需要实时获取更新，适用于 WebSocket、消息推送等场景。

5. 装饰器模式 (Decorator Pattern)

概念：动态地给对象添加额外的职责，而不改变其结构。

何时使用：

当你需要扩展对象的功能，而不想通过继承来增加子类时。
在不修改类的情况下增加新的功能。

实现方式：

class Coffee:
    def cost(self):
        return 5

class MilkDecorator:
    def __init__(self, coffee: Coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 2

class SugarDecorator:
    def __init__(self, coffee: Coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 1

# 使用方式
coffee = Coffee()
milk_coffee = MilkDecorator(coffee)
sugar_milk_coffee = SugarDecorator(milk_coffee)

print(sugar_milk_coffee.cost())  # 8

在实际工作中的应用：

中间件系统：在 Web 框架中，中间件通过装饰器模式对请求和响应进行增强处理，例如日志记录、权限验证等。
功能扩展：当你需要动态添加或修改对象的行为时（例如日志功能、性能监控等），装饰器模式可以帮助你以更灵活的方式进行。

6. 命令模式 (Command Pattern)

概念：将一个请求封装成一个对象，从而使你可以用不同的请求对客户进行参数化。

何时使用：

当你需要将请求的发送者和接收者解耦时。
适用于队列请求、事务处理等场景。

实现方式：

class Command:
    def execute(self):
        pass

class LightOnCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.turn_on()

class Light:
    def turn_on(self):
        print("Light is ON")

class RemoteControl:
    def __init__(self):
        self.command = None

    def set_command(self, command: Command):
        self.command = command

    def press_button(self):
        self.command.execute()

# 使用方式
light = Light()
light_on = LightOnCommand(light)
remote = RemoteControl()
remote.set_command(light_on)
remote.press_button()  # Light is ON