SQLSugar监控与诊断

原创 于 2025-12-20 21:52:26 发布 · 218 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #数据库 #开发语言

AgenticCoding·十二月创作之星挑战赛 10w+人浏览 438人参与

引言

在现代企业级应用中，数据库性能直接影响着系统的响应速度和用户体验。SQLSugar作为一款优秀的.NET ORM框架，不仅需要掌握其基本使用方法，更需要建立完整的监控与诊断体系，确保在复杂业务场景下能够快速定位和解决性能问题。本文将全面介绍SQLSugar的监控与诊断方案，帮助开发者构建高效的数据库性能管理体系。

一、SQLSugar内置监控机制

1.1 AOP事件监控体系

SQLSugar提供了完整的AOP（面向切面编程）事件机制，能够在不侵入业务代码的情况下实现全面的SQL监控。

public class SqlSugarAopLogger
{
    public static void ConfigureAop(SqlSugarClient db)
    {
        // 开启SQL执行监控
        db.Aop.OnLogExecuting = (sql, pars) =>
        {
            // 1. 记录原始SQL
            string originalSql = sql;
            
            // 2. 格式化参数
            SugarParameter[] parameters = pars as SugarParameter[];
            string formattedSql = FormatSql(originalSql, parameters);
            
            // 3. 记录执行前日志
            LogSql("SQL执行前", formattedSql, db.Ado.Connection.Database);
        };

        // SQL执行完成事件
        db.Aop.OnLogExecuted = (sql, pars) =>
        {
            // 可以在此处记录执行完成状态
            Console.WriteLine($"SQL执行完成: {sql}");
        };

        // SQL执行错误事件
        db.Aop.OnError = (exp) =>
        {
            // 记录错误信息
            LogError($"SQL执行错误: {exp.Message}", exp.Sql, db.Ado.Connection.Database);
            
            // 可以集成到错误监控系统
            SendToErrorMonitoringSystem(exp);
        };

        // 执行时间监控
        db.Aop.OnExecutingChangeSql = (sql, pars) =>
        {
            // 可以修改SQL语句
            return new KeyValuePair<string, SugarParameter[]>(sql, pars);
        };
    }

    private static string FormatSql(string sql, SugarParameter[] parameters)
    {
        if (parameters == null || parameters.Length == 0)
            return sql;

        foreach (var param in parameters)
        {
            string paramValue = param.Value?.ToString() ?? "NULL";
            sql = sql.Replace(param.ParameterName, $"'{paramValue.Replace("'", "''")}'");
        }
        
        return sql;
    }
}

1.2 执行统计与性能分析

public class SqlPerformanceMonitor
{
    private readonly ConcurrentDictionary<string, SqlExecutionStats> _stats =
        new ConcurrentDictionary<string, SqlExecutionStats>();

    public void ConfigurePerformanceMonitor(SqlSugarClient db)
    {
        Stopwatch stopwatch = new Stopwatch();
        
        db.Aop.OnLogExecuting = (sql, pars) =>
        {
            stopwatch.Restart();
        };

        db.Aop.OnLogExecuted = (sql, pars) =>
        {
            stopwatch.Stop();
            long elapsedMs = stopwatch.ElapsedMilliseconds;
            
            // 生成SQL指纹（去除具体参数值）
            string sqlFingerprint = GenerateSqlFingerprint(sql);
            
            // 更新统计信息
            var stats = _stats.GetOrAdd(sqlFingerprint, 
                key => new SqlExecutionStats { SqlTemplate = sqlFingerprint });
            
            stats.TotalExecutions++;
            stats.TotalDurationMs += elapsedMs;
            stats.AverageDurationMs = stats.TotalDurationMs / stats.TotalExecutions;
            
            if (elapsedMs > stats.MaxDurationMs)
                stats.MaxDurationMs = elapsedMs;
                
            if (stats.MinDurationMs == 0 || elapsedMs < stats.MinDurationMs)
                stats.MinDurationMs = elapsedMs;
            
            // 记录慢查询
            if (elapsedMs > 1000) // 超过1秒定义为慢查询
            {
                LogSlowQuery(sql, pars, elapsedMs, db.Ado.Connection.Database);
            }
        };
    }

    public List<SqlExecutionStats> GetPerformanceReport()
    {
        return _stats.Values
            .OrderByDescending(s => s.TotalDurationMs)
            .Take(20) // 返回耗时最多的20个SQL
            .ToList();
    }
}

public class SqlExecutionStats
{
    public string SqlTemplate { get; set; }
    public long TotalExecutions { get; set; }
    public long TotalDurationMs { get; set; }
    public long AverageDurationMs { get; set; }
    public long MaxDurationMs { get; set; }
    public long MinDurationMs { get; set; }
}

二、集成第三方监控系统

2.1 集成MiniProfiler

public static class MiniProfilerIntegration
{
    public static void ConfigureMiniProfiler(SqlSugarClient db)
    {
        db.Aop.OnLogExecuting = (sql, pars) =>
        {
            var profiler = MiniProfiler.Current;
            if (profiler != null)
            {
                // 创建MiniProfiler自定义步骤
                var stepKey = $"sql_{Guid.NewGuid()}";
                var step = profiler.CustomTiming("sql", "执行SQL", sql);
                
                // 将step存储在AsyncLocal中，以便在执行完成后结束
                CurrentProfilerStep.Value = step;
                
                // 添加SQL参数信息
                if (pars is SugarParameter[] parameters && parameters.Length > 0)
                {
                    var paramInfo = string.Join(", ", 
                        parameters.Select(p => $"{p.ParameterName}={p.Value}"));
                    step.CommandString = $"{sql} -- 参数: {paramInfo}";
                }
            }
        };

        db.Aop.OnLogExecuted = (sql, pars) =>
        {
            var step = CurrentProfilerStep.Value;
            if (step != null)
            {
                step?.Dispose();
                CurrentProfilerStep.Value = null;
            }
        };

        db.Aop.OnError = (exp) =>
        {
            var step = CurrentProfilerStep.Value;
            if (step != null)
            {
                step.Errored = true;
                step.Dispose();
                CurrentProfilerStep.Value = null;
            }
        };
    }

    private static readonly AsyncLocal<CustomTiming> CurrentProfilerStep = 
        new AsyncLocal<CustomTiming>();
}

2.2 集成Application Insights

public class ApplicationInsightsIntegration
{
    private readonly TelemetryClient _telemetryClient;

    public ApplicationInsightsIntegration(TelemetryClient telemetryClient)
    {
        _telemetryClient = telemetryClient;
    }

    public void ConfigureAppInsights(SqlSugarClient db)
    {
        db.Aop.OnLogExecuting = (sql, pars) =>
        {
            var operationHolder = _telemetryClient.StartOperation<DependencyTelemetry>("SQL");
            operationHolder.Telemetry.Type = "SQL";
            operationHolder.Telemetry.Target = db.Ado.Connection.Database;
            operationHolder.Telemetry.Data = sql;
            
            CurrentOperation.Value = operationHolder;
        };

        db.Aop.OnLogExecuted = (sql, pars) =>
        {
            var operation = CurrentOperation.Value;
            if (operation != null)
            {
                _telemetryClient.StopOperation(operation);
                CurrentOperation.Value = null;
            }
        };

        db.Aop.OnError = (exp) =>
        {
            var operation = CurrentOperation.Value;
            if (operation != null)
            {
                operation.Telemetry.Success = false;
                operation.Telemetry.Properties["ErrorMessage"] = exp.Message;
                _telemetryClient.TrackException(exp);
                _telemetryClient.StopOperation(operation);
                CurrentOperation.Value = null;
            }
        };
    }

    private static readonly AsyncLocal<IOperationHolder<DependencyTelemetry>> CurrentOperation = 
        new AsyncLocal<IOperationHolder<DependencyTelemetry>>();
}

三、慢查询分析与优化

3.1 慢查询自动捕获系统

public class SlowQueryMonitor
{
    private readonly List<SlowQueryRecord> _slowQueries = new List<SlowQueryRecord>();
    private readonly object _lock = new object();
    private readonly int _slowThresholdMs;

    public SlowQueryMonitor(int slowThresholdMs = 1000)
    {
        _slowThresholdMs = slowThresholdMs;
    }

    public void ConfigureSlowQueryDetection(SqlSugarClient db)
    {
        Stopwatch stopwatch = new Stopwatch();
        string currentSql = string.Empty;
        SugarParameter[] currentParams = null;

        db.Aop.OnLogExecuting = (sql, pars) =>
        {
            currentSql = sql;
            currentParams = pars as SugarParameter[];
            stopwatch.Restart();
        };

        db.Aop.OnLogExecuted = (sql, pars) =>
        {
            stopwatch.Stop();
            long elapsedMs = stopwatch.ElapsedMilliseconds;

            if (elapsedMs > _slowThresholdMs)
            {
                var record = new SlowQueryRecord
                {
                    Sql = currentSql,
                    Parameters = currentParams,
                    ExecutionTime = DateTime.Now,
                    DurationMs = elapsedMs,
                    Database = db.Ado.Connection.Database,
                    ConnectionString = db.Ado.Connection.ConnectionString,
                    StackTrace = GetRelevantStackTrace()
                };

                lock (_lock)
                {
                    _slowQueries.Add(record);
                    // 保持最近的1000条慢查询记录
                    if (_slowQueries.Count > 1000)
                        _slowQueries.RemoveAt(0);
                }

                // 异步通知管理员
                Task.Run(() => NotifyAdministrator(record));
            }
        };
    }

    public List<SlowQueryRecord> GetSlowQueries(DateTime? from = null, DateTime? to = null)
    {
        lock (_lock)
        {
            var query = _slowQueries.AsQueryable();
            
            if (from.HasValue)
                query = query.Where(q => q.ExecutionTime >= from.Value);
                
            if (to.HasValue)
                query = query.Where(q => q.ExecutionTime <= to.Value);
                
            return query.OrderByDescending(q => q.DurationMs).ToList();
        }
    }

    private string GetRelevantStackTrace()
    {
        var stackTrace = new System.Diagnostics.StackTrace(true);
        var frames = stackTrace.GetFrames();
        
        // 只保留与业务代码相关的堆栈信息
        var relevantFrames = frames
            .Where(f => !f.GetMethod().DeclaringType.FullName.StartsWith("System") &&
                       !f.GetMethod().DeclaringType.FullName.StartsWith("Microsoft") &&
                       !f.GetMethod().DeclaringType.FullName.Contains("SqlSugar"))
            .Take(5) // 只取前5个相关帧
            .Select(f => $"{f.GetMethod().DeclaringType.FullName}.{f.GetMethod().Name}:{f.GetFileLineNumber()}");
            
        return string.Join(Environment.NewLine, relevantFrames);
    }
}

public class SlowQueryRecord
{
    public string Sql { get; set; }
    public SugarParameter[] Parameters { get; set; }
    public DateTime ExecutionTime { get; set; }
    public long DurationMs { get; set; }
    public string Database { get; set; }
    public string ConnectionString { get; set; }
    public string StackTrace { get; set; }
}

3.2 慢查询分析报表

public class SlowQueryAnalyzer
{
    public SlowQueryReport AnalyzeQueries(List<SlowQueryRecord> queries)
    {
        var report = new SlowQueryReport
        {
            TotalSlowQueries = queries.Count,
            AnalysisTime = DateTime.Now
        };

        if (queries.Count == 0)
            return report;

        // 按SQL模式分组（去除具体参数值）
        var sqlGroups = queries
            .GroupBy(q => NormalizeSql(q.Sql))
            .Select(g => new SqlPatternStats
            {
                SqlPattern = g.Key,
                ExecutionCount = g.Count(),
                AverageDuration = g.Average(q => q.DurationMs),
                MaxDuration = g.Max(q => q.DurationMs),
                LastExecution = g.Max(q => q.ExecutionTime)
            })
            .OrderByDescending(s => s.MaxDuration)
            .ToList();

        report.SqlPatterns = sqlGroups;
        report.MostFrequentPattern = sqlGroups.OrderByDescending(s => s.ExecutionCount).FirstOrDefault();
        report.SlowestPattern = sqlGroups.OrderByDescending(s => s.MaxDuration).FirstOrDefault();

        // 时间分布分析
        var hourlyDistribution = queries
            .GroupBy(q => q.ExecutionTime.Hour)
            .Select(g => new { Hour = g.Key, Count = g.Count() })
            .OrderBy(x => x.Hour)
            .ToList();

        report.PeakHours = hourlyDistribution
            .OrderByDescending(x => x.Count)
            .Take(3)
            .Select(x => x.Hour)
            .ToList();

        return report;
    }

    private string NormalizeSql(string sql)
    {
        // 去除具体参数值，只保留SQL模式
        // 这是一个简化的实现，实际中可能需要更复杂的处理
        string pattern = @"@\w+\d*";
        return System.Text.RegularExpressions.Regex.Replace(sql, pattern, "@param");
    }
}

public class SlowQueryReport
{
    public int TotalSlowQueries { get; set; }
    public DateTime AnalysisTime { get; set; }
    public List<SqlPatternStats> SqlPatterns { get; set; }
    public SqlPatternStats MostFrequentPattern { get; set; }
    public SqlPatternStats SlowestPattern { get; set; }
    public List<int> PeakHours { get; set; }
}

public class SqlPatternStats
{
    public string SqlPattern { get; set; }
    public int ExecutionCount { get; set; }
    public double AverageDuration { get; set; }
    public double MaxDuration { get; set; }
    public DateTime LastExecution { get; set; }
}

四、连接池监控与优化

4.1 连接池状态监控

public class ConnectionPoolMonitor
{
    private readonly SqlSugarClient _db;
    private readonly Timer _monitorTimer;
    private readonly List<ConnectionPoolMetrics> _metricsHistory = new List<ConnectionPoolMetrics>();

    public ConnectionPoolMonitor(SqlSugarClient db, int monitorIntervalSeconds = 30)
    {
        _db = db;
        _monitorTimer = new Timer(CollectMetrics, null, 
            TimeSpan.Zero, TimeSpan.FromSeconds(monitorIntervalSeconds));
    }

    private void CollectMetrics(object state)
    {
        try
        {
            var metrics = GetConnectionPoolMetrics();
            _metricsHistory.Add(metrics);
            
            // 保留最近24小时的数据
            var cutoffTime = DateTime.Now.AddHours(-24);
            _metricsHistory.RemoveAll(m => m.Timestamp < cutoffTime);
            
            // 检查连接池健康状况
            CheckConnectionPoolHealth(metrics);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"连接池监控异常: {ex.Message}");
        }
    }

    private ConnectionPoolMetrics GetConnectionPoolMetrics()
    {
        // 注意：不同数据库的连接池监控方式不同
        // 这里以SQL Server为例
        var metrics = new ConnectionPoolMetrics
        {
            Timestamp = DateTime.Now,
            Database = _db.Ado.Connection.Database
        };

        // 在实际应用中，可能需要执行特定的系统视图查询
        // 例如SQL Server: SELECT * FROM sys.dm_exec_connections
        
        return metrics;
    }

    public ConnectionPoolDiagnosis GetDiagnosis()
    {
        if (_metricsHistory.Count < 10)
            return new ConnectionPoolDiagnosis { Status = "数据不足" };

        var recentMetrics = _metricsHistory
            .OrderByDescending(m => m.Timestamp)
            .Take(100)
            .ToList();

        var diagnosis = new ConnectionPoolDiagnosis
        {
            Status = "正常",
            Suggestions = new List<string>()
        };

        // 分析连接数趋势
        var avgConnections = recentMetrics.Average(m => m.ActiveConnections);
        var maxConnections = recentMetrics.Max(m => m.ActiveConnections);
        
        if (avgConnections > 100)
        {
            diagnosis.Status = "警告";
            diagnosis.Suggestions.Add($"平均连接数较高: {avgConnections:F0}，考虑优化连接管理");
        }
        
        if (maxConnections > 150)
        {
            diagnosis.Status = "警告";
            diagnosis.Suggestions.Add($"最大连接数过高: {maxConnections:F0}，可能存在连接泄露");
        }

        return diagnosis;
    }
}

public class ConnectionPoolMetrics
{
    public DateTime Timestamp { get; set; }
    public string Database { get; set; }
    public int ActiveConnections { get; set; }
    public int IdleConnections { get; set; }
    public int ConnectionTimeouts { get; set; }
    public double AvgConnectionWaitTime { get; set; }
}

public class ConnectionPoolDiagnosis
{
    public string Status { get; set; }
    public List<string> Suggestions { get; set; }
}

五、实时性能仪表板

5.1 Web监控界面

<!-- PerformanceDashboard.html -->
<!DOCTYPE html>
<html>
<head>
    <title>SQLSugar性能监控仪表板</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        .dashboard {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
            gap: 20px;
            padding: 20px;
        }
        .metric-card {
            background: white;
            border-radius: 8px;
            padding: 20px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }
        .slow-query-list {
            max-height: 400px;
            overflow-y: auto;
        }
    </style>
</head>
<body>
    <div class="dashboard">
        <!-- QPS监控 -->
        <div class="metric-card">
            <h3>QPS监控</h3>
            <canvas id="qpsChart"></canvas>
        </div>
        
        <!-- 慢查询统计 -->
        <div class="metric-card">
            <h3>慢查询统计</h3>
            <canvas id="slowQueryChart"></canvas>
        </div>
        
        <!-- 连接池状态 -->
        <div class="metric-card">
            <h3>连接池状态</h3>
            <div id="connectionPoolStatus"></div>
        </div>
        
        <!-- 最近慢查询 -->
        <div class="metric-card">
            <h3>最近慢查询</h3>
            <div id="recentSlowQueries" class="slow-query-list"></div>
        </div>
    </div>
    
    <script>
        // 实时数据更新
        async function updateDashboard() {
            const response = await fetch('/api/sqlsugar-metrics');
            const data = await response.json();
            
            updateQPSChart(data.qpsData);
            updateSlowQueryChart(data.slowQueryData);
            updateConnectionPool(data.connectionPool);
            updateSlowQueries(data.recentSlowQueries);
        }
        
        setInterval(updateDashboard, 5000);
        updateDashboard(); // 初始加载
    </script>
</body>
</html>

SQLSugar监控与诊断体系的建立是一个系统性工程，需要从多个层面进行考虑：

  1. 监控层面：利用SQLSugar的AOP机制实现全面的SQL监控

  2. 分析层面：建立慢查询分析、性能统计和连接池监控

  3. 可视化层面：通过仪表板实时展示关键指标

  4. 告警层面：建立智能告警机制，及时发现潜在问题

  5. 集成层面：与现有监控系统（如Application Insights、MiniProfiler）集成

在实际应用中，建议根据以下原则进行配置：

  • 分级监控：根据环境（开发、测试、生产）配置不同级别的监控

  • 性能开销：监控本身会带来性能开销，需要权衡监控粒度和性能影响

  • 自动化处理：对常见问题建立自动化处理机制

  • 持续优化：定期分析监控数据，持续优化SQL和数据库设计

当 SQL 执行计划 “跑偏”：参数嗅探陷阱，强制索引 “救星” 与运算符优化奇招
danny-IT技术博客
03-22 126
通过深度解析执行计划，某电商平台将核心查询性能提升300%，参数嗅探问题减少90%。记住：执行计划不是敌人，而是性能优化的地图。掌握这些技巧，您将拥有打开SQL Server性能之门的钥匙！
DotNetNext/SqlSugar数据库连接池故障诊断
gitblog_00156的博客
08-31 617
数据库连接池是现代应用开发中的关键组件，它通过复用数据库连接来提升性能并减少资源消耗。在使用DotNetNext/SqlSugar ORM框架时，连接池故障是开发人员经常遇到的棘手问题。本文将深入探讨SqlSugar连接池的工作原理、常见故障场景及诊断方法，帮助开发者快速定位和解决连接池相关问题。 ## SqlSugar连接池架构解析 ### 连接管理核心机制 SqlSugar通过`Conn...
DotNetNext/SqlSugar数据库连接池监控建议
gitblog_00105的博客
08-31 771
在当今高并发的企业级应用开发中，数据库连接池（Database Connection Pool）的性能监控至关重要。作为.NET生态中广受欢迎的ORM框架，SqlSugar提供了灵活的连接管理机制，但很多开发者往往忽视了连接池的监控和优化。本文将深入探讨SqlSugar连接池的最佳监控实践，帮助您构建更稳定、高效的数据库应用。 ## SqlSugar连接池核心机制 ### 连接配置关键参数 ...
DotNetNext/SqlSugar数据库连接池监控深度解析
gitblog_00439的博客
08-31 986
在现代企业级应用开发中，数据库连接池（Connection Pool）的性能直接影响着整个系统的稳定性和响应速度。一个配置不当的连接池可能导致连接泄漏、性能瓶颈甚至系统崩溃。DotNetNext/SqlSugar作为一款高性能的ORM框架，其连接池管理机制值得我们深入探讨。 通过本文，您将掌握： - SqlSugar连接池的核心工作原理 - 实时监控连接池状态的有效方法 - 性能优化和故障排查的...
DotNetNext/SqlSugar数据库连接池故障排查与优化指南
gitblog_00916的博客
08-31 767
数据库连接池故障是.NET应用中常见的性能瓶颈，往往在系统压力增大时突然爆发。SqlSugar作为一款高性能的ORM框架，虽然提供了便捷的数据库操作接口，但在连接池管理方面仍需开发者深度介入。本文将深入探讨SqlSugar连接池故障的排查方法和优化策略。 ## 连接池基础原理 ```mermaid flowchart TD A[应用程序请求连接] --> B{连接池中有空闲连接?} ...
C# 死锁：原理、诊断与解决方案深度解析
记录学习的过程
05-23 1244
本文深入探讨了C#中的死锁问题，详细介绍了死锁的基本概念、形成机制、常见场景、诊断方法及解决方案。死锁通常发生在多线程环境下，当多个线程因争夺资源而互相等待时，导致程序无法继续执行。文章通过代码示例展示了常见的死锁场景，如锁的嵌套、同步上下文死锁和线程池死锁，并提供了使用Visual Studio、WinDbg等工具进行死锁诊断的方法。此外，文章还提出了多种预防和解决死锁的策略，包括保持锁顺序一致性、使用锁超时机制、避免同步阻塞异步代码以及使用更高级的同步原语。通过这些方法，开发者可以有效减少死锁的发生，提
DotNetNext/SqlSugar数据库连接池升级方案
gitblog_00754的博客
08-31 618
在现代企业级应用中，数据库连接池（Database Connection Pool）的性能直接影响着系统的吞吐量和响应时间。SqlSugar作为一款高性能的.NET ORM框架，其连接池管理机制对于提升应用性能至关重要。本文将深入探讨SqlSugar连接池的工作原理、优化策略和升级方案。 ## SqlSugar连接池架构解析 ### 连接配置核心类 SqlSugar通过`Connection...
DotNetNext/SqlSugar数据库连接池报警报告
gitblog_00928的博客
08-31 605
数据库连接池是现代应用程序性能优化的关键组件，但在高并发场景下，连接池问题往往成为系统瓶颈。本文基于DotNetNext/SqlSugar ORM框架，深入分析数据库连接池监控与报警机制，帮助开发者构建健壮的数据库访问层。 ## 连接池基础原理 ### 连接池工作机制 ```mermaid flowchart TD A[应用程序请求数据库连接] --> B{连接池中有空闲连接?} ...
DotNetNext/SqlSugar数据库连接池扩容
gitblog_00306的博客
08-31 1063
在现代企业级应用开发中，数据库连接管理是影响系统性能的关键因素之一。当应用面临高并发访问时，数据库连接池的配置不当往往成为性能瓶颈。DotNetNext/SqlSugar作为一款优秀的.NET ORM框架，提供了灵活的连接池管理机制，本文将深入探讨SqlSugar数据库连接池的扩容策略和实践。 ## SqlSugar连接池架构解析 ### 连接配置核心类：ConnectionConfig S...
DotNetNext/SqlSugar数据库连接池容量评估
gitblog_00549的博客
08-31 899
在现代企业级应用开发中，数据库连接管理是影响系统性能和稳定性的关键因素。DotNetNext/SqlSugar作为一款优秀的.NET ORM（对象关系映射）框架，其连接池管理机制直接关系到应用程序的数据库访问效率。本文将深入探讨SqlSugar的连接池管理策略，并提供专业的容量评估方法和最佳实践。 ## SqlSugar连接管理机制 ### 核心配置参数 SqlSugar通过`Connect...
C# SqlSugar多数据库仓储模式中的数据索引优化
# 1. 理解数据仓储模式 - 1.1 数据仓储模式的定义和作用 - 1.2 数据仓储模式与多数据库的...首先我们将介绍SqlSugar框架的基本概述，然后探讨其在多数据库仓储模式中的具体应用场景，最后讨论SqlSugar资源索引与优
【OceanBase 诊断调优】—— 日志归档延迟或日志归档慢的原因和解决方法
汤庆
12-05 1299
CDB_OB_ARCHIVELOG视图中对应租户的checkpoint_scn字段已经落后于当前时间很多。（前提是日志归档还在进行，即CDB_OB_ARCHIVELOG视图中对应租户的 staus 仍然是 DOING，且checkpoint_scn还在往前推。）
企业级前后端分离权限框架Meiam.System的实践与介绍
- **nlog**: 是一个日志记录框架，用于记录应用程序运行时的信息，便于问题诊断和性能监控。 - **autofac**: 是.NET的一个依赖注入容器，它支持控制反转模式，以简化复杂应用程序的依赖关系。 - **webapi**: 表示该...
车载系统应用开发集成系统API
yangyulong0622的博客
12-16 598
车载开发中，为了快速迭代常将系统应用剥离为普通应用开发，但调用系统API时反射效率低。解决方法是通过集成framework.jar，但会遇到编译报错问题。通用方案是在gradle中配置bootstrapClasspath引入jar包。当使用高版本JDK时，必须强制指定模块使用JDK8并关闭lint检查才能生效。关键步骤：先加载jar包到工程，再设置模块JDK版本为1.8。
MyBatis-Plus 单元测试中 Lambda Mock 的坑与解决
qq_43657722的博客
12-17 1197
本文总结了 MyBatis-Plus 在单元测试中使用 LambdaWrapper 时常见的 Lambda 缓存异常问题，分析其根源在于 Mock 环境缺失真实上下文。通过精简示例说明为何 any(LambdaWrapper.class) 易出错，并给出使用 any() 的稳定解决方案，强调单元测试应聚焦业务逻辑、避免过度关注 SQL 与 Lambda 细节。
JAVA设计模式之观察者模式
pingguocu3的博客
12-17 366
在我们开发的过程中，经常会遇到一些当什么什么事情发生的时候，然后做什么什么事。比如某种商品的物价上涨时会导致部分商家高兴，而消费者伤心。平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。著作权归作者所有,转载或内容合作请联系作者。
使用idea启动一个springboot项目
最新发布
qq_51389137的博客
12-19 1410
5.装配置maven配置到idea下载项目依赖。4.装navicat。
【FastAPI】FastAPI依赖注入完全指南
weixin_63434398的博客
12-18 2872
本文全面介绍FastAPI的依赖注入机制，主要包含两大注入方式：原生自动注入和Depends自定义注入。原生注入支持Request/Response等框架对象以及路径/查询参数等自动解析，而Depends则用于自定义依赖项注入。文章详细讲解依赖注入的核心思想、实现方式、生命周期管理、高级技巧，并通过完整认证系统案例展示实战应用。最后剖析Depends底层原理，并与Spring框架进行对比，帮助开发者彻底掌握FastAPI这一核心特性，实现代码解耦和高效开发。
任务总执行时长
y245166349的专栏
12-17 413
任务编排服务负责对任务进行组合调度。参与编排的任务有两种类型，其中一种执行时长为taskA，另一种执行时长为taskB。任务一旦开始执行不能被打断，且任务可连续执行。服务每次可以编排num个任务。请编写一个方法，生成每次编排后的任务所有可能的总执行时长。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

code_shenbing

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值