领域驱动设计(DDD)在Python中的应用

最新推荐文章于 2025-03-25 09:29:33 发布

欧先生^_^

最新推荐文章于 2025-03-25 09:29:33 发布

阅读量295

点赞数 2

文章标签： python 开发语言

本文链接：https://blog.youkuaiyun.com/u011091936/article/details/145129225

版权

我来详细解释一下领域驱动设计(DDD)在Python中的应用。

领域驱动设计的核心是将复杂的业务逻辑组织成清晰的领域模型。在Python中实现DDD时,我们可以遵循以下主要概念和实践:

# Domain Layer - 领域层
from dataclasses import dataclass
from datetime import datetime
from typing import List, Optional
from uuid import UUID, uuid4

# Value Objects
@dataclass(frozen=True)
class Address:
    street: str
    city: str
    postal_code: str
    country: str

@dataclass(frozen=True)
class Money:
    amount: float
    currency: str

# Entities
@dataclass
class Order:
    id: UUID
    customer_id: UUID
    shipping_address: Address
    total_amount: Money
    status: str
    order_date: datetime
    order_items: List['OrderItem']
    
    @staticmethod
    def create(customer_id: UUID, address: Address, items: List['OrderItem']) -> 'Order':
        total = sum(item.total_price.amount for item in items)
        return Order(
            id=uuid4(),
            customer_id=customer_id,
            shipping_address=address,
            total_amount=Money(total, 'USD'),
            status='PENDING',
            order_date=datetime.now(),
            order_items=items
        )
    
    def ship(self) -> None:
        if self.status != 'PENDING':
            raise ValueError('Order cannot be shipped')
        self.status = 'SHIPPED'

@dataclass
class OrderItem:
    product_id: UUID
    quantity: int
    unit_price: Money
    
    @property
    def total_price(self) -> Money:
        return Money(self.quantity * self.unit_price.amount, self.unit_price.currency)

# Repository Interface
from abc import ABC, abstractmethod

class OrderRepository(ABC):
    @abstractmethod
    def save(self, order: Order) -> None:
        pass
    
    @abstractmethod
    def find_by_id(self, order_id: UUID) -> Optional[Order]:
        pass

# Infrastructure Layer - 基础设施层
class SQLOrderRepository(OrderRepository):
    def __init__(self, db_session):
        self.session = db_session
    
    def save(self, order: Order) -> None:
        # 实现数据库保存逻辑
        pass
    
    def find_by_id(self, order_id: UUID) -> Optional[Order]:
        # 实现数据库查询逻辑
        pass

# Application Layer - 应用层
class OrderService:
    def __init__(self, order_repository: OrderRepository):
        self.order_repository = order_repository
    
    def create_order(self, customer_id: UUID, address: Address, items: List[OrderItem]) -> Order:
        order = Order.create(customer_id, address, items)
        self.order_repository.save(order)
        return order
    
    def ship_order(self, order_id: UUID) -> None:
        order = self.order_repository.find_by_id(order_id)
        if not order:
            raise ValueError('Order not found')
        order.ship()
        self.order_repository.save(order)

# Example Usage
def example_usage():
    # 创建订单项
    item = OrderItem(
        product_id=uuid4(),
        quantity=2,
        unit_price=Money(100.0, 'USD')
    )
    
    # 创建地址
    address = Address(
        street="123 Main St",
        city="Boston",
        postal_code="02108",
        country="USA"
    )
    
    # 初始化服务
    repository = SQLOrderRepository(db_session=None)  # 需要实际的数据库session
    order_service = OrderService(repository)
    
    # 创建订单
    order = order_service.create_order(
        customer_id=uuid4(),
        address=address,
        items=[item]
    )
    
    # 发货
    order_service.ship_order(order.id)

让我解释一下这个DDD实现的主要部分：

领域层(Domain Layer)：
- 值对象(Value Objects)：如Address和Money，它们是不可变的，用@dataclass(frozen=True)实现
- 实体(Entities)：如Order和OrderItem，包含唯一标识符和业务逻辑
- 领域服务：包含复杂的业务规则
仓储层(Repository Layer)：
- 定义了抽象接口OrderRepository
- 提供了具体实现SQLOrderRepository用于数据持久化
应用层(Application Layer)：
- OrderService封装了用例实现
- 协调领域对象和仓储层
- 处理事务边界