023-模型工厂与构建器模式

023-模型工厂与构建器模式

📚 本章概述

模型工厂与构建器模式是面向对象设计中的重要模式，在Pydantic中应用这些模式可以帮助我们更优雅地创建和管理复杂的数据模型。本章将深入探讨如何在Pydantic中实现和应用这些设计模式。

🎯 学习目标

• 理解工厂模式和构建器模式的概念
• 掌握在Pydantic中实现模型工厂
• 学会使用构建器模式创建复杂模型
• 了解模式的实际应用场景和最佳实践

🏭 工厂模式实现

1.1 简单工厂模式

from pydantic import BaseModel, Field, validator
from typing import Dict, Any, Type, Optional, Union, List
from enum import Enum
from abc import ABC, abstractmethod
from datetime import datetime

class UserType(str, Enum):
    """用户类型枚举"""
    ADMIN = "admin"
    REGULAR = "regular"
    GUEST = "guest"
    VIP = "vip"

class BaseUser(BaseModel):
    """用户基类"""
    id: int = Field(..., gt=0, description="用户ID")
    username: str = Field(..., min_length=3, max_length=50, description="用户名")
    email: str = Field(..., description="邮箱地址")
    created_at: datetime = Field(default_factory=datetime.now, description="创建时间")
    is_active: bool = Field(True, description="是否激活")
    
    @validator('email')
    def validate_email(cls, v):
        import re
        if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', v):
            raise ValueError('无效的邮箱格式')
        return v.lower()

class AdminUser(BaseUser):
    """管理员用户"""
    user_type: UserType = Field(UserType.ADMIN, description="用户类型")
    permissions: List[str] = Field(default_factory=list, description="权限列表")
    department: str = Field(..., description="部门")
    access_level: int = Field(10, ge=1, le=10, description="访问级别")
    
    def __init__(self, **data):
        super().__init__(**data)
        if not self.permissions:
            self.permissions = [
                "read_all", "write_all", "delete_all", 
                "manage_users", "system_config"
            ]

class RegularUser(BaseUser):
    """普通用户"""
    user_type: UserType = Field(UserType.REGULAR, description="用户类型")
    profile: Dict[str, Any] = Field(default_factory=dict, description="用户资料")
    subscription_plan: str = Field("basic", description="订阅计划")
    
    def __init__(self, **data):
        super().__init__(**data)
        if not self.profile:
            self.profile = {
   
   
                "bio": "",
                "avatar": "",
                "preferences": {
   
   }
            }

class GuestUser(BaseUser):
    """访客用户"""
    user_type: UserType = Field(UserType.GUEST, description="用户类型")
    session_id: str = Field(..., description="会话ID")
    expires_at: datetime = Field(..., description="过期时间")
    limited_access: bool = Field(True, description="受限访问")

class VIPUser(BaseUser):
    """VIP用户"""
    user_type: UserType = Field(UserType.VIP, description="用户类型")
    vip_level: int = Field(1, ge=1, le=5, description="VIP等级")
    benefits: List[str] = Field(default_factory=list, description="VIP权益")
    personal_manager: Optional[str] = Field(None, description="专属客服")
    
    def __init__(self, **data):
        super().__init__(**data)
        if not self.benefits:
            self.benefits = [
                "priority_support", "exclusive_content", 
                "advanced_features", "no_ads"
            ]

class UserFactory:
    """用户工厂类"""
    
    _user_classes: Dict[UserType, Type[BaseUser]] = {
   
   
        UserType.ADMIN: AdminUser,
        UserType.REGULAR: RegularUser,
        UserType.GUEST: GuestUser,
        UserType.VIP: VIPUser,
    }
    
    @classmethod
    def create_user(cls, user_type: UserType, **kwargs) -> BaseUser:
        """创建用户实例"""
        user_class = cls._user_classes.get(user_type)
        if not user_class:
            raise ValueError(f"不支持的用户类型: {
     
     user_type}")
        
        return user_class(**kwargs)
    
    @classmethod
    def register_user_type(cls, user_type: UserType, user_class: Type[BaseUser]):
        """注册新的用户类型"""
        cls._user_classes[user_type] = user_class
    
    @classmethod
    def get_supported_types(cls) -> List[UserType]:
        """获取支持的用户类型"""
        return list(cls._user_classes.keys())
    
    @classmethod
    def create_from_dict(cls, data: Dict[str, Any]) -> BaseUser:
        """从字典创建用户"""
        user_type = data.get('user_type')
        if not user_type:
            raise ValueError("缺少用户类型信息")
        
        if isinstance(user_type, str):
            user_type = UserType(user_type)
        
        return cls.create_user(user_type, **data)

# 使用简单工厂模式
print("=== 简单工厂模式测试 ===")

# 创建不同类型的用户
admin = UserFactory.create_user(
    UserType.ADMIN,
    id=1,
    username="admin",
    email="admin@example.com",
    department="IT"
)

regular = UserFactory.create_user(
    UserType.REGULAR,
    id=2,
    username="alice",
    email="alice@example.com"
)

guest = UserFactory.create_user(
    UserType.GUEST,
    id=3,
    username="guest_123",
    email="guest@example.com",
    session_id="sess_abc123",
    expires_at=datetime.now()
)

vip = UserFactory.create_user(
    UserType.VIP,
    id=4,
    username="vip_user",
    email="vip@example.com",
    vip_level=3,
    personal_manager="John Doe"
)

print(f"管理员用户: {
     
     admin}")
print(f"普通用户: {
     
     regular}")
print(f"访客用户: {
     
     guest}")
print(f"VIP用户: {
     
     vip}")

# 从字典创建用户
user_data = {
   
   
    "user_type": "admin",
    "id": 5,
    "username": "super_admin",
    "email": "super@example.com",
    "department": "Management"
}

created_user = UserFactory.create_from_dict(user_data)
print(f"从字典创建的用户: {
     
     created_user}")

1.2 抽象工厂模式

from pydantic import BaseModel, Field
from typing import Dict, Any, Type, Protocol, runtime_checkable
from abc import ABC, abstractmethod
from enum import Enum

class DatabaseType(str, Enum):
    """数据库类型"""
    MYSQL = "mysql"
    POSTGRESQL = "postgresql"
    MONGODB = "mongodb"
    REDIS = "redis"

class EnvironmentType(str, Enum):
    """环境类型"""
    DEVELOPMENT = "development"
    TESTING = "testing"
    PRODUCTION = "production"

# 数据库配置模型
class DatabaseConfig(BaseModel):
    """数据库配置基类"""
    host: str = Field(..., description="主机地址")
    port: int = Field(..., gt=0, le=65535, description="端口号")
    database: str = Field(..., description="数据库名")
    
class MySQLConfig(DatabaseConfig):
    """MySQL配置"""
    username: str = Field(..., description="用户名")
    password: str = Field(..., description="密码")
    charset: str = Field("utf8mb4", description="字符集")
    engine: str = Field("InnoDB", description="存储引擎")
    
class PostgreSQLConfig(DatabaseConfig):
    """PostgreSQL配置"""
    username: str = Field(..., description="用户名")
    password: str = Field(..., description="密码")
    schema: str = Field("public", description="模式")
    ssl_mode: str = Field("prefer", description="SSL模式")

class MongoDBConfig(DatabaseConfig):
    """MongoDB配置"""
    username: Optional[str] = Field(None, description="用户名")
    password: Optional[str] = Field(None, description="密码")
    auth_source: str = Field("admin", description="认证数据库")
    replica_set: Optional[str] = Field(None, description="副本集")

class RedisConfig(DatabaseConfig):
    """Redis配置"""
    password: Optional[str] = Field(None, description="密码")
    db: int = Field(0, ge=0, le=15, description="数据库编号")
    max_connections: int = Field(10, gt