【架构设计】设计模式实战与应用：从理论到代码实现

【架构设计】设计模式实战与应用：从理论到代码实现

引言

设计模式是软件开发中经过验证的解决方案，用于解决特定场景下的常见问题。掌握设计模式有助于编写更优雅、可维护和可扩展的代码。本文将详细介绍常用的设计模式及其在实际项目中的应用。

一、创建型模式

1.1 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供全局访问点。

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

# 线程安全的单例
import threading

class ThreadSafeSingleton:
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls):
        with cls._lock:
            if cls._instance is None:
                cls._instance = super().__new__(cls)
        return cls._instance

# 使用示例
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # True

1.2 工厂模式（Factory Pattern）

工厂模式通过工厂方法创建对象，将对象创建与使用分离。

from abc import ABC, abstractmethod

class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

class ConcreteProductA(Product):
    def operation(self):
        return "Product A operation"

class ConcreteProductB(Product):
    def operation(self):
        return "Product B operation"

class Factory:
    def create_product(self, product_type):
        if product_type == "A":
            return ConcreteProductA()
        elif product_type == "B":
            return ConcreteProductB()
        else:
            raise ValueError("Invalid product type")

# 使用示例
factory = Factory()
product_a = factory.create_product("A")
print(product_a.operation())  # Product A operation

1.3 抽象工厂模式（Abstract Factory）

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族。

from abc import ABC, abstractmethod

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

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()

# 使用示例
factory1 = ConcreteFactory1()
product_a1 = factory1.create_product_a()
product_b1 = factory1.create_product_b()

1.4 建造者模式（Builder Pattern）

建造者模式将复杂对象的构建过程与其表示分离。

class Product:
    def __init__(self):
        self.parts = []
    
    def add_part(self, part):
        self.parts.append(part)
    
    def show(self):
        print(f"Product parts: {self.parts}")

class Builder(ABC):
    @abstractmethod
    def build_part_a(self):
        pass
    
    @abstractmethod
    def build_part_b(self):
        pass
    
    @abstractmethod
    def get_product(self):
        pass

class ConcreteBuilder(Builder):
    def __init__(self):
        self.product = Product()
    
    def build_part_a(self):
        self.product.add_part("Part A")
    
    def build_part_b(self):
        self.product.add_part("Part B")
    
    def get_product(self):
        return self.product

class Director:
    def __init__(self, builder):
        self.builder = builder
    
    def construct(self):
        self.builder.build_part_a()
        self.builder.build_part_b()

# 使用示例
builder = ConcreteBuilder()
director = Director(builder)
director.construct()
product = builder.get_product()
product.show()  # Product parts: ['Part A', 'Part B']

二、结构型模式

2.1 适配器模式（Adapter）

适配器模式将一个类的接口转换成客户端期望的另一个接口。

class Target:
    def request(self):
        return "Target request"

class Adaptee:
    def specific_request(self):
        return "Adaptee specific request"

class Adapter(Target):
    def __init__(self, adaptee):
        self.adaptee = adaptee
    
    def request(self):
        return f"Adapter: {self.adaptee.specific_request()}"

# 使用示例
adaptee = Adaptee()
adapter = Adapter(adaptee)
print(adapter.request())  # Adapter: Adaptee specific request

2.2 装饰器模式（Decorator）

装饰器模式动态地给对象添加额外职责。

class Component(ABC):
    @abstractmethod
    def operation(self):
        pass

class ConcreteComponent(Component):
    def operation(self):
        return "ConcreteComponent"

class Decorator(Component, ABC):
    def __init__(self, component):
        self.component = component
    
    @abstractmethod
    def operation(self):
        pass

class ConcreteDecoratorA(Decorator):
    def operation(self):
        return f"DecoratorA({self.component.operation()})"

class ConcreteDecoratorB(Decorator):
    def operation(self):
        return f"DecoratorB({self.component.operation()})"

# 使用示例
component = ConcreteComponent()
decorated = ConcreteDecoratorA(ConcreteDecoratorB(component))
print(decorated.operation())  # DecoratorA(DecoratorB(ConcreteComponent))

2.3 代理模式（Proxy）

代理模式为其他对象提供代理控制访问。

class Subject(ABC):
    @abstractmethod
    def request(self):
        pass

class RealSubject(Subject):
    def request(self):
        return "RealSubject request"

class Proxy(Subject):
    def __init__(self):
        self._real_subject = None
    
    def request(self):
        if self._real_subject is None:
            self._real_subject = RealSubject()
        return f"Proxy: {self._real_subject.request()}"

# 使用示例
proxy = Proxy()
print(proxy.request())  # Proxy: RealSubject request

2.4 组合模式（Composite）

组合模式将对象组合成树形结构，以表示整体-部分的层次关系。

class Component(ABC):
    def __init__(self, name):
        self.name = name
    
    @abstractmethod
    def operation(self, depth=0):
        pass

class Leaf(Component):
    def operation(self, depth=0):
        return "  " * depth + f"Leaf: {self.name}"

class Composite(Component):
    def __init__(self, name):
        super().__init__(name)
        self.children = []
    
    def add(self, component):
        self.children.append(component)
    
    def remove(self, component):
        self.children.remove(component)
    
    def operation(self, depth=0):
        result = "  " * depth + f"Composite: {self.name}\n"
        for child in self.children:
            result += child.operation(depth + 1) + "\n"
        return result.strip()

# 使用示例
root = Composite("Root")
root.add(Leaf("Leaf 1"))
branch = Composite("Branch")
branch.add(Leaf("Leaf 2"))
branch.add(Leaf("Leaf 3"))
root.add(branch)
print(root.operation())

三、行为型模式

3.1 观察者模式（Observer）

观察者模式定义对象间一对多的依赖关系，当一个对象状态改变时，所有依赖者都会收到通知。

class Subject:
    def __init__(self):
        self._observers = []
    
    def attach(self, observer):
        if observer not in self._observers:
            self._observers.append(observer)
    
    def detach(self, observer):
        self._observers.remove(observer)
    
    def notify(self):
        for observer in self._observers:
            observer.update(self)

class ConcreteSubject(Subject):
    def __init__(self):
        super().__init__()
        self._state = None
    
    @property
    def state(self):
        return self._state
    
    @state.setter
    def state(self, value):
        self._state = value
        self.notify()

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

class ConcreteObserverA(Observer):
    def update(self, subject):
        print(f"Observer A: Subject state changed to {subject.state}")

class ConcreteObserverB(Observer):
    def update(self, subject):
        print(f"Observer B: Subject state changed to {subject.state}")

# 使用示例
subject = ConcreteSubject()
observer_a = ConcreteObserverA()
observer_b = ConcreteObserverB()

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

subject.state = "New State"
# Observer A: Subject state changed to New State
# Observer B: Subject state changed to New State

3.2 策略模式（Strategy）

策略模式定义一系列算法，封装每个算法，并使它们可以互换。

class Strategy(ABC):
    @abstractmethod
    def execute(self, data):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self, data):
        return sorted(data)

class ConcreteStrategyB(Strategy):
    def execute(self, data):
        return sorted(data, reverse=True)

class Context:
    def __init__(self, strategy):
        self._strategy = strategy
    
    def set_strategy(self, strategy):
        self._strategy = strategy
    
    def execute_strategy(self, data):
        return self._strategy.execute(data)

# 使用示例
data = [3, 1, 4, 1, 5, 9]

context = Context(ConcreteStrategyA())
print(context.execute_strategy(data))  # [1, 1, 3, 4, 5, 9]

context.set_strategy(ConcreteStrategyB())
print(context.execute_strategy(data))  # [9, 5, 4, 3, 1, 1]

3.3 命令模式（Command）

命令模式将请求封装成对象，以便使用不同的请求、队列或日志来参数化其他对象。

class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

class ConcreteCommand(Command):
    def __init__(self, receiver):
        self._receiver = receiver
    
    def execute(self):
        self._receiver.action()

class Receiver:
    def action(self):
        return "Receiver action"

class Invoker:
    def __init__(self):
        self._commands = []
    
    def add_command(self, command):
        self._commands.append(command)
    
    def execute_commands(self):
        results = []
        for command in self._commands:
            results.append(command.execute())
        return results

# 使用示例
receiver = Receiver()
command = ConcreteCommand(receiver)
invoker = Invoker()
invoker.add_command(command)
print(invoker.execute_commands())  # ['Receiver action']

3.4 模板方法模式（Template Method）

模板方法模式定义算法骨架，将某些步骤延迟到子类实现。

class AbstractClass(ABC):
    def template_method(self):
        self.base_operation1()
        self.required_operations()
        self.base_operation2()
    
    def base_operation1(self):
        return "Base Operation 1"
    
    def base_operation2(self):
        return "Base Operation 2"
    
    @abstractmethod
    def required_operations(self):
        pass

class ConcreteClass(AbstractClass):
    def required_operations(self):
        return "Concrete Operation"

# 使用示例
concrete = ConcreteClass()
print(concrete.template_method())
# Base Operation 1
# Concrete Operation
# Base Operation 2

3.5 状态模式（State）

状态模式允许对象在内部状态改变时改变其行为。

class State(ABC):
    @abstractmethod
    def handle(self, context):
        pass

class ConcreteStateA(State):
    def handle(self, context):
        print("State A handling")
        context.state = ConcreteStateB()

class ConcreteStateB(State):
    def handle(self, context):
        print("State B handling")
        context.state = ConcreteStateA()

class Context:
    def __init__(self):
        self._state = ConcreteStateA()
    
    @property
    def state(self):
        return self._state
    
    @state.setter
    def state(self, state):
        self._state = state
    
    def request(self):
        self._state.handle(self)

# 使用示例
context = Context()
context.request()  # State A handling
context.request()  # State B handling
context.request()  # State A handling

四、实战案例：电商订单系统

4.1 订单状态管理（状态模式）

class OrderState(ABC):
    @abstractmethod
    def handle_payment(self, order):
        pass
    
    @abstractmethod
    def handle_shipment(self, order):
        pass
    
    @abstractmethod
    def handle_delivery(self, order):
        pass

class PendingState(OrderState):
    def handle_payment(self, order):
        print("Payment received")
        order.state = PaidState()
    
    def handle_shipment(self, order):
        print("Cannot ship without payment")
    
    def handle_delivery(self, order):
        print("Cannot deliver without payment")

class PaidState(OrderState):
    def handle_payment(self, order):
        print("Already paid")
    
    def handle_shipment(self, order):
        print("Order shipped")
        order.state = ShippedState()
    
    def handle_delivery(self, order):
        print("Cannot deliver before shipping")

class ShippedState(OrderState):
    def handle_payment(self, order):
        print("Already paid")
    
    def handle_shipment(self, order):
        print("Already shipped")
    
    def handle_delivery(self, order):
        print("Order delivered")
        order.state = DeliveredState()

class DeliveredState(OrderState):
    def handle_payment(self, order):
        print("Order completed")
    
    def handle_shipment(self, order):
        print("Order completed")
    
    def handle_delivery(self, order):
        print("Already delivered")

class Order:
    def __init__(self):
        self._state = PendingState()
    
    @property
    def state(self):
        return self._state
    
    @state.setter
    def state(self, state):
        self._state = state
    
    def pay(self):
        self._state.handle_payment(self)
    
    def ship(self):
        self._state.handle_shipment(self)
    
    def deliver(self):
        self._state.handle_delivery(self)

# 使用示例
order = Order()
order.pay()    # Payment received
order.ship()   # Order shipped
order.deliver() # Order delivered

4.2 通知系统（观察者模式）

class OrderSubject:
    def __init__(self):
        self._observers = []
    
    def attach(self, observer):
        self._observers.append(observer)
    
    def notify(self, order):
        for observer in self._observers:
            observer.update(order)

class EmailNotifier:
    def update(self, order):
        print(f"Sending email for order {order.id}: {order.status}")

class SmsNotifier:
    def update(self, order):
        print(f"Sending SMS for order {order.id}: {order.status}")

class AppNotifier:
    def update(self, order):
        print(f"Sending app notification for order {order.id}: {order.status}")

class Order:
    def __init__(self, order_id):
        self.id = order_id
        self.status = "pending"
        self.subject = OrderSubject()
    
    def update_status(self, status):
        self.status = status
        self.subject.notify(self)

# 使用示例
order = Order("ORD001")
email_notifier = EmailNotifier()
sms_notifier = SmsNotifier()

order.subject.attach(email_notifier)
order.subject.attach(sms_notifier)

order.update_status("paid")
# Sending email for order ORD001: paid
# Sending SMS for order ORD001: paid

五、设计模式选择指南

设计模式	适用场景	解决的问题
单例模式	需要全局唯一实例	控制对象创建数量
工厂模式	对象创建复杂	解耦创建与使用
抽象工厂	产品族创建	保持产品一致性
建造者模式	复杂对象构建	分步构建复杂对象
适配器模式	接口不兼容	转换接口
装饰器模式	动态添加功能	不修改类扩展功能
代理模式	需要控制访问	延迟加载、权限控制
组合模式	树形结构	统一处理整体与部分
观察者模式	一对多依赖	状态变化通知
策略模式	算法需要切换	算法解耦
命令模式	请求需要封装	日志、撤销操作
模板方法	算法骨架固定	复用算法结构
状态模式	对象行为随状态变化	消除大量条件判断

六、设计原则回顾

6.1 SOLID原则

• 单一职责原则（SRP）：一个类只负责一个功能
• 开闭原则（OCP）：对扩展开放，对修改关闭
• 里氏替换原则（LSP）：子类可以替换父类
• 接口隔离原则（ISP）：使用多个专用接口
• 依赖倒置原则（DIP）：依赖抽象而非具体实现

6.2 设计模式核心思想

1. 封装变化：将变化的部分封装起来
2. 面向接口编程：依赖抽象而非具体
3. 组合优于继承：通过组合获得更灵活的设计
4. 最少知识原则：减少对象间的依赖

七、结语

设计模式是软件开发的宝贵财富，掌握它们可以帮助我们编写更优秀的代码。但需要注意的是，设计模式不是银弹，应该根据实际情况选择合适的模式。过度使用设计模式可能会导致代码过于复杂。

#设计模式 #架构设计 #SOLID #面向对象