# 反例：一个类做太多事
class UserManager:
    def create_user(self, name, email): ...
    def delete_user(self, user_id): ...
    def send_email(self, user_id, message): ...   # 不该在这里！
    def generate_report(self): ...                 # 不该在这里！

# 正例：拆分职责
class UserService:
    def create_user(self, name, email): ...
    def delete_user(self, user_id): ...

class EmailService:
    def send(self, to, message): ...

class ReportService:
    def generate(self): ...

# 反例：修改现有代码来添加新功能
class AreaCalculator:
    def calculate(self, shape):
        if isinstance(shape, Rectangle):
            return shape.width * shape.height
        elif isinstance(shape, Circle):    # 新增形状要改这里！
            return 3.14 * shape.radius ** 2

# 正例：扩展而不是修改
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return 3.14159 * self.radius ** 2

# 新增三角形，不需要修改 AreaCalculator
class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height
    def area(self):
        return 0.5 * self.base * self.height

class AreaCalculator:
    def calculate(self, shape: Shape):
        return shape.area()

# 反例：子类破坏了父类的契约
class Bird:
    def fly(self):
        print("Flying")

class Penguin(Bird):   # 企鹅是鸟，但不能飞！
    def fly(self):
        raise Exception("Penguins can't fly")

# 正例：重新设计继承体系
class Bird:
    pass

class FlyingBird(Bird):
    def fly(self): ...

class Penguin(Bird):   # 企鹅是鸟，但不是 FlyingBird
    def swim(self): ...

# 反例：胖接口
class Machine:
    def print(self): ...
    def scan(self): ...
    def fax(self): ...

class OldPrinter(Machine):   # 老打印机不支持扫描和传真
    def scan(self):
        raise NotImplementedError   # 被迫实现不需要的方法
    def fax(self):
        raise NotImplementedError

# 正例：拆分为小接口
class Printer:
    def print(self): ...

class Scanner:
    def scan(self): ...

class Fax:
    def fax(self): ...

class OldPrinter(Printer):
    def print(self): ...

class MultiFunctionDevice(Printer, Scanner, Fax):
    ...

# 反例：高层模块依赖低层模块
class MySQLDatabase:
    def query(self, sql): ...

class UserRepository:
    def __init__(self):
        self.db = MySQLDatabase()   # 直接依赖具体实现

# 正例：依赖抽象
from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def query(self, sql): ...

class UserRepository:
    def __init__(self, db: Database):   # 依赖接口
        self.db = db

# 现在可以随意切换数据库
class MySQLDatabase(Database): ...
class PostgreSQLDatabase(Database): ...
class MongoDB(Database): ...

repo = UserRepository(PostgreSQLDatabase())

from abc import ABC, abstractmethod

# 产品接口
class Notification(ABC):
    @abstractmethod
    def send(self, message: str): ...

class EmailNotification(Notification):
    def send(self, message):
        print(f"Email: {message}")

class SMSNotification(Notification):
    def send(self, message):
        print(f"SMS: {message}")

class PushNotification(Notification):
    def send(self, message):
        print(f"Push: {message}")

# 简单工厂
class NotificationFactory:
    @staticmethod
    def create(type_: str) -> Notification:
        notifications = {
            "email": EmailNotification,
            "sms": SMSNotification,
            "push": PushNotification,
        }
        if type_ not in notifications:
            raise ValueError(f"Unknown type: {type_}")
        return notifications[type_]()

# 使用
notifier = NotificationFactory.create("email")
notifier.send("Hello!")

class HttpRequest:
    """HTTP 请求对象。"""
    def __init__(self):
        self.method = "GET"
        self.url = ""
        self.headers = {}
        self.body = None

    def __repr__(self):
        return f"HttpRequest({self.method} {self.url})"

class HttpRequestBuilder:
    """建造者：分步骤构建复杂对象。"""
    def __init__(self):
        self._request = HttpRequest()

    def set_method(self, method: str):
        self._request.method = method
        return self

    def set_url(self, url: str):
        self._request.url = url
        return self

    def add_header(self, key: str, value: str):
        self._request.headers[key] = value
        return self

    def set_body(self, body: str):
        self._request.body = body
        return self

    def build(self) -> HttpRequest:
        return self._request

# 使用（链式调用）
request = (
    HttpRequestBuilder()
    .set_method("POST")
    .set_url("https://api.example.com/users")
    .add_header("Content-Type", "application/json")
    .add_header("Authorization", "Bearer token123")
    .set_body('{"name": "Alice"}')
    .build()
)

import threading

class SingletonMeta(type):
    """线程安全单例元类。"""
    _instances = {}
    _lock = threading.Lock()

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            with cls._lock:
                if cls not in cls._instances:
                    cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=SingletonMeta):
    def __init__(self, host="localhost"):
        self.host = host

# 使用
db1 = Database()
db2 = Database()
print(db1 is db2)   # True（同一个实例）

import copy

class Prototype(ABC):
    @abstractmethod
    def clone(self): ...

class ConcretePrototype(Prototype):
    def __init__(self, value):
        self.value = value

    def clone(self):
        return copy.deepcopy(self)

# 使用
original = ConcretePrototype(42)
clone = original.clone()

print(original.value)   # 42
print(clone.value)      # 42
print(original is clone)   # False（不同对象，但值相同）

from abc import ABC, abstractmethod

# 抽象产品族
class Button(ABC):
    @abstractmethod
    def render(self): ...

class Checkbox(ABC):
    @abstractmethod
    def render(self): ...

# 具体产品：Windows 风格
class WindowsButton(Button):
    def render(self):
        print("Windows Button")

class WindowsCheckbox(Checkbox):
    def render(self):
        print("Windows Checkbox")

# 具体产品：Mac 风格
class MacButton(Button):
    def render(self):
        print("Mac Button")

class MacCheckbox(Checkbox):
    def render(self):
        print("Mac Checkbox")

# 抽象工厂
class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button: ...
    @abstractmethod
    def create_checkbox(self) -> Checkbox: ...

# 具体工厂
class WindowsFactory(GUIFactory):
    def create_button(self):
        return WindowsButton()
    def create_checkbox(self):
        return WindowsCheckbox()

class MacFactory(GUIFactory):
    def create_button(self):
        return MacButton()
    def create_checkbox(self):
        return MacCheckbox()

# 使用
factory = WindowsFactory()
button = factory.create_button()
checkbox = factory.create_checkbox()
button.render()      # Windows Button
checkbox.render()    # Windows Checkbox

from abc import ABC, abstractmethod

# 旧系统接口
class OldPaymentGateway:
    def make_payment(self, amount):
        print(f"Old gateway: processing ${amount}")

# 新系统接口
class PaymentProcessor(ABC):
    @abstractmethod
    def process(self, amount: float, currency: str): ...

# 适配器
class PaymentAdapter(PaymentProcessor):
    def __init__(self, old_gateway: OldPaymentGateway):
        self._old = old_gateway

    def process(self, amount: float, currency: str):
        if currency != "USD":
            amount = self._convert_currency(amount, currency, "USD")
        self._old.make_payment(amount)

    def _convert_currency(self, amount, from_c, to_c):
        ...

# 使用
old = OldPaymentGateway()
adapter = PaymentAdapter(old)
adapter.process(100, "EUR")   # 新接口调用旧实现

class Coffee:
    """基础组件。"""
    def cost(self):
        return 5
    def description(self):
        return "Coffee"

class CoffeeDecorator:
    """装饰器基类。"""
    def __init__(self, coffee: Coffee):
        self._coffee = coffee

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

    def description(self):
        return self._coffee.description()

class Milk(CoffeeDecorator):
    def cost(self):
        return self._coffee.cost() + 1
    def description(self):
        return self._coffee.description() + ", Milk"

class Sugar(CoffeeDecorator):
    def cost(self):
        return self._coffee.cost() + 0.5
    def description(self):
        return self._coffee.description() + ", Sugar"

# 使用
coffee = Coffee()
coffee = Milk(coffee)
coffee = Sugar(coffee)
print(f"{coffee.description()}: ${coffee.cost()}")
# Coffee, Milk, Sugar: $6.5

class Image:
    """真实对象。"""
    def __init__(self, filename):
        self.filename = filename
        self._load()

    def _load(self):
        print(f"Loading heavy image: {self.filename}")

    def display(self):
        print(f"Displaying: {self.filename}")

class ImageProxy:
    """代理：延迟加载。"""
    def __init__(self, filename):
        self.filename = filename
        self._image = None

    def display(self):
        if self._image is None:
            self._image = Image(self.filename)
        self._image.display()

# 使用
images = [ImageProxy(f"image{i}.jpg") for i in range(10)]
# 此时没有加载任何图片
images[0].display()   # 第一次访问时才加载
images[0].display()   # 第二次直接显示（已缓存）

from abc import ABC, abstractmethod
from typing import List

class Component(ABC):
    @abstractmethod
    def display(self, depth=0): ...

class Leaf(Component):
    def __init__(self, name):
        self.name = name

    def display(self, depth=0):
        print("  " * depth + f"- {self.name}")

class Composite(Component):
    def __init__(self, name):
        self.name = name
        self._children: List[Component] = []

    def add(self, child: Component):
        self._children.append(child)

    def remove(self, child: Component):
        self._children.remove(child)

    def display(self, depth=0):
        print("  " * depth + f"+ {self.name}")
        for child in self._children:
            child.display(depth + 1)

# 使用
root = Composite("root")
root.add(Leaf("leaf1"))
root.add(Leaf("leaf2"))

branch = Composite("branch")
branch.add(Leaf("leaf3"))
branch.add(Leaf("leaf4"))
root.add(branch)

root.display()
# + root
#   - leaf1
#   - leaf2
#   + branch
#     - leaf3
#     - leaf4

class Flyweight:
    def __init__(self, intrinsic_state):
        self.intrinsic_state = intrinsic_state

    def operation(self, extrinsic_state):
        print(f"Flyweight: {self.intrinsic_state}, {extrinsic_state}")

class FlyweightFactory:
    def __init__(self):
        self._flyweights = {}

    def get_flyweight(self, key):
        if key not in self._flyweights:
            self._flyweights[key] = Flyweight(key)
        return self._flyweights[key]

# 使用
factory = FlyweightFactory()

# 获取享元对象
f1 = factory.get_flyweight("key1")
f2 = factory.get_flyweight("key1")
f3 = factory.get_flyweight("key2")

print(f1 is f2)   # True（同一个对象）
print(f1 is f3)   # False（不同对象）

f1.operation("state1")
f2.operation("state2")

class CPU:
    def boot(self):
        print("CPU booting")

class Memory:
    def load(self):
        print("Memory loading")

class HardDrive:
    def read(self):
        print("HardDrive reading")

class Computer:
    """门面：简化复杂子系统的访问。"""
    def __init__(self):
        self.cpu = CPU()
        self.memory = Memory()
        self.hard_drive = HardDrive()

    def start(self):
        self.cpu.boot()
        self.memory.load()
        self.hard_drive.read()
        print("Computer started!")

# 使用
computer = Computer()
computer.start()   # 一个调用完成所有启动流程

from typing import List

class Observer:
    def update(self, event: str, data: dict):
        raise NotImplementedError

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

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

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

    def notify(self, event: str, data: dict):
        for observer in self._observers:
            observer.update(event, data)

class EmailNotifier(Observer):
    def update(self, event, data):
        if event == "user_registered":
            print(f"Sending welcome email to {data['email']}")

class AnalyticsTracker(Observer):
    def update(self, event, data):
        print(f"Tracking event: {event}")

class AuditLogger(Observer):
    def update(self, event, data):
        print(f"Audit: {event} at {data.get('timestamp')}")

# 使用
subject = Subject()
subject.attach(EmailNotifier())
subject.attach(AnalyticsTracker())
subject.attach(AuditLogger())

subject.notify("user_registered", {"email": "alice@example.com", "timestamp": "2024-01-01"})

from typing import Callable

# Python 中策略模式可以用函数更简洁地实现
DiscountStrategy = Callable[[float], float]

def no_discount(price: float) -> float:
    return price

def percentage_discount(percent: float) -> DiscountStrategy:
    def apply(price: float) -> float:
        return price * (1 - percent / 100)
    return apply

def fixed_discount(amount: float) -> DiscountStrategy:
    def apply(price: float) -> float:
        return max(0, price - amount)
    return apply

class Order:
    def __init__(self, price: float, strategy: DiscountStrategy = no_discount):
        self.price = price
        self.strategy = strategy

    def final_price(self) -> float:
        return self.strategy(self.price)

# 使用
order1 = Order(100, percentage_discount(20))
order2 = Order(100, fixed_discount(30))
print(order1.final_price())   # 80.0
print(order2.final_price())   # 70.0

from abc import ABC, abstractmethod

class DataImporter(ABC):
    """模板：定义导入流程的骨架。"""

    def import_data(self, filepath):
        """模板方法，定义算法骨架。"""
        raw = self._read_file(filepath)
        parsed = self._parse(raw)
        validated = self._validate(parsed)
        self._save(validated)
        self._post_process()

    def _read_file(self, filepath):
        with open(filepath, "r") as f:
            return f.read()

    @abstractmethod
    def _parse(self, raw_data):
        """子类必须实现。"""
        pass

    def _validate(self, data):
        """钩子：默认实现，子类可覆盖。"""
        return data

    def _save(self, data):
        print(f"Saving {len(data)} records")

    def _post_process(self):
        """钩子：可选覆盖。"""
        pass

class CSVImporter(DataImporter):
    def _parse(self, raw_data):
        import csv
        return list(csv.reader(raw_data.splitlines()))

class JSONImporter(DataImporter):
    def _parse(self, raw_data):
        import json
        return json.loads(raw_data)

# 使用
CSVImporter().import_data("data.csv")
JSONImporter().import_data("data.json")

from typing import Optional
from abc import ABC, abstractmethod

class Handler(ABC):
    def __init__(self):
        self._next: Optional[Handler] = None

    def set_next(self, handler: "Handler") -> "Handler":
        self._next = handler
        return handler

    def handle(self, request):
        if self._next:
            return self._next.handle(request)
        return None

class AuthHandler(Handler):
    def handle(self, request):
        if not request.get("token"):
            return "Unauthorized"
        print("Auth passed")
        return super().handle(request)

class RateLimitHandler(Handler):
    def __init__(self):
        super().__init__()
        self.requests = 0

    def handle(self, request):
        self.requests += 1
        if self.requests > 100:
            return "Rate limit exceeded"
        print("Rate limit ok")
        return super().handle(request)

class ValidationHandler(Handler):
    def handle(self, request):
        if not request.get("data"):
            return "Invalid data"
        print("Validation passed")
        return super().handle(request)

# 组装责任链
auth = AuthHandler()
rate = RateLimitHandler()
validate = ValidationHandler()

auth.set_next(rate).set_next(validate)

# 使用
result = auth.handle({"token": "abc", "data": {"name": "Alice"}})
print(result)   # None（所有处理通过）

from typing import Protocol

class Database(Protocol):
    def get_user(self, user_id: int) -> dict: ...
    def save_user(self, user: dict) -> None: ...

class UserService:
    """依赖注入：通过构造函数传入依赖。"""
    def __init__(self, db: Database, notifier):
        self.db = db
        self.notifier = notifier

    def register_user(self, name: str, email: str):
        user = {"name": name, "email": email}
        self.db.save_user(user)
        self.notifier.send(email, "Welcome!")
        return user

# 使用
from unittest.mock import Mock

# 测试时注入 Mock
mock_db = Mock()
mock_db.get_user.return_value = {"name": "Alice"}
mock_notifier = Mock()

service = UserService(mock_db, mock_notifier)
user = service.register_user("Bob", "bob@example.com")

mock_db.save_user.assert_called_once()
mock_notifier.send.assert_called_once_with("bob@example.com", "Welcome!")

from abc import ABC, abstractmethod
from typing import List, Optional

class User:
    def __init__(self, id: int, name: str, email: str):
        self.id = id
        self.name = name
        self.email = email

class UserRepository(ABC):
    """抽象仓储：定义数据访问接口。"""
    @abstractmethod
    def get_by_id(self, user_id: int) -> Optional[User]: ...

    @abstractmethod
    def get_all(self) -> List[User]: ...

    @abstractmethod
    def save(self, user: User) -> None: ...

    @abstractmethod
    def delete(self, user_id: int) -> None: ...

class InMemoryUserRepository(UserRepository):
    """内存实现：用于测试。"""
    def __init__(self):
        self._users = {}
        self._counter = 0

    def get_by_id(self, user_id: int):
        return self._users.get(user_id)

    def get_all(self):
        return list(self._users.values())

    def save(self, user: User):
        if user.id == 0:
            self._counter += 1
            user.id = self._counter
        self._users[user.id] = user

    def delete(self, user_id: int):
        self._users.pop(user_id, None)

class SQLUserRepository(UserRepository):
    """SQL 实现：用于生产。"""
    def __init__(self, session):
        self.session = session

    def get_by_id(self, user_id: int):
        row = self.session.execute("SELECT * FROM users WHERE id = ?", (user_id,)).fetchone()
        return User(*row) if row else None

# 使用
# 测试用内存版本
repo = InMemoryUserRepository()
service = UserService(repo)

# 生产用 SQL 版本
# repo = SQLUserRepository(db_session)
# service = UserService(repo)

class UnitOfWork:
    """管理事务边界，确保一组操作要么全成功，要么全回滚。"""
    def __init__(self, session):
        self.session = session
        self.new_objects = []
        self.dirty_objects = []
        self.removed_objects = []

    def register_new(self, obj):
        self.new_objects.append(obj)

    def register_dirty(self, obj):
        self.dirty_objects.append(obj)

    def register_removed(self, obj):
        self.removed_objects.append(obj)

    def commit(self):
        try:
            for obj in self.new_objects:
                self.session.insert(obj)
            for obj in self.dirty_objects:
                self.session.update(obj)
            for obj in self.removed_objects:
                self.session.delete(obj)
            self.session.commit()
        except Exception:
            self.session.rollback()
            raise
        finally:
            self.new_objects.clear()
            self.dirty_objects.clear()
            self.removed_objects.clear()

# 使用
with UnitOfWork(session) as uow:
    user = User(name="Alice", email="alice@example.com")
    uow.register_new(user)
    uow.commit()   # 统一提交

# 单体 vs 微服务的决策树

"""
是否应该拆分为微服务？

1. 团队规模 > 10 人？
   否 → 单体足够
   是 → 继续

2. 不同模块的发布节奏差异大？
   否 → 单体 + 模块化
   是 → 继续

3. 有独立扩展需求？（如订单服务压力远大于用户服务）
   否 → 单体 + 模块化
   是 → 考虑微服务

4. 团队具备 DevOps 能力？
   否 → 先提升运维能力
   是 → 可以拆分

微服务拆分粒度：
- 按业务能力（用户服务、订单服务、支付服务）
- 按数据所有权（每个服务独占数据库）
- 避免过细（纳米服务反模式）
"""

from typing import List, Optional
from abc import ABC, abstractmethod

class Command(ABC):
    """命令接口。"""
    @abstractmethod
    def execute(self): ...

    @abstractmethod
    def undo(self): ...

class TextEditor:
    """接收者（Receiver）。"""
    def __init__(self):
        self.text = ""

    def insert(self, text, pos=None):
        if pos is None:
            self.text += text
        else:
            self.text = self.text[:pos] + text + self.text[pos:]

    def delete(self, start, end):
        self.text = self.text[:start] + self.text[end:]

class InsertCommand(Command):
    def __init__(self, editor, text, pos=None):
        self.editor = editor
        self.text = text
        self.pos = pos

    def execute(self):
        self.editor.insert(self.text, self.pos)

    def undo(self):
        if self.pos is None:
            start = len(self.editor.text) - len(self.text)
        else:
            start = self.pos
        self.editor.delete(start, start + len(self.text))

class CommandHistory:
    """保存命令历史，支持撤销。"""
    def __init__(self):
        self._history: List[Command] = []
        self._position = -1

    def execute(self, cmd: Command):
        cmd.execute()
        self._history = self._history[:self._position + 1]
        self._history.append(cmd)
        self._position += 1

    def undo(self):
        if self._position >= 0:
            cmd = self._history[self._position]
            cmd.undo()
            self._position -= 1

    def redo(self):
        if self._position + 1 < len(self._history):
            self._position += 1
            self._history[self._position].execute()

# 使用
editor = TextEditor()
history = CommandHistory()
history.execute(InsertCommand(editor, "Hello"))
history.execute(InsertCommand(editor, " World"))
print(editor.text)   # Hello World
history.undo()
print(editor.text)   # Hello

from abc import ABC, abstractmethod

class OrderState(ABC):
    """订单状态接口。"""
    @abstractmethod
    def pay(self, order): ...
    @abstractmethod
    def ship(self, order): ...
    @abstractmethod
    def cancel(self, order): ...

class PendingState(OrderState):
    def pay(self, order):
        print("订单已支付")
        order.state = PaidState()

    def ship(self, order):
        print("请先支付")

    def cancel(self, order):
        print("订单已取消")
        order.state = CancelledState()

class PaidState(OrderState):
    def pay(self, order):
        print("订单已支付，无需重复支付")

    def ship(self, order):
        print("订单已发货")
        order.state = ShippedState()

    def cancel(self, order):
        print("订单已取消，退款处理中")
        order.state = CancelledState()

class ShippedState(OrderState):
    def pay(self, order):
        print("订单已发货，无需支付")

    def ship(self, order):
        print("订单已发货，请勿重复发货")

    def cancel(self, order):
        print("订单已发货，取消需联系客服")

class CancelledState(OrderState):
    def pay(self, order):
        print("订单已取消，无法支付")

    def ship(self, order):
        print("订单已取消，无法发货")

    def cancel(self, order):
        print("订单已取消，无需重复取消")

class Order:
    def __init__(self):
        self.state = PendingState()

    def pay(self):
        self.state.pay(self)

    def ship(self):
        self.state.ship(self)

    def cancel(self):
        self.state.cancel(self)

# 使用
order = Order()
order.pay()          # 订单已支付
order.ship()         # 订单已发货
order.cancel()       # 订单已发货，取消需联系客服

# 问题：大泥球代码，所有逻辑混在一起
class MegaService:
    def process_order(self, order_data):
        # 验证数据（业务逻辑）
        if not order_data.get("user_id"):
            raise ValueError("Missing user_id")
        
        # 数据库操作（数据层）
        db = MySQLDatabase()
        user = db.query(f"SELECT * FROM users WHERE id = {order_data['user_id']}")
        
        # 发送通知（表现层）
        email_service = EmailService()
        email_service.send(user["email"], "Order received")
        
        # 记录日志（基础设施）
        logger.info(f"Order processed: {order_data}")

# 解决方案：分层重构
# 1. 领域模型层
class Order:
    def __init__(self, user_id, items):
        self.user_id = user_id
        self.items = items
    
    def validate(self):
        if not self.user_id:
            raise ValueError("Missing user_id")
        if not self.items:
            raise ValueError("Empty order")

# 2. 数据访问层（仓储模式）
class OrderRepository:
    def __init__(self, db):
        self.db = db
    
    def save(self, order):
        self.db.execute("INSERT INTO orders ...")

# 3. 业务逻辑层（服务层）
class OrderService:
    def __init__(self, order_repo, user_repo, notifier):
        self.order_repo = order_repo
        self.user_repo = user_repo
        self.notifier = notifier
    
    def process_order(self, order_data):
        order = Order(order_data["user_id"], order_data["items"])
        order.validate()
        
        user = self.user_repo.get_by_id(order.user_id)
        self.order_repo.save(order)
        self.notifier.send(user.email, "Order received")

# 4. 表现层（API 层）
@app.post("/orders")
def create_order(request):
    service = OrderService(order_repo, user_repo, email_notifier)
    service.process_order(request.json())
    return {"status": "success"}