springbootAI 1.8.0__py3-none-any.whl

spring/monitoring/prometheus.py

@@ -0,0 +1,199 @@
+"""
+Prometheus监控模块
+提供指标暴露和采集功能
+"""
+from prometheus_client import (
+    CollectorRegistry,
+    Counter,
+    Gauge,
+    Histogram,
+    Summary,
+    generate_latest,
+    CONTENT_TYPE_LATEST,
+)
+from prometheus_client.exposition import start_http_server
+import logging
+import os
+import time
+
+logger = logging.getLogger("Spring.Monitoring.Prometheus")
+
+
+class PrometheusMetrics:
+    """Prometheus指标管理器"""
+    
+    _instance = None
+    _lock = __import__('threading').Lock()
+    
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self, namespace: str = "spring", subsystem: str = "python"):
+        if hasattr(self, '_initialized'):
+            return
+        self.namespace = namespace
+        self.subsystem = subsystem
+        self._registry = CollectorRegistry()
+        self._metric_registry = self._registry
+        if os.getenv('PROMETHEUS_MULTIPROC_DIR'):
+            from prometheus_client import multiprocess
+            multiprocess.MultiProcessCollector(self._registry)
+            # Metrics write their values to multiprocess files and must not also
+            # register live collectors in the exposition registry.
+            self._metric_registry = None
+        self._metrics: dict = {}
+        self._initialized = True
+
+    def configure(self, namespace: str, subsystem: str) -> None:
+        if self._metrics and (namespace != self.namespace or subsystem != self.subsystem):
+            raise RuntimeError("Prometheus namespace/subsystem cannot change after metrics are created")
+        self.namespace = namespace
+        self.subsystem = subsystem
+    
+    def create_counter(self, name: str, documentation: str, labelnames: list = None) -> Counter:
+        """
+        创建计数器指标
+        
+        Args:
+            name: 指标名称
+            documentation: 指标描述
+            labelnames: 标签名称列表
+        
+        Returns:
+            Counter对象
+        """
+        key = f"{self.namespace}_{self.subsystem}_{name}"
+        if key not in self._metrics:
+            self._metrics[key] = Counter(
+                name=name,
+                documentation=documentation,
+                labelnames=labelnames or [],
+                namespace=self.namespace,
+                subsystem=self.subsystem,
+                registry=self._metric_registry,
+            )
+        return self._metrics[key]
+    
+    def create_gauge(self, name: str, documentation: str, labelnames: list = None) -> Gauge:
+        """
+        创建仪表盘指标
+        
+        Args:
+            name: 指标名称
+            documentation: 指标描述
+            labelnames: 标签名称列表
+        
+        Returns:
+            Gauge对象
+        """
+        key = f"{self.namespace}_{self.subsystem}_{name}"
+        if key not in self._metrics:
+            self._metrics[key] = Gauge(
+                name=name,
+                documentation=documentation,
+                labelnames=labelnames or [],
+                namespace=self.namespace,
+                subsystem=self.subsystem,
+                registry=self._metric_registry,
+            )
+        return self._metrics[key]
+    
+    def create_histogram(self, name: str, documentation: str, labelnames: list = None, 
+                         buckets: list = None) -> Histogram:
+        """
+        创建直方图指标
+        
+        Args:
+            name: 指标名称
+            documentation: 指标描述
+            labelnames: 标签名称列表
+            buckets: 桶边界列表
+        
+        Returns:
+            Histogram对象
+        """
+        key = f"{self.namespace}_{self.subsystem}_{name}"
+        if key not in self._metrics:
+            self._metrics[key] = Histogram(
+                name=name,
+                documentation=documentation,
+                labelnames=labelnames or [],
+                buckets=buckets or Histogram.DEFAULT_BUCKETS,
+                namespace=self.namespace,
+                subsystem=self.subsystem,
+                registry=self._metric_registry,
+            )
+        return self._metrics[key]
+    
+    def create_summary(self, name: str, documentation: str, labelnames: list = None,
+                       objectives: dict = None) -> Summary:
+        """
+        创建摘要指标
+        
+        Args:
+            name: 指标名称
+            documentation: 指标描述
+            labelnames: 标签名称列表
+            objectives: 分位数目标
+        
+        Returns:
+            Summary对象
+        """
+        key = f"{self.namespace}_{self.subsystem}_{name}"
+        if key not in self._metrics:
+            self._metrics[key] = Summary(
+                name=name,
+                documentation=documentation,
+                labelnames=labelnames or [],
+                objectives=objectives or Summary.DEFAULT_OBJECTIVES,
+                namespace=self.namespace,
+                subsystem=self.subsystem,
+                registry=self._metric_registry,
+            )
+        return self._metrics[key]
+    
+    def get_metrics(self) -> dict:
+        """获取所有指标"""
+        return self._metrics
+    
+    def get_registry(self) -> CollectorRegistry:
+        """获取指标注册表"""
+        return self._registry
+    
+    def generate_metrics_data(self) -> bytes:
+        """生成Prometheus格式的指标数据"""
+        return generate_latest(self._registry)
+    
+    def start_server(self, port: int = 8000):
+        """
+        启动Prometheus指标暴露HTTP服务器
+        
+        Args:
+            port: 监听端口
+        """
+        start_http_server(port, registry=self._registry)
+        logger.info(f"Prometheus metrics server started on port {port}")
+
+
+# 创建全局Prometheus指标管理器实例
+prometheus_metrics = PrometheusMetrics()
+
+
+def init_prometheus(config: dict) -> None:
+    """
+    初始化Prometheus配置
+    
+    Args:
+        config: 配置字典，包含namespace, subsystem, port等
+    """
+    prometheus_metrics.configure(
+        namespace=config.get('namespace', 'spring'),
+        subsystem=config.get('subsystem', 'python'),
+    )
+    # 默认通过主应用 /actuator/prometheus 暴露，避免多 worker 争抢端口。
+    if config.get('standalone_server', False):
+        prometheus_metrics.start_server(config.get('port', 8000))

spring/orm/__init__.py

@@ -0,0 +1,258 @@
+"""
+Spring ORM模块
+集成PyMyBatis作为核心ORM框架
+提供SQL与代码分离、事务管理、连接池等企业级数据库能力
+
+支持两种数据访问模式：
+1. Mapper模式（推荐）：使用@Mapper注解和SQL注解定义数据访问接口
+2. Repository模式：使用SQLAlchemy的ORM方式进行数据访问
+"""
+
+# 导入SQLAlchemy数据库管理器（可选）
+try:
+    from spring.orm.database import (
+        DatabaseManager,
+        Base,
+        BaseEntity,
+        User,
+        AuditLog,
+        init_database,
+    )
+except ImportError:
+    # SQLAlchemy未安装，这些类不可用
+    DatabaseManager = None
+    Base = None
+    BaseEntity = None
+    User = None
+    AuditLog = None
+    init_database = None
+
+# 从pymybatis导入核心类
+from spring.orm.pymybatis import (
+    Configuration,
+    build_session_factory,
+    SqlSessionFactory,
+    SqlSession,
+)
+
+# 导入Spring与MyBatis集成注解和工具
+from spring.orm.mybatis_integration import (
+    Mapper,
+    MapperScan,
+    MyBatisConfigurer,
+    init_mybatis,
+)
+
+# 导入注解
+from spring.orm.pymybatis.annotations import (
+    Select,
+    Insert,
+    Update,
+    Delete,
+    SelectProvider,
+    InsertProvider,
+    UpdateProvider,
+    DeleteProvider,
+    ResultMap,
+    Result,
+    Options,
+    Param,
+    CacheNamespace,
+    DataSource,
+    Transactional as MapperTransactional,
+)
+
+# 导入安全模块
+from spring.orm.pymybatis.security import (
+    SensitiveDataMasker,
+    PasswordEncoder,
+    SQLInjectionDetector,
+    RoleBasedAccessControl,
+    RowLevelAccessControl,
+)
+
+# 导入缓存模块
+from spring.orm.pymybatis.cache import (
+    LRUCache,
+    SecondLevelCache,
+)
+
+# 导入事务模块
+from spring.orm.pymybatis.transaction import (
+    TransactionIsolationLevel,
+)
+
+# 导入拦截器模块
+from spring.orm.pymybatis.interceptor import (
+    Interceptor,
+    LogInterceptor,
+    PerformanceInterceptor,
+    SecurityInterceptor,
+)
+
+# 导入类型处理器
+from spring.orm.pymybatis.type_handler import (
+    TypeHandler,
+)
+
+# 导入数据库方言
+from spring.orm.pymybatis.dialect import (
+    Dialect,
+    get_dialect,
+)
+
+# 导入连接池
+from spring.orm.pymybatis.pool import (
+    create_connection_pool,
+)
+
+# 导入动态SQL处理器
+from spring.orm.pymybatis.dynamic_sql import (
+    DynamicSQLProcessor,
+)
+
+# 导入XML解析器
+from spring.orm.pymybatis.xml_parser import (
+    XmlParser,
+)
+
+# 导入熔断器
+from spring.orm.pymybatis.circuit_breaker import (
+    CircuitBreaker,
+)
+
+# 导入指标监控
+from spring.orm.pymybatis.metrics import (
+    MetricsCollector,
+)
+
+# 导入数据库迁移（Flyway风格）
+from spring.orm.migration import (
+    MigrationManager,
+    MigrationError,
+    MigrationState,
+)
+
+# 导入DDL自动建表（JPA hibernate.ddl-auto风格）
+from spring.orm.ddl_auto import (
+    DdlAutoManager,
+    DdlAutoMode,
+    EntityTable,
+    Table,
+    Column,
+    Id,
+    Version,
+    Transient,
+    Index,
+    entity,
+    table as table_decorator,
+    column as column_decorator,
+    id_column as id_column_decorator,
+    version_column,
+    version_column as version_column_decorator,
+    transient_field,
+    transient_field as transient_field_decorator,
+    init_ddl_auto,
+    get_ddl_manager,
+    OptimisticLockExecutor,
+    OptimisticLockError,
+)
+
+# 版本信息
+from spring.orm.pymybatis.version import __version__
+
+__all__ = [
+    # SQLAlchemy数据库管理器
+    'DatabaseManager',
+    'Base',
+    'BaseEntity',
+    'User',
+    'AuditLog',
+    'init_database',
+    # PyMyBatis核心类
+    'Configuration',
+    'build_session_factory',
+    'SqlSessionFactory',
+    'SqlSession',
+    # Spring集成注解
+    'Mapper',
+    'MapperScan',
+    'MyBatisConfigurer',
+    'init_mybatis',
+    # 注解
+    'Select',
+    'Insert',
+    'Update',
+    'Delete',
+    'SelectProvider',
+    'InsertProvider',
+    'UpdateProvider',
+    'DeleteProvider',
+    'ResultMap',
+    'Result',
+    'Options',
+    'Param',
+    'CacheNamespace',
+    'DataSource',
+    'MapperTransactional',
+    # 安全模块
+    'SensitiveDataMasker',
+    'PasswordEncoder',
+    'SQLInjectionDetector',
+    'RoleBasedAccessControl',
+    'RowLevelAccessControl',
+    # 缓存模块
+    'LRUCache',
+    'SecondLevelCache',
+    # 事务模块
+    'TransactionIsolationLevel',
+    # 拦截器模块
+    'Interceptor',
+    'LogInterceptor',
+    'PerformanceInterceptor',
+    'SecurityInterceptor',
+    # 类型处理器
+    'TypeHandler',
+    # 数据库方言
+    'Dialect',
+    'get_dialect',
+    # 连接池
+    'create_connection_pool',
+    # 动态SQL
+    'DynamicSQLProcessor',
+    # XML解析器
+    'XmlParser',
+    # 熔断器
+    'CircuitBreaker',
+    # 指标监控
+    'MetricsCollector',
+    # 数据库迁移
+    'MigrationManager',
+    'MigrationError',
+    'MigrationState',
+    # DDL自动建表
+    'DdlAutoManager',
+    'DdlAutoMode',
+    'EntityTable',
+    'Table',
+    'Column',
+    'Id',
+    'Version',
+    'Transient',
+    'Index',
+    'entity',
+    'table_decorator',
+    'column_decorator',
+    'id_column_decorator',
+    'version_column',
+    'version_column_decorator',
+    'transient_field',
+    'transient_field_decorator',
+    'init_ddl_auto',
+    'get_ddl_manager',
+    # JPA @Version 乐观锁执行器
+    'OptimisticLockExecutor',
+    'OptimisticLockError',
+    # 版本
+    '__version__',
+]

spring/orm/database.py

@@ -0,0 +1,222 @@
+"""
+数据库ORM模块
+集成SQLAlchemy实现企业级数据库操作
+"""
+from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, Boolean, Text, ForeignKey
+from sqlalchemy.orm import declarative_base, sessionmaker, Session, relationship, scoped_session
+from sqlalchemy.exc import SQLAlchemyError
+from datetime import datetime
+import logging
+
+logger = logging.getLogger("Spring.ORM")
+
+# 创建Base类
+Base = declarative_base()
+
+
+class DatabaseManager:
+    """数据库管理器"""
+    
+    _instance = None
+    _lock = __import__('threading').Lock()
+    
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self, db_url: str = "sqlite:///./test.db", echo: bool = False):
+        if hasattr(self, '_initialized'):
+            return
+        self.db_url = db_url
+        self.echo = echo
+        self._engine = None
+        self._session_factory = None
+        self._scoped_session = None
+        self._initialized = True
+    
+    def connect(self) -> None:
+        """连接数据库"""
+        try:
+            self._engine = create_engine(self.db_url, echo=self.echo)
+            
+            # 创建Session工厂
+            self._session_factory = sessionmaker(
+                bind=self._engine,
+                autocommit=False,
+                autoflush=False,
+            )
+            
+            # 创建线程安全的Scoped Session
+            self._scoped_session = scoped_session(self._session_factory)
+            
+            logger.info(f"Connected to database: {self.db_url}")
+        except Exception as e:
+            logger.error(f"Failed to connect to database: {e}")
+            raise
+    
+    def get_engine(self):
+        """获取数据库引擎"""
+        if self._engine is None:
+            self.connect()
+        return self._engine
+    
+    def get_session(self) -> Session:
+        """获取数据库会话"""
+        if self._scoped_session is None:
+            self.connect()
+        return self._scoped_session()
+    
+    def create_all(self):
+        """创建所有表"""
+        engine = self.get_engine()
+        Base.metadata.create_all(engine)
+        logger.info("All tables created")
+    
+    def drop_all(self):
+        """删除所有表"""
+        engine = self.get_engine()
+        Base.metadata.drop_all(engine)
+        logger.info("All tables dropped")
+    
+    def execute(self, statement, *args, **kwargs):
+        """执行SQL语句"""
+        session = self.get_session()
+        try:
+            result = session.execute(statement, *args, **kwargs)
+            session.commit()
+            return result
+        except SQLAlchemyError as e:
+            session.rollback()
+            logger.error(f"SQL execution failed: {e}")
+            raise
+        finally:
+            session.close()
+    
+    def insert(self, model):
+        """插入数据"""
+        session = self.get_session()
+        try:
+            session.add(model)
+            session.commit()
+            session.refresh(model)
+            return model
+        except SQLAlchemyError as e:
+            session.rollback()
+            logger.error(f"Insert failed: {e}")
+            raise
+        finally:
+            session.close()
+    
+    def update(self, model):
+        """更新数据"""
+        session = self.get_session()
+        try:
+            # 使用merge处理脱管对象
+            merged_model = session.merge(model)
+            session.commit()
+            session.refresh(merged_model)
+            # 更新原始对象的属性
+            for attr in ['id', 'created_at', 'updated_at'] + [c.name for c in model.__table__.columns]:
+                if hasattr(merged_model, attr):
+                    setattr(model, attr, getattr(merged_model, attr))
+            return model
+        except SQLAlchemyError as e:
+            session.rollback()
+            logger.error(f"Update failed: {e}")
+            raise
+        finally:
+            session.close()
+    
+    def delete(self, model):
+        """删除数据"""
+        session = self.get_session()
+        try:
+            session.delete(model)
+            session.commit()
+        except SQLAlchemyError as e:
+            session.rollback()
+            logger.error(f"Delete failed: {e}")
+            raise
+        finally:
+            session.close()
+    
+    def query(self, model):
+        """创建查询对象"""
+        session = self.get_session()
+        return session.query(model)
+    
+    def flush(self):
+        """刷新会话"""
+        session = self.get_session()
+        session.flush()
+    
+    def commit(self):
+        """提交事务"""
+        session = self.get_session()
+        session.commit()
+    
+    def rollback(self):
+        """回滚事务"""
+        session = self.get_session()
+        session.rollback()
+
+
+# 创建全局数据库管理器实例
+db_manager = DatabaseManager()
+
+
+def init_database(config: dict) -> None:
+    """
+    初始化数据库配置
+    
+    Args:
+        config: 配置字典，包含url, echo等
+    """
+    global db_manager
+    db_manager = DatabaseManager(
+        db_url=config.get('url', 'sqlite:///./test.db'),
+        echo=config.get('echo', False)
+    )
+    db_manager.connect()
+    
+    # 创建所有表
+    db_manager.create_all()
+
+
+# ==================== 基础实体类 ====================
+
+class BaseEntity(Base):
+    """基础实体类"""
+    __abstract__ = True
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    created_at = Column(DateTime, default=datetime.now, nullable=False)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False)
+    deleted = Column(Boolean, default=False, nullable=False)
+
+
+class User(BaseEntity):
+    """用户实体"""
+    __tablename__ = 'users'
+    
+    username = Column(String(50), unique=True, nullable=False)
+    password = Column(String(255), nullable=False)
+    email = Column(String(100), unique=True, nullable=False)
+    phone = Column(String(20))
+    role = Column(String(50), default='USER')
+    status = Column(Integer, default=1)
+
+
+class AuditLog(BaseEntity):
+    """审计日志实体"""
+    __tablename__ = 'audit_logs'
+    
+    action = Column(String(100), nullable=False)
+    target = Column(String(200))
+    detail = Column(Text)
+    operator = Column(String(100))
+    status = Column(String(20), default='SUCCESS')
+    duration = Column(Float)