Python应用层服务

# Python 应用层服务 (Application Service)
# 应用服务层，用例即类，DTO 组装，事务管理，事件发布
# 应用服务是系统"用例"入口，协调领域对象完成业务流程。

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Callable
import uuid

# 领域层
@dataclass
class Account:
id: str; owner: str; balance: float = 0.0
def deposit(self, amount: float) -> None:
if amount <= 0:
raise ValueError("存款必须为正")
self.balance += amount
def withdraw(self, amount: float) -> None:
if amount > self.balance:
raise ValueError("余额不足")
self.balance -= amount

# DTO
@dataclass
class OpenAccountRequest:
owner: str; initial_deposit: float = 0.0

@dataclass
class AccountResponse:
id: str; owner: str; balance: float
@classmethod
def from_entity(cls, a: Account) -> "AccountResponse":
return cls(a.id, a.owner, a.balance)

# 仓储
class AccountRepository(ABC):
@abstractmethod
def save(self, a: Account) -> None: ...
@abstractmethod
def by_id(self, aid: str) -> Account | None: ...

class MemoryAccountRepo(AccountRepository):
def __init__(self):
self._store: dict[str, Account] = {}
def save(self, a: Account) -> None:
self._store[a.id] = a
def by_id(self, aid: str) -> Account | None:
return self._store.get(aid)

# 领域事件
@dataclass
class DomainEvent: pass

class AccountOpened(DomainEvent):
def __init__(self, aid: str, owner: str):
self.account_id = aid; self.owner = owner

class EventPublisher:
def __init__(self):
self._handlers: dict[type, list[Callable]] = {}
def register(self, t: type, h: Callable) -> None:
self._handlers.setdefault(t, []).append(h)
def publish(self, e: DomainEvent) -> None:
for h in self._handlers.get(type(e), []):
h(e)

# 用例即类
class OpenAccountUseCase:
def __init__(self, repo: AccountRepository, pub: EventPublisher):
self._repo = repo; self._pub = pub
def execute(self, req: OpenAccountRequest) -> AccountResponse:
a = Account(id=str(uuid.uuid4())[:8], owner=req.owner)
if req.initial_deposit > 0:
a.deposit(req.initial_deposit)
self._repo.save(a)
self._pub.publish(AccountOpened(a.id, a.owner))
return AccountResponse.from_entity(a)

class TransferUseCase:
def __init__(self, repo: AccountRepository, pub: EventPublisher):
self._repo = repo; self._pub = pub
def execute(self, from_id: str, to_id: str, amt: float) -> None:
src = self._repo.by_id(from_id)
dst = self._repo.by_id(to_id)
if not src or not dst:
raise ValueError("账户不存在")
src.withdraw(amt); dst.deposit(amt)
self._repo.save(src); self._repo.save(dst)

if __name__ == "__main__":
repo = MemoryAccountRepo(); pub = EventPublisher()
pub.register(AccountOpened,
lambda e: print(f"[事件] 新账户: {e.account_id}"))
resp = OpenAccountUseCase(repo, pub).execute(
OpenAccountRequest("张三", 1000.0))
print(f"开户: {resp.id}, 余额: {resp.balance}")