MySQL核心概念与架构解析

在现代应用开发中，数据库是系统的核心支柱。而MySQL作为世界上最流行的开源关系型数据库，其重要性不言而喻。今天，我们将深入探讨MySQL的核心概念和架构设计，为你揭开这个强大数据库系统的神秘面纱。

1. MySQL概述与版本演进

什么是MySQL？关系型数据库的核心价值

MySQL是一个开源的关系型数据库管理系统（RDBMS），由瑞典MySQL AB公司开发，目前属于Oracle公司。它采用客户端-服务器模型，使用结构化查询语言（SQL）进行数据管理。

关系型数据库的核心价值：

-- ACID特性的具体体现START TRANSACTION;-- 原子性(Atomicity)：要么全部成功，要么全部失败UPDATE accounts SET balance = balance - 100 WHERE user_id = 1;UPDATE accounts SET balance = balance + 100 WHERE user_id = 2;-- 一致性(Consistency)：始终满足业务规则约束-- 隔离性(Isolation)：事务间互不干扰-- 持久性(Durability)：提交后数据永久保存COMMIT;

MySQL的关键特性：

• 开源免费（社区版）
• 跨平台支持
• 支持多种存储引擎
• 强大的复制功能
• 丰富的生态系统

MySQL发展历程与重要版本特性

版本演进时间线：

MySQL 5.7 vs 8.0 核心差异对比

-- MySQL 5.7 特性示例SELECT * FROM users WHERE JSON_EXTRACT(profile, '$.age') > 25;-- MySQL 8.0 新特性示例-- 窗口函数SELECT     name,     salary,    AVG(salary) OVER (PARTITION BY department_id) as avg_dept_salaryFROM employees;-- 公用表表达式(CTE)WITH department_stats AS (    SELECT         department_id,        AVG(salary) as avg_salary    FROM employees     GROUP BY department_id)SELECT * FROM department_stats WHERE avg_salary > 5000;-- 角色管理CREATE ROLE read_only;GRANT SELECT ON company.* TO read_only;GRANT read_only TO 'report_user'@'%';

性能对比：

• MySQL 8.0 在读写并发性能上提升约30%
• 更好的JSON处理性能
• 改进的优化器，更准确的成本估算

MySQL在现代应用架构中的定位

在现代微服务架构中，MySQL扮演着重要角色：

TypeError: Cannot read properties of undefined (reading 'v')

2. MySQL体系架构深度解析

整体架构概览

MySQL采用经典的客户端-服务器架构，其核心组件包括：

MySQL Architecture:├── 连接层 (Connection Layer)├── SQL层 (SQL Layer)│   ├── 连接池│   ├── 查询解析器│   ├── 查询优化器│   ├── 查询执行器│   └── 缓存└── 存储引擎层 (Storage Engine Layer)    ├── InnoDB (默认)    ├── MyISAM    ├── Memory    └── 其他引擎

连接层：连接池、身份验证、线程管理

连接处理机制：

public class MySQLConnectionPool{    // MySQL使用线程池处理连接    private const int MAX_CONNECTIONS = 151; // 默认最大连接数        public void HandleConnection(ClientConnection client)    {        // 1. 连接验证        if (!Authenticate(client.Username, client.Password))            throw new AuthenticationException();                    // 2. 权限检查        if (!CheckPrivileges(client.Username, client.Database))            throw new AccessDeniedException();                    // 3. 创建会话        var session = CreateSession(client);                // 4. 线程分配（一对一或线程池）        AssignThreadToSession(session);    }}

连接状态监控：

-- 查看当前连接信息SHOW PROCESSLIST;-- 查看连接统计SHOW STATUS LIKE 'Threads_%';-- 输出示例：-- Threads_cached: 10      -- 缓存中的线程数-- Threads_connected: 25   -- 当前连接数-- Threads_created: 1000   -- 已创建线程总数-- Threads_running: 5      -- 活跃线程数

SQL层：查询解析、优化器、执行器工作原理

SQL查询处理流程：

-- 示例查询SELECT u.name, COUNT(o.id) as order_countFROM users uJOIN orders o ON u.id = o.user_idWHERE u.created_at > '2023-01-01'GROUP BY u.idHAVING order_count > 5ORDER BY order_count DESCLIMIT 10;

处理步骤详解：

1. 查询解析（Parser）

   • 语法分析：检查SQL语法正确性
   • 词法分析：将SQL分解为标记（tokens）
   • 生成解析树

2. 查询优化（Optimizer）

   -- 使用EXPLAIN查看优化器决策EXPLAIN FORMAT=JSON SELECT u.name, COUNT(o.id) as order_countFROM users uJOIN orders o ON u.id = o.user_idWHERE u.created_at > '2023-01-01'GROUP BY u.idHAVING order_count > 5;

3. 查询执行（Executor）

   • 根据执行计划访问存储引擎
   • 应用WHERE条件过滤
   • 执行JOIN操作
   • 进行GROUP BY和聚合
   • 应用HAVING条件
   • 排序和限制结果

存储引擎层：插件式架构设计

MySQL的存储引擎采用插件式架构，允许为不同表选择不同存储引擎：

-- 创建表时指定存储引擎CREATE TABLE users (    id INT PRIMARY KEY AUTO_INCREMENT,    name VARCHAR(100),    email VARCHAR(255),    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP) ENGINE=InnoDB;-- 查看表的存储引擎SHOW TABLE STATUS LIKE 'users';

存储引擎对比：

InnoDB存储引擎架构详解

InnoDB是MySQL的默认存储引擎，其架构设计非常精妙：

InnoDB Architecture:├── 内存结构 (In-Memory Structures)│   ├── Buffer Pool (缓冲池)│   ├── Change Buffer (变更缓冲)│   ├── Adaptive Hash Index (自适应哈希索引)│   ├── Log Buffer (日志缓冲)│   └── Additional Memory Pool└── 磁盘结构 (On-Disk Structures)    ├── 表空间 (Tablespaces)    │   ├── 系统表空间    │   ├── 独立表空间    │   ├── 通用表空间    │   └── 临时表空间    ├── 重做日志 (Redo Logs)    ├── 撤销日志 (Undo Logs)    └── 二进制日志 (Binary Logs)

Buffer Pool工作机制：

-- 查看Buffer Pool状态SHOW ENGINE INNODB STATUS\G-- Buffer Pool相关配置SELECT @@innodb_buffer_pool_size;      -- 缓冲池大小SELECT @@innodb_buffer_pool_instances; -- 缓冲池实例数-- 监控Buffer Pool命中率SELECT     (1 - (Variable_value / (SELECT Variable_value                            FROM information_schema.global_status                            WHERE Variable_name = 'Innodb_pages_read'))) * 100 as hit_rateFROM information_schema.global_status WHERE Variable_name = 'Innodb_buffer_pool_reads';

内存结构与磁盘存储机制

内存管理：

public class InnoDBMemoryManager{    // Buffer Pool - 数据页缓存    private Dictionary<PageId, DataPage> bufferPool;        // Change Buffer - 非唯一索引变更缓存    private Dictionary<IndexId, IndexChange> changeBuffer;        // Log Buffer - 重做日志缓冲    private CircularBuffer<RedoLogRecord> logBuffer;        public DataPage ReadPage(PageId pageId)    {        // 1. 检查Buffer Pool        if (bufferPool.ContainsKey(pageId))            return bufferPool[pageId];                    // 2. 从磁盘读取        var page = diskStorage.ReadPage(pageId);                // 3. 使用LRU算法管理缓存        if (bufferPool.Count >= maxSize)            EvictLeastRecentlyUsedPage();                    bufferPool[pageId] = page;        return page;    }}

磁盘存储结构：

-- 表空间文件结构-- 系统表空间: ibdata1-- 独立表空间: db/table.ibd-- 查看表空间信息SELECT     table_name,    engine,    table_rows,    avg_row_length,    data_length,    index_length,    data_freeFROM information_schema.tables WHERE table_schema = 'your_database';

3. 安装部署与配置优化

多平台安装指南

Linux安装（Ubuntu为例）：

# 更新包管理器sudo apt update# 安装MySQL服务器sudo apt install mysql-server-8.0# 安全配置sudo mysql_secure_installation# 启动服务sudo systemctl start mysqlsudo systemctl enable mysql# 验证安装mysql --version

Docker部署：

# docker-compose.ymlversion: '3.8'services:  mysql:    image: mysql:8.0    container_name: mysql-server    environment:      MYSQL_ROOT_PASSWORD: your_secure_password      MYSQL_DATABASE: app_db      MYSQL_USER: app_user      MYSQL_PASSWORD: app_password    ports:      - "3306:3306"    volumes:      - mysql_data:/var/lib/mysql      - ./conf.d:/etc/mysql/conf.d    command:       - --default-authentication-plugin=mysql_native_password      - --character-set-server=utf8mb4      - --collation-server=utf8mb4_unicode_civolumes:  mysql_data:

配置文件详解（my.cnf/my.ini）

生产环境配置示例：

[mysqld]# 基础配置datadir=/var/lib/mysqlsocket=/var/lib/mysql/mysql.sockport=3306# 内存配置innodb_buffer_pool_size=16G           # 建议为系统内存的70-80%innodb_log_file_size=2G               # 重做日志文件大小innodb_log_buffer_size=256M           # 日志缓冲区大小# 连接配置max_connections=1000                  # 最大连接数thread_cache_size=100                 # 线程缓存大小table_open_cache=4000                 # 表缓存大小# InnoDB配置innodb_file_per_table=ON              # 每个表独立表空间innodb_flush_log_at_trx_commit=1      # 事务提交时刷盘innodb_flush_method=O_DIRECT          # I/O方式innodb_buffer_pool_instances=8        # 缓冲池实例数# 复制配置（如果使用主从）server_id=1log_bin=mysql-binbinlog_format=ROW# 性能配置query_cache_type=0                    # 8.0已移除查询缓存sort_buffer_size=2Mread_buffer_size=2Mread_rnd_buffer_size=2M[mysql]default-character-set=utf8mb4[client]default-character-set=utf8mb4

系统参数调优实战

性能诊断查询：

-- 查看关键性能指标SHOW STATUS WHERE `variable_name` IN (    'Questions', 'Com_select', 'Com_insert', 'Com_update', 'Com_delete',    'Innodb_buffer_pool_reads', 'Innodb_buffer_pool_read_requests',    'Threads_connected', 'Threads_running',    'Key_reads', 'Key_read_requests');-- 计算缓冲池命中率SELECT     ROUND(1 - (variable_value / (        SELECT variable_value         FROM information_schema.global_status         WHERE variable_name = 'innodb_buffer_pool_read_requests'    )), 4) * 100 as buffer_pool_hit_rateFROM information_schema.global_status WHERE variable_name = 'innodb_buffer_pool_reads';-- 检查慢查询SHOW VARIABLES LIKE 'slow_query_log%';SHOW VARIABLES LIKE 'long_query_time';

安全配置与权限管理

基础安全配置：

-- 创建应用用户（遵循最小权限原则）CREATE USER 'app_user'@'192.168.1.%' IDENTIFIED BY 'secure_password_123';-- 授予精确权限GRANT SELECT, INSERT, UPDATE, DELETE ON app_db.* TO 'app_user'@'192.168.1.%';-- 创建只读用户用于报表CREATE USER 'report_user'@'%' IDENTIFIED BY 'readonly_password';GRANT SELECT ON app_db.* TO 'report_user'@'%';-- 查看用户权限SHOW GRANTS FOR 'app_user'@'192.168.1.%';-- 密码策略配置SET GLOBAL validate_password.policy = MEDIUM;SET GLOBAL validate_password.length = 12;

网络安全配置：

-- 限制连接来源RENAME USER 'root'@'%' TO 'root'@'localhost';-- 删除测试数据库和匿名用户DROP DATABASE IF EXISTS test;DELETE FROM mysql.user WHERE User = '';-- 刷新权限FLUSH PRIVILEGES;

监控工具与性能基线建立

系统监控查询：

-- 性能模式监控（MySQL 5.6+）SELECT * FROM performance_schema.events_statements_summary_by_digest ORDER BY sum_timer_wait DESC LIMIT 10;-- 查看锁信息SELECT * FROM information_schema.INNODB_LOCKS;SELECT * FROM information_schema.INNODB_LOCK_WAITS;-- 表统计信息SELECT     table_name,    table_rows,    data_length,    index_length,    ROUND((data_length + index_length) / 1024 / 1024, 2) as total_size_mbFROM information_schema.tables WHERE table_schema = 'your_database'ORDER BY total_size_mb DESC;

建立性能基线：

-- 创建性能基线表CREATE TABLE performance_baseline (    id INT AUTO_INCREMENT PRIMARY KEY,    metric_name VARCHAR(100),    metric_value DECIMAL(20,4),    collected_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,    notes TEXT);-- 收集基线数据INSERT INTO performance_baseline (metric_name, metric_value)SELECT     'qps' as metric_name,    VARIABLE_VALUE as metric_valueFROM information_schema.GLOBAL_STATUS WHERE VARIABLE_NAME = 'Queries';-- 定期收集其他关键指标...

总结

通过本篇的学习，我们深入了解了MySQL的核心概念和架构设计：

1. MySQL的演进历程：从简单的数据库系统发展到功能丰富的企业级解决方案
2. 分层架构设计：连接层、SQL层、存储引擎层的明确分工
3. InnoDB的核心地位：作为默认存储引擎的先进特性
4. 配置优化原则：根据硬件和工作负载进行针对性调优
5. 安全最佳实践：权限最小化和网络安全配置

关键收获：

• 理解MySQL的架构有助于更好地进行性能调优和故障排查
• 合理的配置可以显著提升数据库性能和稳定性
• 安全配置不是可选项，而是生产部署的必备条件

在接下来的篇章中，我们将深入探讨MySQL的数据类型、表设计、索引优化等高级主题，帮助你构建高性能的数据库应用。

思考与实践：

1. 在你的环境中安装MySQL 8.0，并尝试不同的配置参数
2. 使用性能模式监控数据库的运行状态
3. 设计一个符合最小权限原则的用户权限体系
4. 建立关键性能指标的监控基线

欢迎在评论区分享你的MySQL配置经验和遇到的问题！

Lucene.Net 本身是一个单机版全文搜索引擎库，不直接支持分布式索引，但通过合理的架构设计，可以实现分布式索引与搜索。以下是常见的分布式索引实现方案及其优缺点：

主从复制

原理

• 主节点（Master）：负责写入索引，定期将索引快照同步到从节点。
• 从节点（Slave）：只读副本，处理查询请求，提升查询吞吐量和可用性。

实现步骤

1. 主节点写入：所有增删改操作由主节点处理。
2. 索引同步：
   • 方案1：主节点定期将索引文件复制到从节点（如通过 Rsync）。
   • 方案2：通过消息队列（如 RabbitMQ）广播增量变更，从节点实时更新。
3. 查询负载均衡：查询请求通过负载均衡器分发到多个从节点。

优点

• 提升读取性能和可用性（从节点可故障转移）。
• 实现相对简单，无需修改 Lucene.Net 核心逻辑。

缺点

• 写入能力受限于单主节点，可能成为瓶颈。
• 同步延迟导致短暂数据不一致。

适用场景

• 读多写少的场景（如新闻网站、知识库）。

方案2 实现

1. RabbitMQ Fanout 路由模式介绍

1. 核心原理

• 交换器类型：fanout 类型的交换器。
• 行为规则：
  生产者发送到 fanout 交换器的消息，会被复制并分发到所有绑定到该交换器的队列，无论队列绑定时是否指定了路由键。
• 关键特点：
  • 广播机制：消息无差别发送到所有队列，类似“发布-订阅”模式。
  • 路由键无效：消息的路由键（如 user.created）会被忽略，仅交换器类型决定分发行为。

2. 适用场景

• 广播通知：

  • 用户注册成功后，同时发送邮件、短信、站内信（多个消费者独立处理）。
  • 系统配置更新时，通知所有微服务刷新本地缓存。

• 日志收集：
  将日志消息广播到多个处理队列，分别用于实时监控、持久化存储、错误告警等。

• 事件驱动架构：
  解耦事件发布者与订阅者，新增订阅者只需绑定队列，无需修改生产者代码。

3. 对比其他路由模式

4. 总结

Fanout 模式是 RabbitMQ 中最简单的广播机制，适合需要将同一消息分发给多个消费者的场景。其优势在于快速实现解耦和扩展，但需注意无差别广播可能带来的资源浪费。对于需要精细化路由控制的场景，应选择 direct 或 topic 模式。

2. 技术栈组成

3. 示意图

4. 安装MassTransit.RabbitMQ包

5. docker启动RabbitMq服务

# 启动带管理界面的RabbitMQdocker run -d --name rabbitmq \  -p 5672:5672 -p 15672:15672 \  rabbitmq:3-management

6. 示例

services.AddMassTransit(x =>        {            x.AddConsumer<SyncIndexEventConsumer>();            x.UsingRabbitMq((context, cfg) =>            {                cfg.Host("127.0.0.1", $"/",h =>                {                    h.Username("guest");                    h.Password("guest");                });                cfg.Publish<SyncIndexEventConsumer>(x =>                {                    x.ExchangeType = "fanout";                });                // 配置接收端点并绑定到 Fanout 交换机                cfg.ReceiveEndpoint(Guid.NewGuid().ToString(), e =>                {                    e.Bind<SyncIndexEvent>(p =>                    {                        p.ExchangeType = "fanout";                        p.RoutingKey = "";                                         });                    e.ConfigureConsumer<SyncIndexEventConsumer>(context);                    e.PrefetchCount = 50; // 控制消费速率                });            });        });

SyncIndexEventConsumer.cs

public class SyncIndexEventConsumer: IConsumer<SyncIndexEvent>{    public async Task Consume(ConsumeContext<SyncIndexEvent> context)    {        var contextInput = context.Message;        Console.WriteLine("触发索引同步");        await Task.CompletedTask;    }}

SyncIndexEvent.cs

public class SyncIndexEvent{        /// <summary>    /// 表名    /// </summary>    public string TableName { get; set; }        /// <summary>    /// 实际实体对象    /// </summary>    public object Data { get; set; }}

RabbitMQController

[Route("api/[controller]/[action]")][ApiController]public class RabbitMqController : BaseApiController{    private readonly IPublishEndpoint _publishEndpoint;    public RabbitMqController(IPublishEndpoint publishEndpoint)    {        _publishEndpoint = publishEndpoint;    }    /// <summary>    /// 触发全局同步索引    /// </summary>    [HttpGet]    public async Task SyncIndex()    {        await _publishEndpoint.Publish<SyncIndexEvent>(new SyncIndexEvent(), x =>        {            x.Durable = true; // 持久化存储            x.Mandatory = true; // 强制路由            x.SetPriority(1); // 消息优先级        });    }}

方案对比分析

1. 同步机制对比

2. 性能压测数据

# 测试环境：4核8G服务器集群[写入吞吐量]单主节点：1,200 docs/sec从节点扩展：10节点时 8,000 docs/sec[同步延迟]99%请求 < 50ms最大延迟 120ms

• Asp.Net Core Swagger Api 分组和控制器注释
• Asp.Net Core 全局请求返回封装
• 编程工具集(updating)
• 个人能力掌握(updating)
• .Net Core Jenkins 正式版本回滚+发布
• Flutter快速入门
• 快速搭建kubernetes+kubernetes dashboard学习环境
• 踩坑：.Net Core 项目使用 XMLRPC
• Asp.Net Core 使用Serilog记录日志
• Asp.Net Core 基于WorkFlow的工作流引擎
• 踩坑 XMLRPC 踩坑实战 进行中
• Asp.Net Core 全局请求Log
• Asp.Net Core 全局错误拦截
• Asp.Net Core 使用AutoFac注册服务
• Asp.Net Core封装简单EntityFrameworkCore
• Asp.Net Core封装简单的Redis操作库
• Asp.Net Core AutoWrapper库 快速入门
• Asp.Net Core AutoMapper使用
• Asp.net Core分布式系统的日志收集，跟踪
• Asp.net Core GRPC网关
• Asp.net Core Identity Server 4实战
• Asp.net Core消息队列
• Asp.net Core订阅发布
• Asp.net Core Singlr简单使用
• Asp.net Core性能检测（分布式）
• Redis集群踩坑
• Redis集群部署
• Redis快速入门
• 2021程序人生年终总结
• DDD项目实践
• .Net Core 面试题更新中
• Redis 面试题
• RabbitMQ 面试题
• MySQL 面试题
• Docker 快速入门

Serilog简介

Serilog是Asp.Net Core 新兴的日志框架，本文这里简单的介绍一下它的用法以及对他进行简单的封装
官网

Serilog配置

安装基础库

• Install-Package Serilog
• Install-Package Serilog.Sinks.Console
  其中包Serilog是Log核心库，Serilog.Sinks.Console是Log的控制台输出库，这个也是日志框架的一贯策略，一个核心库加多个输出库组合使用，这样可以保持良好的扩展性。

简单的示例：

using (var log = new LoggerConfiguration()           .WriteTo.Console()           .CreateLogger()){    log.Information("Hello, world!");    log.Warning("Goodbye, world.");    log.Error("Goodbye, world.");}

Serilog介绍

LoggerConfiguration

这里用了一个LoggerConfiguration对象，它主要用于创建和设置Log对象，类似于Nlog里面的LogManager类。这里主要用它两个方法：

• WriteTo：WriteTo属性用来设置日志的输出，Serilog将其称为Sink（水槽），还是比较形象的。
• CreateLogger：用于创建一个ILogger类型的Logger对象.

Serilog封装

 public static class SerilogHostingExtensions    {        /// <summary>        /// 加载Serilog配置文件        /// </summary>        /// <returns></returns>        public static IConfiguration AddDefaultConfiguration()        {            var environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");            return new ConfigurationBuilder()            .SetBasePath(Directory.GetCurrentDirectory())            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)            .AddJsonFile($"appsettings.{environmentName}.json", optional: false, reloadOnChange: true)            .AddEnvironmentVariables()            .Build();        }        /// <summary>        /// 使用Serilog日志记录 以文件的方式记录        /// </summary>        /// <param name="hostBuilder"></param>        /// <returns></returns>        public static IWebHostBuilder UseSerilogDefault(this IWebHostBuilder hostBuilder)        {                        var config = AddDefaultConfiguration();            Log.Logger = new LoggerConfiguration()                .ReadFrom.Configuration(config)                .WriteTo.Console()                .CreateLogger();            hostBuilder.UseSerilog();            return hostBuilder;        }        /// <summary>        /// 获取log文件        /// </summary>        /// <param name="config"></param>        /// <param name="defaultValue"></param>        /// <returns></returns>        public static string GetLogFile(this IConfiguration config, string defaultValue)        {            return config.GetValue<string>("LogFile", defaultValue);        }    }

Program.cs

//注入日志builder.WebHost.UseSerilogDefault();

如何使用

ILogger

ILogger对象用于记录日志，和其他日志框架差不多。Serilog日志级别分为如下5级

• Verbose
• Debug
• Information
• Warning
• Error
• Fatal
  大多数的日志也是这样5级，只是有的名称叫的不同（NLog第1级叫Trace，其它的一致），每一级别对应一个写Log的函数：

全局Logger对象

在实际的使用过程中，往往并不是每次使用都去创建一个ILogger，一种方式是通过依赖注入的方式创建一个全局的Logger。不过这种方式需要引入DI框架。在小程序中使用不算方便。

另一种方式是直接使用静态的Log类，它也携带了写入日志的方法，用起来非常方便。

常见存储格式

Serilog的输出对象称之为Sink（水槽），github上提供了大量的第三方的可用sinks，这里简单的列举几个常用的：

• Console 输出到控制台
• Debug 输出到VS的Debug窗口
• File 输出到文件
• MongoDB 输出到MongoDB
• LiteDB 输出到文件数据库LiteDB
• SQLite 输出到文件数据库SQLite
• SignalR 输出为SignalR服务
• HTTP 输出到REST服务
• Loki 输出Loki分布式分布式日志框架
• Elasticsearch 输出到ELK分布式日志框架

输出格式配置

Serilog的日志输出通过LoggerConfiguration类配置，详细的配置参数可以参看官方文档：Configuration Basics。在日常使用中，感觉更多的是直接通过LoggerConfiguration在代码中配置。

输出到文件中

安装扩展

• Install-Package Serilog.Sinks.File

        /// <summary>        /// 使用Serilog日志记录 以Loki分布式的方式记录        /// </summary>        /// <param name="hostBuilder"></param>        /// <returns></returns>        public static IWebHostBuilder UseSerilogDefault(this IWebHostBuilder hostBuilder)        {                        var config = AddDefaultConfiguration();            Log.Logger = new LoggerConfiguration()                .ReadFrom.Configuration(config)                .WriteTo.Console()                .WriteTo.File(config.GetLogFile("logs/.log"), rollingInterval: RollingInterval.Day)                .CreateLogger();            hostBuilder.UseSerilog();            return hostBuilder;        }

配合Loki使用

安装扩展

• Install-Package Serilog.Sinks.Grafana.Loki
• Install-Package Serilog.Settings.Configuration

        /// <summary>        /// 使用Serilog日志记录 以Loki分布式的方式记录        /// </summary>        /// <param name="hostBuilder"></param>        /// <returns></returns>        public static IWebHostBuilder UseSerilogDefault(this IWebHostBuilder hostBuilder)        {                        var config = AddDefaultConfiguration();            Log.Logger = new LoggerConfiguration()                .ReadFrom.Configuration(config)                .WriteTo.Console().Enrich.FromLogContext()    .WriteTo.GrafanaLoki(        "http://localhost:3100")                .CreateLogger();            hostBuilder.UseSerilog();            return hostBuilder;        }

json配置文件形式

{  "Serilog": {    "Using": [      "Serilog.Sinks.Grafana.Loki"    ],    "MinimumLevel": {      "Default": "Debug"    },    "WriteTo": [      {        "Name": "GrafanaLoki",        "Args": {          "uri": "http://localhost:3100",          "labels": [            {              "key": "app",              "value": "web_app"            }          ],          "propertiesAsLabels": [            "app"          ]        }      }    ]  }}

配合ELK使用

安装扩展

• Install-Package serilog.formatting.elasticsearch
• Install-Package serilog.sinks.elasticsearch
• Install-Package Serilog.Settings.Configuration

        /// <summary>        /// 使用Serilog日志记录 以ELK分布式的方式记录        /// </summary>        /// <param name="hostBuilder"></param>        /// <returns></returns>        public static IWebHostBuilder UseSerilogDefault(this IWebHostBuilder hostBuilder)        {                        var config = AddDefaultConfiguration();            Log.Logger = new LoggerConfiguration()                .ReadFrom.Configuration(config)                .WriteTo.Console().WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri("http://localhost:9200") ){             AutoRegisterTemplate = true,             AutoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv6     })                .CreateLogger();            hostBuilder.UseSerilog();            return hostBuilder;        }

json配置项

        /// <summary>        /// 使用Serilog日志记录 以ELK分布式的方式记录        /// </summary>        /// <param name="hostBuilder"></param>        /// <returns></returns>        public static IWebHostBuilder UseSerilogDefault(this IWebHostBuilder hostBuilder)        {            var config = new ConfigurationBuilder()    .SetBasePath(env.ContentRootPath)    .AddJsonFile("appsettings.json")    .Build();            Log.Logger = new LoggerConfiguration()                .ReadFrom.Configuration(config)                .WriteTo.Console().Enrich.FromLogContext()            hostBuilder.UseSerilog();            return hostBuilder;        }var logger = new LoggerConfiguration()    .ReadFrom.Configuration(configuration)    .CreateLogger();

{  "Serilog": {    "WriteTo": [{        "Name": "Elasticsearch",        "Args": {          "nodeUris": "http://localhost:9200;http://remotehost:9200/",          "indexFormat": "custom-index-{0:yyyy.MM}",          "templateName": "myCustomTemplate",          "typeName": "myCustomLogEventType",          "pipelineName": "myCustomPipelineName",          "batchPostingLimit": 50,          "batchAction": "Create",          "period": 2,          "inlineFields": true,          "restrictedToMinimumLevel": "Warning",          "bufferBaseFilename":  "C:/Temp/docker-elk-serilog-web-buffer",          "bufferFileSizeLimitBytes": 5242880,          "bufferLogShippingInterval": 5000,          "bufferRetainedInvalidPayloadsLimitBytes": 5000,          "bufferFileCountLimit": 31,          "connectionGlobalHeaders" :"Authorization=Bearer SOME-TOKEN;OtherHeader=OTHER-HEADER-VALUE",          "connectionTimeout": 5,          "emitEventFailure": "WriteToSelfLog",          "queueSizeLimit": "100000",          "autoRegisterTemplate": true,          "autoRegisterTemplateVersion": "ESv2",          "overwriteTemplate": false,          "registerTemplateFailure": "IndexAnyway",          "deadLetterIndexName": "deadletter-{0:yyyy.MM}",          "numberOfShards": 20,          "numberOfReplicas": 10,          "templateCustomSettings": [{ "index.mapping.total_fields.limit": "10000000" } ],          "formatProvider": "My.Namespace.MyFormatProvider, My.Assembly.Name",          "connection": "My.Namespace.MyConnection, My.Assembly.Name",          "serializer": "My.Namespace.MySerializer, My.Assembly.Name",          "connectionPool": "My.Namespace.MyConnectionPool, My.Assembly.Name",          "customFormatter": "My.Namespace.MyCustomFormatter, My.Assembly.Name",          "customDurableFormatter": "My.Namespace.MyCustomDurableFormatter, My.Assembly.Name",          "failureSink": "My.Namespace.MyFailureSink, My.Assembly.Name"        }    }]  }}

参考文章

Serilog简介

在混合开发中遇到了ucharts无法实现的图表

ucharts

散点图

盒须图

热力图

为了兼容IOS，安卓，H5 并展示图片 ，只能通过uniapp 特定的renderjs语法来实现

代码实现

引入包

echarts.js
ecStat.min.js

echarts.vue

<template><view class="content"><!-- #ifdef APP-PLUS || H5 --><view @click="echarts.onClick" :prop="optionData" :moduleParamProp="moduleParam":change:moduleParamProp="echarts.moduleParamUp" :change:prop="echarts.updateEcharts" :id="moduleParam.id"class="echarts"></view><!--<button @click="changeOption">更新数据</button>--><!-- #endif --><!-- #ifndef APP-PLUS || H5 --><view>非 APP、H5 环境不支持</view><!-- #endif --></view></template><script>export default {data() {return {}},emits: ["getClickData"],props: {moduleParam: {type: Object,default: () => {id: "myCharts";width: "100%";height: "300rpx";type: ""}},optionData: {type: Object,default: () => {}}},onLoad() {},methods: {changeOption() {// 父组件刷新数据// this.$emit("changeOption")},onViewClick(options) {this.$emit("getClickData", options)}}}</script><script module="echarts" lang="renderjs">let myChartexport default {data() {return {clickData: null}},mounted() {if (typeof window.echarts === 'function') {this.initEcharts()} else {// 动态引入较大类库避免影响页面展示const script = document.createElement('script')// view 层的页面运行在 www 根目录，其相对路径相对于 www 计算script.src = 'static/js/echarts.js'script.onload = this.initEcharts.bind(this)document.head.appendChild(script)if(this.moduleParam.type === "scatter"){const ecStat = document.createElement("script")ecStat.src = 'static/js/ecStat.min.js'ecStat.onload = this.initEcharts.bind(this)document.head.appendChild(ecStat)}}},methods: {initEcharts() {myChart = echarts.init(document.getElementById(this.moduleParam.id))// 观测更新的数据在 view 层可以直接访问到if (this.optionData == null) {return;}if (this.moduleParam.type == "boxplot") {this.optionData.tooltip.formatter = (params) => {let txt = ''txt += params.seriesName + '<br/>' +params.marker + '上限值：' + params.data[5] + '' + '<br/>' +params.marker + '上四分位数：' + params.data[4] + '' + '<br/>' +params.marker + '中位数：' + params.data[3] + '' + '<br/>' +params.marker + '下四分位数:' + params.data[2] + '' + '<br/>' +  params.marker + '下限值：' + params.data[1] + '' + '<br/>'return txt}}else if(this.moduleParam.type === "scatter"){echarts.registerTransform(ecStat.transform.clustering);}myChart.setOption(this.optionData)// 点击传参myChart.on('click', params => {this.clickData = params})},updateEcharts(newValue, oldValue, ownerInstance, instance) {// // 监听 service 层数据变更// // console.log(newValue) myChart = echarts.init(document.getElementById(this.moduleParam.id)) myChart.setOption(newValue)},moduleParamUp(newvalue, oldvalue) {},onClick(event, ownerInstance) {// console.log(this.clickData)ownerInstance.callMethod('onViewClick', {value: this.clickData.value,name: this.clickData.name,dataIndex: this.clickData.dataIndex,seriesName: this.clickData.seriesName})}}}</script><style>.echarts {margin-top: 10px;width: 100%;    height: 226px;}</style>

如何使用

<template><view class="content"><dom-echart :moduleParam="moduleParam1" :optionData="option" @getClickData="getClickData1"></dom-echart><dom-echart :moduleParam="moduleParam2" :optionData="option1" @getClickData="getClickData2"></dom-echart><dom-echart :moduleParam="moduleParam3" :optionData="option2" @getClickData="getClickData3"></dom-echart></view></template><script>const dataAll = [{value: [10.0, 80],symbolSize: 10,itemStyle: {color: '#B797C4',}},];// prettier-ignoreconst markLineOpt = {animation: false,lineStyle: {type: 'solid'},data: [[{coord: [0, 50],symbol: 'none'},{coord: [20, 50],symbol: 'none'}],[{coord: [10, 0],symbol: 'none'},{coord: [10, 100],symbol: 'none'}]]};import domEchart from '@/components/echarts/echarts.vue'export default {components: {domEchart},data() {return {moduleParam1: {id: "moId1",type: "scatter"},moduleParam2: {id: "moId2",},moduleParam3: {id: "moId3",},option: {title: {text: '平均正确率：%',textStyle: {color: '#9E9E9E',fontSize: 10,}},grid: {left: 30,top: 30,right: 20,bottom: 20},tooltip: {formatter: 'Group {a}: ({c})'},xAxis: [{gridIndex: 0,min: 0,max: 20}],yAxis: [{gridIndex: 0,min: 0,max: 100}],series: [{name: 'I',type: 'scatter',data: dataAll,markLine: markLineOpt}]},option1: {title: {text: 'ECharts2'},series: [{name: '销量',type: 'pie',data: [53, 20, 28, 12, 10, 20]}]},option2: {title: {text: 'ECharts3'},xAxis: {data: ["衬衫1", "羊毛衫", "雪纺衫", "裤子", "高跟鞋", "袜子"]},yAxis: {},series: [{name: '销量',type: 'line',data: [53, 20, 28, 12, 10, 20]}]}}},onLoad() {},methods: {getClickData1(option) {console.log("点击的值", option)},getClickData2(option) {console.log("点击的值", option)},getClickData3(option) {console.log("点击的值", option)},}}</script><style></style>