当前位置：首页 > news >正文

一个电商场景串联23种设计模式：创建型、结构型和行为型

news 来源：原创 2025/5/6 6:40:01

理解了！你希望有一个具体的项目案例，能够涵盖所有23种设计模式，并且将它们分类为创建型、结构型和行为型。这个需求非常好，能够帮助你从实际的应用场景理解每种设计模式的用法。

为了实现这个目标，我将为你设计一个电商系统，并将23种设计模式通过具体的功能需求应用到这个系统中。系统的功能包括订单管理、支付管理、商品管理、用户管理等，而设计模式将被应用到各个功能模块中。

一. 概念篇

🧠 电商系统的设计模式实现

创建型模式 (Creational Patterns)

这些模式帮助我们灵活地创建对象。创建型模式主要解决如何高效地创建对象，减少对象创建的复杂度。

单例模式（Singleton）：
- 用途：确保一个类只有一个实例，常用于配置管理类、数据库连接等。
- 应用：支付管理器类，确保支付模块只有一个实例。
工厂方法模式（Factory Method）：
- 用途：定义一个用于创建对象的接口，允许子类决定实例化哪一个类。
- 应用：创建不同类型的商品（如电子产品、衣服等）。
抽象工厂模式（Abstract Factory）：
- 用途：提供一个接口，用于创建一系列相关的对象，而无需指定它们的具体类。
- 应用：创建不同类型的支付方式（如信用卡支付、支付宝支付）。
建造者模式（Builder）：
- 用途：通过一步步的构建，构造一个复杂的对象。
- 应用：构建一个复杂的订单对象，包含商品、支付方式、送货方式等。
原型模式（Prototype）：
- 用途：通过复制现有的对象来创建新对象，而不需要重新创建。
- 应用：克隆一个订单对象，用于修改或再次提交。

结构型模式 (Structural Patterns)

这些模式帮助我们简化对象之间的组合关系。结构型模式主要关注类和对象如何组织和组合，简化系统的结构。

适配器模式（Adapter）：
- 用途：使得原本由于接口不兼容而不能一起工作的类可以协同工作。
- 应用：将不同的支付方式（如信用卡支付和支付宝支付）转换为统一的支付接口。
桥接模式（Bridge）：
- 用途：将抽象部分与实现部分分离，使它们可以独立地变化。
- 应用：将支付方式和通知方式分离，可以独立改变支付和通知的实现。
装饰者模式（Decorator）：
- 用途：动态地给对象添加一些额外的职责，不影响其他对象。
- 应用：对商品应用优惠或折扣，包装商品对象。
组合模式（Composite）：
- 用途：将对象组合成树形结构，表示“部分-整体”层次结构。
- 应用：管理一个订单中的多个商品。
外观模式（Facade）：
- 用途：提供一个统一的接口，简化系统的使用。
- 应用：为用户提供一个简化的订单支付、配送等操作的接口。
享元模式（Flyweight）：
- 用途：通过共享技术来支持大量的细粒度对象，减少内存占用。
- 应用：商品的描述信息（如价格、名称）在多个订单中共享。
代理模式（Proxy）：
- 用途：为其他对象提供代理以控制对该对象的访问。
- 应用：为支付功能提供一个代理类，控制支付流程的访问权限。

行为型模式 (Behavioral Patterns)

这些模式主要关注对象之间的交互和职责分配，确保系统中的对象能够协同工作。

责任链模式（Chain of Responsibility）：
- 用途：为请求创建一个处理链，沿着链传递，直到某个对象处理请求。
- 应用：订单处理中的多个步骤（如库存检查、支付处理、发货处理）通过责任链模式进行处理。
命令模式（Command）：
- 用途：将请求封装成对象，从而允许用户对请求排队、记录日志、以及支持可撤销操作。
- 应用：购物车中的每个操作（如添加商品、删除商品）封装为命令对象。
解释器模式（Interpreter）：
- 用途：给定一个语言，定义其文法，并解释句子。
- 应用：订单中的一些复杂的价格计算规则，可以使用解释器模式进行处理。
迭代器模式（Iterator）：
- 用途：提供一种方法，顺序访问一个聚合对象中的各个元素，而不暴露该对象的内部结构。
- 应用：遍历订单中的所有商品，并进行相应的操作（如价格计算）。
中介者模式（Mediator）：
- 用途：通过一个中介对象来简化多个对象之间的通信。
- 应用：不同模块之间的交互（如支付、配送、库存管理）通过中介者模式协调。
备忘录模式（Memento）：
- 用途：在不暴露对象实现的情况下，捕获对象的内部状态，并在需要时恢复。
- 应用：保存订单状态（如支付状态），以便在需要时恢复。
观察者模式（Observer）：
- 用途：当一个对象的状态发生改变时，所有依赖于它的对象都会收到通知并自动更新。
- 应用：当订单状态（如支付状态）变化时，通知相关的模块（如用户、配送部门）。
状态模式（State）：
- 用途：允许一个对象在其内部状态改变时改变其行为。
- 应用：订单可以处于不同的状态（如“待支付”、“已支付”、“已发货”），每个状态的行为不同。
策略模式（Strategy）：
- 用途：定义一系列算法，将每个算法封装起来，并使它们可以互换。
- 应用：根据用户选择的支付方式（如信用卡、支付宝等），选择不同的支付策略。
模板方法模式（Template Method）：

用途：定义一个操作中的算法框架，将一些步骤延迟到子类中去实现。
应用：订单处理的过程可以定义模板方法，每个步骤的具体实现交给子类来完成。

访问者模式（Visitor）：

用途：表示一个作用于某对象结构中的各元素的操作，可以通过访问者来定义新的操作。
应用：在订单中添加新的操作（如计算税费），而不改变订单的结构。

🧠 总结：

创建型模式：专注于如何创建对象，减少对象创建的复杂性，提升系统的灵活性。
结构型模式：通过组合和组织类和对象，使得系统更简洁、高效。
行为型模式：专注于对象之间的交互，保证它们高效地协作。

二. 实现篇

设计模式总结：解决电商场景中的问题

在电商平台中，设计模式可以帮助解决各种架构、行为和交互问题。下面我们对每种设计模式进行总结，表达它们在电商场景中解决的具体问题，并简要描述它们如何解决这些问题。

1️⃣ 创建型设计模式 (Creational Patterns)

1. 单例模式 (Singleton)

解决的问题：确保在电商系统中某些组件如支付处理器、日志记录器等全局只有一个实例，避免重复创建和状态共享。
解决方法：通过提供一个静态方法get_instance()来创建和访问单一实例。

class PaymentProcessor:_instance = None  # 类变量，存储单例实例@staticmethoddef get_instance():# 如果实例不存在，则创建一个新的实例if not PaymentProcessor._instance:PaymentProcessor._instance = PaymentProcessor()return PaymentProcessor._instance  # 返回唯一的实例# 使用单例模式
payment_processor = PaymentProcessor.get_instance()  # 获取单例实例

注释：

PaymentProcessor类用单例模式确保全局只有一个实例。
get_instance方法确保实例化PaymentProcessor时不会重复创建，返回同一个实例。

2. 工厂方法模式 (Factory Method)

解决的问题：创建不同类型的支付方式时，避免硬编码，便于扩展新的支付方式。
解决方法：定义一个工厂类，基于支付方式类型动态创建相应的支付对象。

class Payment:def process(self, amount):pass  # 声明一个接口，允许不同支付方式处理支付class CreditCardPayment(Payment):def process(self, amount):# 使用信用卡支付print(f"Paid {amount} via Credit Card")class PaymentFactory:@staticmethoddef create_payment(payment_type: str) -> Payment:# 根据不同支付类型返回不同的支付方式对象if payment_type == "credit_card":return CreditCardPayment()  # 返回信用卡支付实例else:raise ValueError("Unknown payment type")  # 如果支付类型未知，抛出异常# 创建支付方式实例
payment = PaymentFactory.create_payment("credit_card")  # 创建一个信用卡支付对象
payment.process(100)  # 执行支付操作

注释：

PaymentFactory根据不同的支付方式返回不同的支付对象。
CreditCardPayment实现了Payment接口，具体处理信用卡支付。

3. 抽象工厂模式 (Abstract Factory)

解决的问题：为不同平台（比如不同操作系统或支付渠道）提供统一的支付接口。
解决方法：使用抽象工厂来提供一组相关对象（如不同支付方式的实现）。

from abc import ABC, abstractmethod# 定义支付的抽象工厂类
class PaymentFactory(ABC):@abstractmethoddef create_payment(self):pass  # 工厂类的抽象方法class CreditCardPaymentFactory(PaymentFactory):def create_payment(self):return CreditCardPayment()  # 返回信用卡支付对象 #【见上一模式代码】class PaymentClient:def __init__(self, factory: PaymentFactory):# 使用工厂来创建支付方式self.payment = factory.create_payment()# 使用抽象工厂模式
factory = CreditCardPaymentFactory()  # 创建信用卡支付工厂
client = PaymentClient(factory)  # 使用工厂创建支付方式
client.payment.process(200)  # 执行支付

注释：

PaymentFactory定义了抽象的支付工厂接口。
CreditCardPaymentFactory是具体工厂类，用来创建信用卡支付对象。

4. 建造者模式 (Builder)【】

解决的问题：订单的构建过程可能比较复杂，例如包含多个商品的订单，且不同的订单可能需要不同的参数。
解决方法：使用建造者模式，通过链式调用逐步构建复杂的订单对象。

class Order:def __init__(self):self.items = []  # 商品列表self.payment = None  # 支付方式def add_item(self, item):self.items.append(item)  # 添加商品到订单def set_payment(self, payment):self.payment = payment  # 设置支付方式class OrderBuilder:def __init__(self):self.order = Order()  # 创建一个空的订单def add_item(self, item):self.order.add_item(item)  # 链式调用，添加商品return self  # 返回builder对象以便继续链式调用def set_payment(self, payment):self.order.set_payment(payment)  # 设置支付方式return self  # 返回builder对象def build(self):return self.order  # 返回构建完成的订单# 使用建造者模式构建订单
builder = OrderBuilder()
order = builder.add_item("Laptop").set_payment("Credit Card").build()  # 建造订单

注释：

OrderBuilder允许通过链式调用一步步构建订单对象。
最终通过build()方法返回完整的订单对象。

5. 原型模式 (Prototype)

解决的问题：需要克隆订单对象或商品对象，避免重复构建相同对象，减少内存开销。
解决方法：提供一个clone()方法来复制对象，而无需重新创建新实例。

import copyclass Order:def __init__(self, items=None):if items is None:self.items = []else:self.items = items  # 初始化订单的商品列表def clone(self):return copy.deepcopy(self)  # 深拷贝当前订单对象# 克隆一个订单
order1 = Order(["Laptop", "Phone"])  # 创建一个订单
order2 = order1.clone()  # 克隆订单
order2.items.append("Tablet")  # 修改克隆订单的商品

注释：

Order类提供了clone()方法，可以克隆一个订单对象。
使用copy.deepcopy来实现深拷贝，确保克隆的订单是独立的。

2️⃣ 结构型设计模式 (Structural Patterns)

6. 适配器模式 (Adapter)

解决的问题：电商系统可能需要集成不同支付接口（如支付宝、微信支付、银行卡等），它们有不同的API，需要统一接口。
解决方法：定义一个适配器模式，将不同支付API适配为统一接口，便于替换和扩展。

class Alipay:def make_payment(self, amount):print(f"Paid {amount} via Alipay")class PaymentAdapter:def __init__(self, alipay):self.alipay = alipay  # 适配Alipay对象def process(self, amount):self.alipay.make_payment(amount)  # 适配并调用Alipay的支付方法# 使用适配器模式
alipay = Alipay()
payment_adapter = PaymentAdapter(alipay)  # 创建适配器
payment_adapter.process(100)  # 调用适配器进行支付

注释：

PaymentAdapter将Alipay的支付方式适配为统一的接口。

7. 桥接模式 (Bridge)

解决的问题：支付和通知功能可能分别依赖于不同的具体实现，但它们在业务流程中需要一起协调工作。
解决方法：将支付和通知功能通过桥接模式分离，让它们各自独立变化而不影响彼此的实现。

class Payment:def __init__(self, notification):self.notification = notification  # 聚合通知方式对象def process(self, amount):print(f"Processing payment of {amount}")self.notification.notify()  # 调用通知方式class Notification:def notify(self):pass  # 抽象通知方法class EmailNotification(Notification):def notify(self):print("Sending email notification")  # 具体的通知实现# 使用桥接模式
payment = Payment(EmailNotification())  # 选择Email通知方式
payment.process(200)

注释：

Payment类通过桥接模式实现支付与通知功能的分离，允许更灵活的组合。

8. 装饰者模式 (Decorator)

解决的问题：电商系统中的支付方式可能会有折扣、优惠券等附加功能，这些功能可以动态增加到支付过程中。
解决方法：通过装饰器模式，在支付对象基础上动态添加额外的行为（如折扣、赠品等）。

class Payment:def process(self, amount):pass  # 支付接口class CreditCardPayment(Payment):def process(self, amount):print(f"Paid {amount} via Credit Card")class PaymentWithDiscount(Payment):def __init__(self, payment, discount):self.payment = payment  # 传入原支付对象self.discount = discount  # 折扣信息def process(self, amount):amount_after_discount = amount * (1 - self.discount)print(f"After discount: {amount_after_discount}")self.payment.process(amount_after_discount)  # 调用原支付对象# 使用装饰者模式
payment = PaymentWithDiscount(CreditCardPayment(), 0.1)  # 包装为带折扣的支付
payment.process(500)

注释：

PaymentWithDiscount是一个装饰者，它在原支付方法上增加了折扣功能。

9. 组合模式 (Composite)

解决的问题：订单由多个商品组成，有些商品可能是单独购买的，有些可能是套餐，组合模式帮助统一管理和操作这些商品。
解决方法：通过组合模式将多个商品或套餐包装成一个订单对象，统一处理。

class Product:def __init__(self, name, price):self.name = nameself.price = priceclass Order:def __init__(self):self.products = []  # 商品列表def add_product(self, product):self.products.append(product)  # 添加商品到订单def total_price(self):return sum([product.price for product in self.products])  # 计算总价格# 使用组合模式
order = Order()
order.add_product(Product("Laptop", 1000))
order.add_product(Product("Phone", 500))
print(f"Total price: {order.total_price()}")

注释：

Order和Product实现了组合模式，通过Order类可以添加多个Product，计算总价格。

10. 外观模式 (Facade)

解决的问题：电商系统中的支付、配送、订单管理等功能非常复杂，用户需要一个简化的接口来处理这些操作。
解决方法：使用外观模式，提供一个简单的接口来整合多个复杂子系统（如支付、物流、订单处理）。

class PaymentFacade:def __init__(self, payment_processor, notification_service):self.payment_processor = payment_processorself.notification_service = notification_servicedef make_payment(self, amount):self.payment_processor.process_payment(amount)self.notification_service.send_notification(f"Payment of {amount} processed.")# 使用外观模式
payment_facade = PaymentFacade(PaymentProcessor(), EmailNotification())
payment_facade.make_payment(300)

注释：

PaymentFacade封装了复杂的支付和通知流程，提供简化接口。

11. 享元模式 (Flyweight)

解决的问题：商品信息可能会被多次共享，尤其是在库存管理中，重复的商品信息占用内存过多。
解决方法：使用享元模式来共享相同的商品信息对象，只保留必要的状态（如库存数量等）。

class Product:def __init__(self, name, price):self.name = nameself.price = priceclass ProductFactory:_products = {}@staticmethoddef get_product(name, price):if name not in ProductFactory._products:ProductFactory._products[name] = Product(name, price)return ProductFactory._products[name]# 使用享元模式
product1 = ProductFactory.get_product("Laptop", 1000)
product2 = ProductFactory.get_product("Laptop", 1000)  # Reuses existing object

注释：

ProductFactory共享相同的Product实例，减少内存消耗。

12. 代理模式 (Proxy)

解决的问题：电商系统中支付的处理可能涉及到外部系统，需要增加代理来进行控制和优化，比如检查支付安全性。
解决方法：代理模式通过一个中间层处理支付请求，检查权限、安全性等，控制访问。

class PaymentProxy:def __init__(self, payment_processor):self.payment_processor = payment_processordef process_payment(self, amount):if self.check_fraud(amount):self.payment_processor.process_payment(amount)else:print("Payment blocked due to fraud")def check_fraud(self, amount):return amount < 10000  # Fraud check# 使用代理模式
payment_proxy = PaymentProxy(PaymentProcessor())
payment_proxy.process_payment(5000)

注释：

PaymentProxy在实际支付之前进行处理，比如进行欺诈检查。

3️⃣ 行为型设计模式 (Behavioral Patterns)

13. 责任链模式 (Chain of Responsibility)

解决的问题：订单的审批过程可能涉及多个环节（例如库存检查、支付验证、配送确认等），每个环节依赖前一个环节的结果。
解决方法：通过责任链模式，将每个处理环节组成链条，处理一个环节后自动传递给下一个环节。

class PaymentHandler:def __init__(self, successor=None):self.successor = successordef handle(self, amount):if self.successor:self.successor.handle(amount)class FraudHandler(PaymentHandler):def handle(self, amount):if amount > 10000:print("Fraud detected")else:super().handle(amount)class PaymentProcessorHandler(PaymentHandler):def handle(self, amount):print(f"Payment of {amount} processed")# 使用责任链模式
handler = FraudHandler(PaymentProcessorHandler())
handler.handle(15000)

注释：

FraudHandler和PaymentProcessorHandler通过责任链模式处理支付请求。

14. 命令模式 (Command)

解决的问题：电商系统可能需要将不同的业务操作（如支付、取消订单）封装成对象，便于回滚、重试等。
解决方法：命令模式将每个操作封装成对象，并可以对这些对象进行排队、执行、撤销等操作。

class Command:def execute(self):passclass PaymentCommand(Command):def __init__(self, payment_processor, amount):self.payment_processor = payment_processorself.amount = amountdef execute(self):self.payment_processor.process_payment(self.amount)# 使用命令模式
command = PaymentCommand(PaymentProcessor(), 500)
command.execute()

注释：

PaymentCommand封装了支付请求，允许在后续执行或撤销。

15. 解释器模式 (Interpreter)

解决的问题：电商系统可能需要处理复杂的优惠规则表达式（例如满减、折扣等）。
解决方法：使用解释器模式解析和执行这些规则表达式，将其转换为具体的操作。

class Expression:def interpret(self, context):passclass AmountExpression(Expression):def __init__(self, amount):self.amount = amountdef interpret(self, context):return context.get(self.amount)# 使用解释器模式
context = {"amount": 500}
expression = AmountExpression("amount")
print(expression.interpret(context))

注释：

AmountExpression根据上下文解释并执行表达式。

16. 迭代器模式 (Iterator)

解决的问题：需要在订单、购物车等集合对象中遍历商品。
解决方法：通过迭代器模式，提供统一的接口来遍历集合中的商品，简化遍历操作。

class Cart:def __init__(self):self.items = []def add_item(self, item):self.items.append(item)def __iter__(self):return iter(self.items)# 使用迭代器模式
cart = Cart()
cart.add_item("Laptop")
cart.add_item("Phone")
for item in cart:print(item)

注释：

Cart实现了迭代器模式，允许遍历购物车中的所有商品。

17. 中介者模式 (Mediator)

解决的问题：多个系统组件（如订单管理、库存管理、支付系统）需要协调工作，但每个系统不应该直接依赖其他系统。
解决方法：使用中介者模式，集中管理不同系统组件之间的通信和协调，避免紧耦合。

class Mediator:def process_payment(self, amount):passclass PaymentMediator(Mediator):def __init__(self, order, payment_processor):self.order = orderself.payment_processor = payment_processordef process_payment(self, amount):if self.order.is_valid():self.payment_processor.process_payment(amount)# 使用中介者模式
order = Order()
payment_processor = PaymentProcessor()
mediator = PaymentMediator(order, payment_processor)
mediator.process_payment(200)

注释：

PaymentMediator协调订单和支付之间的交互。

18. 备忘录模式 (Memento)

解决的问题：在处理订单时，需要记录订单的状态，以便进行回滚或恢复到某个历史状态（如订单变更前后的状态）。
解决方法：使用备忘录模式保存对象的状态，允许在需要时恢复到之前的状态。

class Memento:def __init__(self, state):self.state = stateclass Originator:def __init__(self):self.state = ""def set_state(self, state):self.state = statedef save_state_to_memento(self):return Memento(self.state)def restore_state_from_memento(self, memento):self.state = memento.state# 使用备忘录模式
originator = Originator()
originator.set_state("Order created")
memento = originator.save_state_to_memento()
originator.set_state("Order paid")
originator.restore_state_from_memento(memento)

注释：

Originator保存对象的状态，并能够恢复先前的状态。

19. 观察者模式 (Observer)

解决的问题：订单状态发生变化时（例如，订单支付、发货等），需要通知相关的系统组件（如客户、库存系统等）。
解决方法：通过观察者模式，当订单状态变化时，自动通知所有的观察者（如客户、仓库等）。

class Observer:def update(self, state):passclass OrderObserver(Observer):def update(self, state):print(f"Order state updated: {state}")class Order:def __init__(self):self.state = "Pending"self.observers = []def add_observer(self, observer):self.observers.append(observer)def set_state(self, state):self.state = stateself.notify()def notify(self):for observer in self.observers:observer.update(self.state)# 使用观察者模式
order = Order()
observer = OrderObserver()
order.add_observer(observer)
order.set_state("Paid")

注释：

Order对象通知所有观察者当状态变化时进行更新。

20. 状态模式 (State)

解决的问题：订单在生命周期中有多个状态（如待支付、已支付、已发货等），需要根据状态做不同的操作。
解决方法：使用状态模式，管理订单的不同状态，每个状态对应不同的行为。

class OrderState:def handle(self, order):passclass PendingState(OrderState):def handle(self, order):print("Order is pending")class PaidState(OrderState):def handle(self, order):print("Order is paid")class Order:def __init__(self):self.state = PendingState()def set_state(self, state: OrderState):self.state = statedef process(self):self.state.handle(self)# 使用状态模式
order = Order()
order.process()  # Output: Order is pending
order.set_state(PaidState())
order.process()  # Output: Order is paid

注释：

Order类的状态变化决定了其行为。

21. 策略模式 (Strategy)

解决的问题：电商系统中有不同的支付方式（如信用卡、支付宝、微信支付），可以选择不同的支付策略来进行支付。
解决方法：使用策略模式，封装不同的支付方式，客户可以根据需要选择不同的支付策略。

class PaymentStrategy:def pay(self, amount):passclass CreditCardStrategy(PaymentStrategy):def pay(self, amount):print(f"Paid {amount} with credit card")class PayPalStrategy(PaymentStrategy):def pay(self, amount):print(f"Paid {amount} with PayPal")class Order:def __init__(self, strategy: PaymentStrategy):self.strategy = strategydef process_payment(self, amount):self.strategy.pay(amount)# 使用策略模式
order = Order(CreditCardStrategy())
order.process_payment(100)

注释：

PaymentStrategy定义了支付的不同策略，Order根据不同策略选择支付方式。

22. 模板方法模式 (Template Method)

解决的问题：订单的处理流程大致相同，但在不同子类中可能有些许差异（如不同的验证方式、支付方式等）。
解决方法：使用模板方法模式，定义一个固定的处理流程，具体步骤由子类实现。

class OrderProcessor:def process_order(self, order):self.verify_order(order)self.process_payment(order)self.ship_order(order)def verify_order(self, order):passdef process_payment(self, order):passdef ship_order(self, order):passclass OnlineOrderProcessor(OrderProcessor):def verify_order(self, order):print("Verifying online order")def process_payment(self, order):print("Processing online payment")def ship_order(self, order):print("Shipping online order")# 使用模板方法模式
processor = OnlineOrderProcessor()
processor.process_order("Order1")

注释：

OrderProcessor定义了一个处理订单的框架，具体步骤由子类实现。

23. 访问者模式 (Visitor)

解决的问题：电商系统中有多个不同类型的商品，而每种商品可能有不同的行为（例如折扣、税费计算等）。
解决方法：使用访问者模式，允许在不改变商品类结构的情况下，新增商品行为（如计算税费、折扣等）。

class Cart:def __init__(self):self.items = []def add_item(self, item):self.items.append(item)def accept(self, visitor):for item in self.items:visitor.visit(item)class CartVisitor:def visit(self, item):passclass TaxVisitor(CartVisitor):def visit(self, item):print(f"Calculating tax for {item}")# 使用访问者模式
cart = Cart()
cart.add_item("Laptop")
cart.accept(TaxVisitor())