申请步骤

1. 使用学校邮箱注册Notion账号

   确保你的Notion账号绑定的是学校提供的教育邮箱，注册完成之后可申请教育版。

2. 确保工作区只有一个成员

   如果你的工作区中有其他成员，请先移除，确保工作区仅包含你自己。

3. 检查当前计划是否为免费版

   如果你已经订阅了付费计划，请先降级到免费版：

   • 进入 Settings → Plans
   • 点击 Downgrade 降级到免费计划。

4. 申请教育优惠

   • 进入 Settings → Plans
   • 点击 Get free education plan 按钮，系统会自动验证你的学校邮箱。
   • 验证成功后，你的账号将自动升级到教育版Plus计划。

注意事项

• 你的学校必须在 World Higher Education Database (WHED) 中注册，才能享受教育优惠。
• 如果你的学校邮箱未被自动验证，可以联系Notion的支持团队进行人工审核。

通过以上步骤，你就可以轻松解锁Notion的教育版Plus功能，享受更多强大功能，提升学习和工作的效率！

三角套利是一种利用不同交易市场（或同一市场内不同交易对）之间短暂的价格差异来获取理论上无风险利润的策略。尤其在波动剧烈的市场中，这类价格不一致的情况可能更频繁出现，为敏锐的交易者提供了潜在的套利机会。

如何判断与计算套利机会？

三角套利的核心在于快速发现并计算三个交易对之间的汇率关系，判断是否存在一个闭环交易能让你用初始资金换回更多资金。以下是具体的判别式、计算方法以及一个交互式计算器，可以帮助你理解和模拟这一过程：

（如果您无法看到上面的图表，请确保您的浏览器支持 iframe。）

高波动市场下的策略优化

市场瞬息万变，尤其在高波动时期，简单的套利逻辑需要配合精密的策略优化才能有效执行：

1. 高频监控是前提：套利窗口可能仅持续几秒甚至毫秒，依赖高频数据接口（如WebSocket）实时捕捉价格变动至关重要。
2. 动态调整阈值：
   • 市场平稳时：可以接受较低的利润阈值（例如0.2%），捕捉更多微小机会。
   • 市场剧烈波动时：应提高阈值（例如0.5%或更高），以覆盖增加的滑点和执行风险。
3. 智能管理流动性：
   • 拆分订单：避免大额订单冲击市场价格，降低滑点。
   • 选择交易所：优先在交易深度好、流动性强的平台执行。
   • 设置滑点容忍度：预先设定可接受的最大滑点，超出则取消订单，避免意外损失。

不可忽视的风险管理

即使是理论上的无风险套利，在实际操作中也存在风险：

1. 滑点风险：高波动下，从看到价格到订单成交，价格可能已经发生不利变化。
   • 对策：优先使用限价单锁定价格，而非市价单。
   • 监控：实时追踪订单簿变化和自身订单的执行状态。
2. 执行风险：包括网络延迟、API响应慢、订单部分成交等，可能导致套利失败甚至亏损。
3. 资金分配：
   • 分散风险：切忌将所有资金投入单次套利。
   • 动态调整：根据市场状况和套利机会的确定性调整投入比例。

总结：三角套利听起来简单，但成功执行需要精密的计算、快速的响应、对市场细微变化的洞察以及严格的风险控制。尤其是在当前多变的市场环境中，持续优化策略和风控措施是保持盈利的关键。

在现代AI应用中，我们常常希望模型能够调用外部工具或服务来完成特定任务，例如执行代码、查询数据库或调用第三方API。模型上下文协议（Model Context Protocol, MCP）提供了一种标准化的方式来实现这种交互。

本教程将指导您如何一步步在本地Windows环境中配置一个基于Node.js的MCP服务器，该服务器能够连接到RapidAPI上的代码执行服务（具体为 Judge0 CE API）。同时，我们还将介绍如何在（假设的）客户端应用 Cherry Studio 中配置此服务器，从而让AI能够通过函数调用（Function Call）来执行代码片段。

第一部分：搭建本地 MCP 服务器

1. 创建项目目录并初始化

首先，我们需要在您的 Windows 电脑上创建一个项目文件夹，并初始化 Node.js 项目。

命令 (PowerShell):

1
2
3
4
5
6
7
8

# 切换到 H 盘（如果需要）
H:
# 创建项目目录（如果目录已存在，此命令会提示，可以忽略）
mkdir mcp-rapidapi-server
# 进入项目目录
cd mcp-rapidapi-server
# 初始化 npm 项目，生成默认 package.json
npm init -y

说明:

• mkdir: 创建新目录。
• cd: 切换当前目录。
• npm init -y: 快速生成一个 package.json 文件，用于管理项目依赖和脚本。

2. 安装依赖

接下来，我们需要安装运行 MCP 服务器所必需的依赖库。

命令 (PowerShell):

1

npm install @modelcontextprotocol/sdk zod node-fetch

说明:

• @modelcontextprotocol/sdk: MCP 协议的官方 Node.js SDK，用于创建 MCP 服务器。
• zod: 一个强大的 TypeScript/JavaScript 模式验证库，用于验证工具的输入参数。
• node-fetch: 允许在 Node.js 环境中像浏览器一样使用 Workspace API 来发送 HTTP 请求。我们用它来调用 RapidAPI。

3. 配置 package.json

为了确保能使用 ES 模块语法（如 import/export）并方便地启动服务器，我们需要对 package.json 文件进行一些修改。

编辑 H:\mcp-rapidapi-server\package.json 文件，内容如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

{
  "name": "mcp-rapidapi-server",
  "version": "1.0.0",
  "main": "server.js",
  "type": "module",  // 启用 ES 模块
  "scripts": {
    "start": "node server.js", // 定义启动脚本
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "dependencies": {
    // 依赖库及其版本（实际安装版本可能因 ^ 而略有不同）
    "@modelcontextprotocol/sdk": "^1.0.0",
    "node-fetch": "^3.0.0",
    "zod": "^3.0.0"
  }
}

说明:

• "type": "module": 这是启用 ES 模块的关键设置。
• "start": "node server.js": 允许我们稍后通过 npm start 命令来启动服务器。

4. 创建并编写 server.js

现在，核心的服务器逻辑来了。在 H:\mcp-rapidapi-server 目录下创建一个名为 server.js 的文件，并将以下代码粘贴进去。

代码 (server.js):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fetch from "node-fetch";

// --- 辅助函数和常量 ---

// 支持的语言及其在 Judge0 API 中的 ID
const LANGUAGE_IDS = {
  "c": 50,
  "cpp": 54,
  "go": 95,
  "java": 91,
  "javascript": 93,
  "python": 92,
  "ruby": 72
};

// 语言别名，增加容错性
const LANGUAGE_ALIASES = {
  "c++": "cpp",
  "golang": "go",
  "js": "javascript"
};

// 根据语言名称获取对应的 ID
function getLanguageId(language) {
  let l = language.toLowerCase();
  return LANGUAGE_IDS[LANGUAGE_ALIASES[l] || l] || 0; // 不支持则返回 0
}

// Base64 编码函数 (用于 Judge0 API)
function encode(str) {
  return Buffer.from(unescape(encodeURIComponent(str || ""))).toString('base64');
}

// Base64 解码函数 (用于 Judge0 API 返回结果)
function decode(bytes) {
  const escaped = escape(Buffer.from(bytes || "", 'base64').toString());
  try {
    return decodeURIComponent(escaped);
  } catch {
    return unescape(escaped); // Fallback for potential decoding errors
  }
}

// --- MCP 服务器设置 ---

// 创建 MCP 服务器实例
const server = new McpServer({
  name: "rapidapi-code-execution",
  version: "1.0.0",
});

// --- 工具定义与注册 ---

// 定义代码执行工具的处理函数
const codeExecutionHandler = async ({ source_code, language }) => {
  // 从环境变量获取 RapidAPI 密钥
  const rapidApiKey = process.env.RAPIDAPI_KEY;
  if (!rapidApiKey) {
      return { content: [{ type: "text", text: "Error: RAPIDAPI_KEY environment variable not set." }] };
  }

  const languageId = getLanguageId(language);
  if (languageId === 0) {
    // 如果语言不受支持，返回错误信息
    return {
      content: [
        {
          type: "text",
          text: `Unsupported language: ${language}`,
        },
      ],
    };
  }

  // 准备请求 RapidAPI 的 Headers 和 Body
  const requestHeaders = {
    "x-rapidapi-key": rapidApiKey,
    "x-rapidapi-host": "judge0-ce.p.rapidapi.com", // 明确 Host
    "Content-Type": "application/json",
  };
  const requestData = {
    language_id: languageId,
    source_code: encode(source_code), // 源代码需要 Base64 编码
    redirect_stderr_to_stdout: true, // 将标准错误重定向到标准输出
  };

  try {
    // 发送 POST 请求到 Judge0 API
    const response = await fetch(
      "[https://judge0-ce.p.rapidapi.com/submissions?base64_encoded=true&wait=true](https://judge0-ce.p.rapidapi.com/submissions?base64_encoded=true&wait=true)", // 使用 base64 并等待执行结果
      {
        method: "POST",
        headers: requestHeaders,
        body: JSON.stringify(requestData),
      }
    );

    // 处理网络或 API 错误
    if (!response.ok) {
      const errorText = await response.text();
      console.error("RapidAPI Error:", response.status, errorText);
      return {
        content: [
          {
            type: "text",
            text: `API request failed with status ${response.status}: ${errorText}`,
          },
        ],
      };
    }

    // 解析返回的 JSON 数据
    const responseData = await response.json();

    // 组合编译输出和标准输出作为最终结果
    const compileOutput = decode(responseData["compile_output"]);
    const stdoutOutput = decode(responseData["stdout"]);
    const stderrOutput = decode(responseData["stderr"]); // 也解码 stderr 看看
    const message = responseData["message"] ? decode(responseData["message"]) : ""; // 解码 message
    const statusDesc = responseData.status?.description || ""; // 获取状态描述

    let resultText = "";
    if (compileOutput) resultText += `Compile Output:\n${compileOutput}\n`;
    if (stdoutOutput) resultText += `Output:\n${stdoutOutput}\n`;
    if (stderrOutput) resultText += `Error Output:\n${stderrOutput}\n`;
    if (message) resultText += `Message:\n${message}\n`;
    if (statusDesc) resultText += `Status: ${statusDesc}\n`;


    return {
      content: [
        {
          type: "text",
          text: resultText.trim() || "Execution finished with no output.", // 如果完全没输出，给个提示
        },
      ],
    };
  } catch (error) {
    // 捕获请求过程中的异常
    console.error("Fetch Error:", error);
    return {
      content: [
        {
          type: "text",
          text: `Error during API call: ${error.message}`,
        },
      ],
    };
  }
};

// 向 MCP 服务器注册 'code_execution' 工具
server.tool(
  "code_execution", // 工具名称，AI 调用时使用
  "Run code in various programming languages using RapidAPI Judge0", // 工具描述
  {
    // 定义输入参数及其类型和描述 (使用 Zod)
    source_code: z.string().describe("The source code snippet to execute."),
    language: z
      .enum(["c", "cpp", "go", "java", "javascript", "python", "ruby"]) // 支持的语言列表
      .describe("The programming language of the source code."),
  },
  codeExecutionHandler // 指定处理函数
);

// --- 测试代码 (已注释掉，仅用于开发调试) ---
/*
if (process.env.TEST_MODE) {
  const testInput = {
    source_code: "print('Hello from MCP test!')",
    language: "python"
  };
  console.log("Running in TEST_MODE...");
  codeExecutionHandler(testInput).then(result => {
    console.log("Test result:", JSON.stringify(result, null, 2));
    process.exit(0); // 测试成功后退出
  }).catch(error => {
    console.error("Test error:", error);
    process.exit(1); // 测试失败后退出
  });
}
*/

// --- 服务器主运行逻辑 ---
async function main() {
  // 如果不是在测试模式下，则正常启动服务器
  if (!process.env.TEST_MODE) {
    const transport = new StdioServerTransport(); // 使用标准输入输出进行通信
    await server.connect(transport);
    console.error("RapidAPI Code Execution MCP Server running on stdio..."); // 使用 console.error 避免干扰 stdout
  }
}

// 启动服务器并捕获潜在错误
main().catch((error) => {
  console.error("Fatal error initializing server:", error);
  process.exit(1);
});

说明:

• 模块导入: 代码首先导入了所需的 SDK 组件、zod 和 node-fetch。
• 辅助函数: 包含处理语言 ID、别名以及 Base64 编解码的函数。
• 服务器实例化: 创建了一个 McpServer 实例。
• 工具处理函数 (codeExecutionHandler): 这是核心逻辑所在，负责接收参数、调用 RapidAPI、处理响应和错误，并返回符合 MCP 格式的结果。注意： 已添加对 RAPIDAPI_KEY 环境变量是否设置的检查。同时改进了错误处理和结果组合。
• 工具注册 (server.tool): 将 codeExecutionHandler 函数注册为名为 code_execution 的工具，并定义了输入参数的模式（使用 zod）。
• 测试代码: 这部分代码（现在已被注释掉）用于在开发时快速测试 codeExecutionHandler 函数是否能正常工作。
• 主函数 (main): 使用 StdioServerTransport 启动服务器，监听标准输入输出流，等待客户端（如 Cherry Studio）连接。

5. 测试服务器 (可选，但推荐首次运行时执行)

在您确认代码无误后，可以通过设置环境变量并运行脚本来测试服务器是否能独立调用 RapidAPI。

命令 (PowerShell):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 确保在项目目录下: H:\mcp-rapidapi-server
cd H:\mcp-rapidapi-server

# 设置 RapidAPI 密钥 (请替换为你的真实密钥)
$env:RAPIDAPI_KEY="YOUR_RAPIDAPI_KEY_HERE"

# 设置测试模式环境变量
$env:TEST_MODE="1"

# 运行服务器脚本 (在测试模式下)
node server.js

# 清理环境变量 (可选)
# Remove-Item Env:\RAPIDAPI_KEY
# Remove-Item Env:\TEST_MODE

预期输出 (类似这样):

1
2
3
4
5
6
7
8
9

Running in TEST_MODE...
Test result: {
  "content": [
    {
      "type": "text",
      "text": "Output:\nHello from MCP test!"
    }
  ]
}

说明:

• 环境变量: 在运行前必须设置 RAPIDAPI_KEY 和 TEST_MODE=1。
• 成功标志: 看到类似 “Test result: …” 的输出并且程序正常退出，表示 server.js 中的 codeExecutionHandler 函数可以成功调用 RapidAPI。
• 失败排查: 如果出错，请检查：
  • RAPIDAPI_KEY 是否正确且有效。
  • 网络连接是否正常。
  • 依赖是否都已正确安装 (npm install)。
  • server.js 代码是否有语法错误。

6. 准备正式运行

测试成功后，服务器脚本就已经准备好了。您可以移除或保持注释掉 server.js 中的测试代码块。确保在后续步骤中不设置 TEST_MODE 环境变量，以便服务器能正常启动并等待客户端连接。

第二部分：在 Cherry Studio 中配置 MCP 服务器

服务器端已经就绪，现在我们需要告诉 Cherry Studio 如何找到并运行这个服务器。以下是在 Cherry Studio 图形界面中进行配置的步骤（基于通用配置项推断）。

配置步骤

1. 打开MCP服务器配置窗口

• 启动 Cherry Studio 应用程序。
• 在菜单栏或设置界面中找到与 MCP 服务器、外部工具 或类似功能相关的配置选项。
• 点击 “添加服务器”、“新建配置” 或类似按钮，打开用于添加新 MCP 服务器的配置窗口。

2. 填写配置字段

在弹出的配置窗口中，仔细填写以下信息：

• 名称 (Name)：
  • 值: @modelcontextprotocol/server-rapidapi-code-execution
  • 说明: 给这个服务器配置起一个唯一的、易于识别的名称。
• 描述 (Description)：
  • 值: MCP server for executing code via RapidAPI Judge0 API
  • 说明: 简要描述这个服务器的功能。
• 类型 (Type)：
  • 选项: STDIO (或 Standard Input/Output)
  • 说明: 选择此类型，因为我们的服务器是通过标准输入/输出来与 Cherry Studio 通信的。
• 命令 (Command)：
  • 值: node
  • 说明: 指定用于启动服务器进程的可执行文件。这里是 Node.js 运行时。
• 参数 (Arguments)：
  • 值: H:\mcp-rapidapi-server\server.js
  • 说明: 提供 server.js 脚本的 完整绝对路径。请务必根据您的实际文件位置修改此路径。 确保路径分隔符对于 Windows 是反斜杠 \。
• 环境变量 (Environment Variables)：
  • 值: RAPIDAPI_KEY=YOUR_RAPIDAPI_KEY_HERE
  • 说明: 在这里设置服务器运行时所需的环境变量。将 YOUR_RAPIDAPI_KEY_HERE 替换为您自己的有效 RapidAPI 密钥。 如果有多个环境变量，通常可以换行或按特定格式添加。
• 启用 (Usage / Enable)：
  • 状态: 开 (On) / 启用 (Enabled)
  • 说明: 确保此开关处于打开状态，以激活这个服务器配置。

3. 保存配置

• 填写完所有字段后，点击窗口中的 “确定”、“保存” 或 “应用” 按钮。

4. 重启 Cherry Studio (推荐)

• 为了确保新的 MCP 服务器配置被完全加载和识别，建议关闭并重新启动 Cherry Studio 应用程序。

5. 测试配置

• 重启后，尝试在 Cherry Studio 中向 AI 发出需要执行代码的指令。例如：

  “请使用 python 运行代码: print(1 + 2 * 3)“

• 观察 AI 的响应。如果配置成功，AI 应该能够识别出这是一个需要使用 code_execution 工具的任务，然后调用您本地运行的 MCP 服务器。服务器执行代码（通过 RapidAPI）后，将结果返回给 AI，最终显示给您。

• 预期结果 (示例):

  1 2

  Output: 7

配置注意事项

• 路径精确性: 参数 (Arguments) 中填写的 server.js 路径必须是 绝对路径 且完全正确，Cherry Studio 必须有权限访问该路径。
• API 密钥: 环境变量 中的 RAPIDAPI_KEY 必须是您自己有效且未过期的 RapidAPI 密钥。
• 服务器运行: Cherry Studio 在需要调用工具时，会根据您的配置尝试启动 node H:\mcp-rapidapi-server\server.js 命令。确保 Node.js 已正确安装并可在系统路径中找到。
• 防火墙/安全软件: 某些情况下，防火墙或安全软件可能会阻止 Cherry Studio 启动本地进程或进行网络通信，需要相应配置允许。

故障排除

如果在测试配置时遇到问题（例如 AI 无法调用工具，或调用后报错），可以尝试以下步骤排查：

1. 检查 Cherry Studio 日志: 查找与 MCP 服务器启动或通信相关的错误信息。

2. 手动运行命令: 在 PowerShell 或 CMD 中，手动执行 Cherry Studio 配置中的完整命令（包括环境变量设置），例如：

   1 2	$env:RAPIDAPI_KEY="YOUR_RAPIDAPI_KEY_HERE" node H:\mcp-rapidapi-server\server.js

   观察是否有错误输出，或者服务器是否能正常启动并打印 ...running on stdio... 信息。

3. 检查路径和密钥: 再次确认 server.js 的路径和 RapidAPI 密钥是否无误。

4. 确认工具名称: 确保 AI 模型知道要调用的工具名称是 code_execution（与 server.js 中 server.tool() 的第一个参数一致）。

总结

恭喜！通过以上步骤，您已经成功：

1. 在本地搭建了一个 Node.js MCP 服务器，它能够代理对 RapidAPI 代码执行服务的调用。
2. 在 Cherry Studio 中配置了这个本地服务器，使得 AI 可以通过 MCP 协议调用该服务器来执行代码。

这为您提供了一个强大的基础，您可以基于此扩展更多自定义工具，进一步增强您的 AI 应用能力。

深圳，作为中国改革开放的前沿阵地和经济发展的活力引擎，其就业市场的薪酬水平一直是大家关注的焦点。不同行业的“钱景”如何？哪些行业在过去十年中增长迅猛？了解这些信息，无论是对于求职者规划职业生涯，还是对于观察城市经济结构演变，都具有重要的意义。

本篇博客将通过一个交互式图表，直观展示深圳市在 2013年至2023年 这十一年间，主要行业单位从业人员年平均工资（城镇非私营单位）的变化情况。

交互式图表：深圳各行业年平均工资趋势 (2013-2023)

重要操作说明：

• 将鼠标悬停 在图表的线条或数据点上，可以查看具体年份、具体行业的年平均工资，以及该年度的同比增长率。
• 点击图例 中的行业名称，可以隐藏或显示对应行业的曲线，方便进行对比分析。

（如果您无法看到上面的图表，请确保您的浏览器支持 iframe。）

图表解读与观察

通过上面的交互式图表，我们可以观察到以下几个显著特点：

1. 头部梯队：高薪行业格局

   • 金融业 长期以来稳居深圳市薪酬榜首，并且在 2023 年达到了惊人的 41.9 万元年平均工资，显示出强大的“吸金”能力。
   • 采矿业 虽然从业人员规模相对较小，但其薪酬水平一直处于较高位置，2023 年也达到了 34.6 万元。
   • 信息传输、软件和信息技术服务业（通常指 IT 行业）作为深圳的支柱产业之一，薪酬水平同样表现亮眼，位列前三甲，2023 年为 28.1 万元。

2. 中坚力量：稳步增长的行业

   • 卫生和社会工作、电力、热力、燃气及水生产和供应业、科学研究和技术服务业 以及 教育 等行业，在过去十年中也展现出显著的薪酬增长，年平均工资普遍超过 20 万元大关（截至 2023 年）。这些行业通常与公共服务、科研创新和人才培养密切相关，其薪酬增长也反映了城市发展的投入方向。

3. 追赶者与基础行业

   • 制造业 作为深圳的传统优势产业，虽然从业人员众多，但整体平均薪酬水平（2023 年约 14.2 万元）相较于头部行业有明显差距，但近年来也保持着稳健的增长。
   • 交通运输、仓储和邮政业、批发和零售业、租赁和商务服务业 等服务性行业，薪酬水平处于中等偏后位置。
   • 建筑业、居民服务、修理和其他服务业 以及 住宿和餐饮业 等基础性服务业和劳动密集型行业，其年平均工资相对较低。

4. 增长趋势与波动

   • 整体趋势：绝大多数行业的年平均工资在 2013 年至 2023 年间都呈现出明显的上升趋势。
   • 增长率差异：不同行业的增长速度差异显著。鼠标悬停在数据点上可以看到具体的年同比增长率，部分行业在特定年份可能出现较大幅度的增长或回调（例如 2022-2023 年部分行业增速放缓甚至略有下降）。

结语

这张图表为我们提供了一个观察深圳过去十一年经济结构和劳动力市场变化的窗口。行业的薪酬水平不仅是经济发展的“晴雨表”，也直接关系到人才的流向和城市的竞争力。

金融、IT 等高薪行业持续领跑，体现了深圳在这些领域的优势地位。同时，科教文卫、公共事业等行业的稳步发展，也反映了城市综合服务能力的提升。当然，不同行业间的薪酬差距依然是需要关注的问题。

希望这份数据和图表能为您提供有价值的参考信息。

这里将介绍如何使用 Amazon Bedrock 的Stability生成图片，并通过 API 提供服务。下面是我的操作步骤，应该还可以优化和简化，我的步骤包括：

1. 申请访问 Amazon Bedrock 基础模型
2. 配置 AWS IAM 权限
3. 搭建 Flask API 服务
4. 使用 systemd 管理服务和 Nginx 反向代理
5. 测试 API

1. 申请访问 Amazon Bedrock 基础模型

首先，你需要申请访问 Amazon Bedrock 的基础模型。你可以在 AWS 管理控制台中找到与 Bedrock 相关的服务。确保你选择了适合你需求的区域，例如支持 Stability AI 的区域。

2. 配置 AWS IAM 权限

在 AWS IAM 中创建一个策略，授予 InvokeModel 和 ListFoundationModels 操作权限，允许访问 Amazon Bedrock 服务。具体步骤如下：

1. 登录 AWS 管理控制台。
2. 打开 IAM 控制台，创建一个新的 IAM 策略。
3. 在策略中，选择 Bedrock 服务，授予 InvokeModel 和 ListFoundationModels 操作权限。
4. 配置资源 ARN（Resource ARN）为你需要访问的模型的 ARN，或选择任何资源。
5. 将策略与 IAM 用户或角色关联。

3. 安装 AWS CLI 和 Boto3 SDK

在你的 VPS 上，你需要安装 AWS CLI 和 Boto3，以便与 Amazon Bedrock 交互。

安装 AWS CLI 教程：

1

https://docs.aws.amazon.com/zh_cn/cli/latest/userguide/getting-started-install.html

配置 AWS CLI：

1

aws configure

输入以下信息：

• AWS Access Key ID:
• AWS Secret Access Key:
• Default region name: 选择你的区域，例如 us-east-1
• Default output format: json

安装 Boto3 SDK：

1

pip install boto3

4. 搭建 Flask API 服务

我们使用 Flask 来创建一个 API 服务，用户可以通过 POST 请求生成图片，并返回图片的 URL。

以下是完整的 Flask 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

from flask import Flask, request, jsonify, send_from_directory
from flask_cors import CORS
import base64
import boto3
import json
import os
from datetime import datetime

app = Flask(__name__)
CORS(app)

client = boto3.client("bedrock-runtime", region_name="us-east-1")
model_id = "stability.stable-diffusion-xl-v1"

output_dir = "/root/output"
if not os.path.exists(output_dir):
    os.makedirs(output_dir)

# 配置API密钥
API_KEY = ""

def generate_image_from_bedrock(prompt):
    native_request = {
        "text_prompts": [{"text": prompt, "weight": 1}],
        "cfg_scale": 10,
        "steps": 50,
        "seed": 0,
        "width": 1024,
        "height": 1024,
        "samples": 1
    }

    try:
        response = client.invoke_model(
            modelId=model_id,
            body=json.dumps(native_request)
        )
        model_response = json.loads(response["body"].read())
        base64_image_data = model_response["artifacts"][0]["base64"]
        return base64_image_data
    except Exception as e:
        raise Exception(f"Error invoking Bedrock model: {str(e)}")

def verify_api_key(api_key):
    if api_key != API_KEY:
        raise PermissionError("Invalid API Key. Access Denied.")

def save_image_and_get_url(base64_image):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"image_{timestamp}.png"
    filepath = os.path.join(output_dir, filename)

    with open(filepath, "wb") as image_file:
        image_file.write(base64.b64decode(base64_image))

    return f"/images/{filename}"

@app.route('/generate-image', methods=['POST'])
def generate_image():
    try:
        data = request.json
        prompt = data.get("prompt")
        api_key = request.headers.get("Authorization")

        if api_key is None:
            return jsonify({"error": "API Key is required"}), 400

        verify_api_key(api_key)

        if not prompt:
            return jsonify({"error": "Prompt is required"}), 400

        base64_image = generate_image_from_bedrock(prompt)
        image_url = save_image_and_get_url(base64_image)

        return jsonify({"imageUrl": image_url}), 200

    except PermissionError as e:
        return jsonify({"error": str(e)}), 403
    except KeyError as e:
        return jsonify({"error": f"Missing key: {str(e)}"}), 400
    except Exception as e:
        return jsonify({"error": f"Internal Server Error: {str(e)}"}), 500

@app.route('/images/<path:filename>')
def serve_image(filename):
    return send_from_directory(output_dir, filename)

if __name__ == '__main__':
    app.run(host="0.0.0.0", port=5000, debug=False)

代码说明

• generate_image_from_bedrock：调用 Amazon Bedrock 生成图像。
• verify_api_key：验证请求中的 API 密钥。
• save_image_and_get_url：将生成的图像保存到本地，并返回图像的 URL。

5. 使用 systemd 和 Nginx 配置反向代理

为了将 API 服务以后台进程运行，并通过 HTTPS 访问，我们需要使用 systemd 和 Nginx 配置。

配置 systemd 服务

创建 systemd 服务文件：

1

sudo nano /etc/systemd/system/flaskapp.service

将以下内容粘贴到文件中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[Unit]
Description=Flask web application for image generation
After=network.target

[Service]
ExecStart=/usr/bin/python3 /root/img-web.py
WorkingDirectory=/root
StandardOutput=journal
StandardError=journal
Restart=always
User=root
Group=root

[Install]
WantedBy=multi-user.target

注意：

• 我们将 ExecStart 设置为 /usr/bin/python3 /root/img-web.py，这里使用了你提供的 img-web.py 的路径。
• WorkingDirectory 设置为 /root，因为你的脚本在 root 目录下。
• User 和 Group 都设置为 root，因为你是在 root 用户下操作的。

保存并关闭文件（在 nano 编辑器中，按 Ctrl+X，然后按 Y，最后按 Enter）。

重新加载 systemd 配置：

1

sudo systemctl daemon-reload

启用服务，使其在系统启动时自动启动：

1

sudo systemctl enable flaskapp.service

启动服务：

1

sudo systemctl start flaskapp.service

检查服务状态：

1

sudo systemctl status flaskapp.service

配置 Nginx 反向代理

参考我的这篇博客

1

https://xblog.aptzone.cc/2024/01/26/docker%E4%BB%A5%E5%8F%8Adocker-compose%E7%9A%84%E4%B8%80%E4%BA%9B%E5%B8%B8%E7%94%A8%E5%91%BD%E4%BB%A4/

6. 测试 API

使用 curl 命令进行测试，发送 POST 请求并查看返回的图像 URL：

1
2
3
4

curl -X POST http://your-domain.com/generate-image \
    -H "Authorization: YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"prompt": "a futuristic city skyline at sunset"}'

如果一切顺利，返回的 JSON 会包含图片的 URL。

总结

通过本教程，你可以成功使用 Amazon Bedrock 创建图片，并通过 Flask API 提供服务。你还学会了如何使用 systemd 管理 Flask 服务，并通过 Nginx 配置反向代理，提供一个可以在线访问的 API。

代码地址：https://github.com/ZefanHu/KGQA

前提条件

在开始之前，请确保你已满足以下条件：

1. 服务器:

   • 安装了 1Panel 面板的 Linux 服务器。
   • 拥有服务器的 SSH 访问权限（本文示例将使用 root 用户，你可以根据实际情况替换为其他有权限的用户）。
   • 服务器上已安装 Git。

2. 1Panel 配置:

   • 已通过 1Panel 创建了一个网站（例如 blog.yourdomain.com），并记下该网站的 根目录（Document Root）。通常在 1Panel 中，路径类似于 /opt/1panel/apps/openresty/openresty/www/sites/你的网站目录/index。请务必替换为你的实际路径。

3. 本地环境:

   • 你的电脑上已安装并配置好 Hexo 博客环境。

   • 你的电脑上已安装 Git。

   • 已安装 Hexo Git 部署插件：

     1	npm install hexo-deployer-git --save

4. SSH 密钥认证 (关键):

   • 你需要在本地电脑生成 SSH 密钥对（如果还没有的话）。
   • 必须将你的本地电脑的 SSH 公钥 添加到服务器上对应用户（如 root）的 ~/.ssh/authorized_keys 文件中。这样可以确保 hexo deploy 时 Git PUSH 操作无需输入密码即可完成。

配置步骤

步骤一：在服务器上安装 Git

如果你的服务器尚未安装 Git，请根据你的 Linux 发行版执行相应命令：

• Debian/Ubuntu:

  1 2	sudo apt-get update sudo apt-get install git -y

• Fedora/RedHat/CentOS:

  1	sudo yum install git -y

步骤二：在服务器上创建 Git 裸仓库 (Bare Repository)

我们需要在服务器上创建一个 Git “裸仓库”。裸仓库不包含工作目录（即你看不到项目文件），只存储 Git 的版本历史和对象数据，非常适合作为中心仓库或中转仓库。

1. 创建仓库目录:
   选择一个路径来存放你的 Git 仓库。例如，我们选择放在 /root/git/ 目录下（你可以自定义路径）。

   1 2	# 创建目录 (如果父目录不存在，也一并创建) mkdir -p /root/git/

2. 修改目录权限 (可选但推荐):
   如果你不是一直使用 root 用户，或者希望更精细地控制权限，可以修改目录所有者和权限。如果使用 root，此步通常可以跳过。

   1 2 3 4

   # 将目录所有者改为当前用户 (如果用 root 执行，则为 root) # chown -R $USER:$USER /root/git/ # 设置权限 (所有者完全控制，同组用户读取执行，其他用户读取执行) # chmod -R 755 /root/git/

3. 初始化裸仓库:
   进入你选择的目录，并初始化一个裸仓库。我们将仓库命名为 blog.git (你也可以自定义)。

   1 2	cd /root/git git init --bare blog.git

   执行后，你会在 /root/git/ 目录下看到一个名为 blog.git 的文件夹。

步骤三：在服务器上配置 Git 钩子 (post-receive)

Git 钩子是在 Git 操作过程中的特定时间点自动执行的脚本。post-receive 钩子在服务器成功接收到推送 (push) 后执行。我们将利用这个钩子将推送过来的 Hexo 文件检出 (checkout) 到 1Panel 的网站根目录。

1. 创建钩子文件:
   进入裸仓库的 hooks 目录，并创建一个名为 post-receive 的文件。

   1	vim /root/git/blog.git/hooks/post-receive

2. 编辑钩子内容:
   在 vim 编辑器中，按 i 进入插入模式，然后粘贴以下脚本内容：

   1 2 3 4 5 6 7 8 9 10

   #!/bin/bash # 指定 Hexo 网站文件存放的目录 (!!!!务必替换为你的 1Panel 网站实际根目录!!!!) WORK_TREE="/opt/1panel/apps/openresty/openresty/www/sites/blog/index" # 指定 Git 裸仓库的路径 (!!!!务必替换为你的裸仓库实际路径!!!!) GIT_DIR="/root/git/blog.git" # 执行 Git checkout 命令，强制将内容检出到工作目录 git --work-tree=${WORK_TREE} --git-dir=${GIT_DIR} checkout -f echo "Hexo blog deployed to ${WORK_TREE}"

   重要说明:

   • --work-tree: 必须 修改为你在 1Panel 中创建的那个网站的 实际根目录路径。
   • --git-dir: 必须 修改为你刚刚创建的 Git 裸仓库的路径 (blog.git)。
   • checkout -f: -f 参数表示强制检出，会覆盖目标目录中已有的文件。

3. 保存并退出 Vim:
   按下 ESC 键退出插入模式，然后输入 :wq! 并按回车键，强制保存并退出 Vim。

4. 赋予钩子执行权限:
   新创建的钩子文件默认没有执行权限，需要添加：

   1	chmod +x /root/git/blog.git/hooks/post-receive

步骤四：修改本地 Hexo 配置

现在，配置你本地 Hexo 博客的 _config.yml 文件，告诉它如何部署。

1. 打开你本地 Hexo 项目根目录下的 _config.yml 文件。

2. 找到 deploy 部分（如果不存在，请添加）。

3. 修改或添加 git 部署配置，如下所示：

   1 2 3 4 5

   deploy: type: git repo: ssh://root@YOUR_SERVER_IP:22/root/git/blog.git # !!! 修改 IP 和路径 !!! branch: main # 或者 master，取决于你希望推送的分支 # message: "Site updated: {{ now('YYYY-MM-DD HH:mm:ss') }}" # 可选的提交信息

   请务必修改:

   • root: 替换为你配置了 SSH 免密登录的服务器用户名。
   • YOUR_SERVER_IP: 替换为你的服务器公网 IP 地址或域名。
   • 22: 如果你的 SSH 端口不是默认的 22，请修改。
   • /root/git/blog.git: 替换为你在服务器上创建的裸仓库的 绝对路径。
   • branch: 确保这个分支名 (main 或 master) 与你的 post-receive 钩子期望检出的分支一致（默认情况下 checkout -f 会检出仓库的 HEAD 指向的分支，通常是 master 或 main）。

步骤五：部署你的 Hexo 博客

一切配置完成后，部署就非常简单了：

1. 在本地 Hexo 项目目录下，执行标准的生成和部署命令：

   1	hexo clean && hexo generate && hexo deploy

   或者直接：

   1

   hexo d

2. 工作流程:

   • hexo g 生成静态文件到 public 目录。
   • hexo d 使用 hexo-deployer-git 插件：
     • 将 public 目录的内容提交到一个临时 Git 分支。
     • 通过 SSH 将这个分支强制推送到你配置的服务器裸仓库 (ssh://root@YOUR_SERVER_IP:22/root/git/blog.git)。
     • 服务器上的 Git 仓库接收到推送后，自动触发 post-receive 钩子脚本。
     • 钩子脚本执行 git checkout -f，将最新的网站文件强制检出（部署）到 1Panel 网站的根目录 (/opt/1panel/apps/openresty/openresty/www/sites/blog/index)。

3. 验证:
   部署命令执行成功后，稍等片刻，然后访问你的博客域名 (http://blog.yourdomain.com 或 https://blog.yourdomain.com)，应该就能看到更新后的内容了。

故障排除提示

• 权限问题: 检查服务器上 Git 仓库目录、网站根目录以及钩子文件的权限是否正确。钩子脚本需要有权限写入网站根目录。
• SSH 密钥问题: 确保本地 SSH 公钥已正确添加到服务器的 authorized_keys 文件中，并且本地 SSH 私钥可用。尝试手动 ssh root@YOUR_SERVER_IP 看是否能免密登录。
• 路径错误: 仔细核对 post-receive 脚本中的 --work-tree 和 --git-dir 路径，以及本地 _config.yml 中的 repo 路径是否完全正确。
• 钩子未执行: 检查钩子文件是否有执行权限 (chmod +x)，文件名是否精确为 post-receive (没有扩展名)。
• 查看日志: 如果部署失败，可以尝试在服务器上查看 SSH 或 Git 相关日志，或者在钩子脚本中添加一些 echo 输出到日志文件来调试。

通过以上配置，你就实现了一个高效、自动化的 Hexo 博客部署流程！

• 操作系统: Ubuntu 22.04
• 编程语言: C++11
• 构建工具: Make
• 数据库: Redis

技术栈

• 中文分词库: cppjieba
• 文本去重: simhash
• 计算机词语权重: TF-IDF
• 倒排索引: 用于快速检索文档
• 余弦相似度算法: 用于计算查询和文档的相似度

主要模块说明

1. DictProducer: 负责创建词典{Word Frequency}和索引文件{Word idx1 idx2 …}
2. PageLibPreprocessor: 负责网页库的预处理,包括网页去重和倒排索引的生成。
3. Dictionary: 管理词典和索引,提供词频查询等功能。
4. WebSearch: 实现网页搜索的核心逻辑,包括查询分词、文档检索和相似度计算。
5. KeyRecommend: 实现关键词推荐功能,使用最小编辑距离算法。
6. NetServer: 基于 Wfrest 的 HTTP 服务器,处理前端请求。
7. Configuration: 管理配置信息,实现单例模式。

本项目的关键字推荐和网页搜索模块是单独的，在离线阶段完成了词典 词典索引 去重后的网页库 网页偏移库 倒排索引库
建立倒排索引是本项目的核心也是难点，目的是将单词或记录作为索引，将文档 ID 作为记录，
这样便可以方便地通过单词或记录查找到其所在的文档。
TF : Term Frequency, 某个词在文章中出现的次数；
DF: Document Frequency, 某个词在所有文章中出现的次数，即包含该词语的文档数量；
IDF: Inverse Document Frequency, 逆文档频率，表示该词对于该篇文章的重要性的一个系数，
其计算公式为：IDF = log2(N/(DF+1))，其中 N 表示文档的总数或网页库的文档数，
最后，词语的权重 w 则为：w = TF * IDF

前提条件

在开始之前，请确保你满足以下条件：

• 两台 Linux 服务器 (本文以两台 Ubuntu 22.04 为例)：
  • 一台拥有公网 IP 的服务器，作为 控制面板服务器 (运行 frps)。示例 IP：18.138.249.128
  • 一台位于内网或防火墙后的服务器，作为 目标服务器 (运行 frpc 和内部服务)。示例 IP：35.212.231.21 (这是公网IP，但假设其上的服务需要穿透)
• 目标服务器上运行的服务：需要一个通过 HTTP 协议访问的服务。本文以 Docker 容器运行的 van-nav 为例，监听在特定端口。也可以是直接运行的二进制程序。
• 域名：一个你拥有管理权限的域名，需要将其解析到 控制面板服务器 的公网 IP。本文示例域名：nat1.status.aptzone.cc。
• FRP 程序：从 FRP GitHub Releases 下载适合你服务器架构（如 amd64, arm64）的最新版本。压缩包内同时包含服务端程序 frps 和客户端程序 frpc。

配置步骤

接下来，我们将分步完成 FRP 的配置和运行。

1. 确定内网服务地址和端口

首先，你需要知道 目标服务器 上内部服务监听的 IP 地址和端口，以便 frpc 可以将流量转发给它。

• 确定 IP 地址：

  • 如果服务和 frpc 运行在同一台目标服务器上，通常可以使用 127.0.0.1 (localhost)。

  • 如果服务运行在 Docker 容器中，你可能需要使用 Docker 容器的内部 IP，或者更常见的是，使用目标服务器上可以访问该容器映射端口的网络接口 IP (例如，物理网卡 IP 或 Docker 网桥 IP)。

  • 你可以使用 ip addr show 命令查看目标服务器的网络接口和 IP 地址：

    1
    ip addr show
    输出示例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
        link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
        inet 127.0.0.1/8 scope host lo
           valid_lft forever preferred_lft forever
        inet6 ::1/128 scope host 
           valid_lft forever preferred_lft forever
    2: ens4: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc mq state UP group default qlen 1000
        link/ether 42:01:0a:8a:00:04 brd ff:ff:ff:ff:ff:ff
        inet 10.138.0.4/32 metric 100 scope global dynamic ens4
           valid_lft 2138sec preferred_lft 2138sec
        inet6 fe80::4001:aff:fe8a:4/64 scope link 
           valid_lft forever preferred_lft forever
    3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
        link/ether 02:42:5c:de:e0:39 brd ff:ff:ff:ff:ff:ff
        inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
           valid_lft forever preferred_lft forever
        inet6 fe80::42:5cff:fede:e039/64 scope link 
           valid_lft forever preferred_lft forever
    你需要记下目标服务器上 `frpc` 可以访问到 `van-nav` 服务的那个 IP 地址。在本例中，我们将使用 `ens4` 接口的 IP `10.138.0.4`。

• 确定端口：确认 van-nav 服务实际监听的端口号。

2. 运行内部服务 (以 van-nav Docker 为例)

在 目标服务器 上启动你的内部服务。以 van-nav Docker 容器为例：

1
2

# 确保你在一个合适的目录下执行，因为 -v $(pwd):/app/data 会映射当前目录
docker run -d --name van-nav --restart always -p 8080:6412 -v $(pwd):/app/data mereith/van-nav:latest

• 命令解释：
  • docker run -d: 在后台运行容器。
  • --name van-nav: 给容器命名为 van-nav。
  • --restart always: 容器退出时自动重启。
  • -p 8080:6412: 将容器内部的 6412 端口映射到 目标服务器 的 8080 端口。这意味着现在可以通过 目标服务器IP:8080 (即 10.138.0.4:8080) 访问 van-nav。
  • -v $(pwd):/app/data: 将主机当前目录映射到容器内的 /app/data 目录，用于持久化数据。
  • mereith/van-nav:latest: 使用的 Docker 镜像。

替代方案：你也可以不使用 Docker，直接下载 van-nav 的二进制文件运行。具体步骤请参考其官方文档。关键是确保服务在目标服务器的某个 IP 和端口上运行。

3. 配置 FRP 服务端 (frps)

在 控制面板服务器 (公网服务器) 上，创建并编辑 frps 的配置文件。通常命名为 frps.toml (或 frps.ini，取决于你下载的版本和偏好，新版本推荐 TOML)。

将下载的 frps 可执行文件和配置文件（例如 frps.toml）放在服务器的某个目录下（例如 /root/frp/）。

编辑 frps.toml 文件：

1
2
3
4
5

# /root/frp/frps.toml 内容示例
bindPort = 7000         # frps 与 frpc 通信的端口
vhostHttpPort = 8080    # frps 监听 HTTP 请求的端口 (用于域名转发)
# 你还可以添加 token 进行身份验证等，提高安全性，例如:
# auth.token = "your_secure_token" 

• bindPort: frps 等待 frpc 连接的端口，需要确保防火墙已放行此端口 (TCP)。
• vhostHttpPort: 当 frpc 配置了 type = http 时，frps 在此端口监听来自公网的 HTTP 请求，并通过 customDomains 进行转发。确保防火墙放行此端口 (TCP)。

4. 配置 FRP 客户端 (frpc)

在 目标服务器 (内网服务器) 上，创建并编辑 frpc 的配置文件。通常命名为 frpc.toml (或 frpc.ini)。

将下载的 frpc 可执行文件和配置文件（例如 frpc.toml）放在服务器的某个目录下（例如 /root/frp/）。

编辑 frpc.toml 文件：

1
2
3
4
5
6
7
8
9
10
11
12

# /root/frp/frpc.toml 内容示例
serverAddr = "18.138.249.128"  # 指向你的控制面板服务器的公网 IP
serverPort = 7000             # 必须与 frps.toml 中的 bindPort 一致
# 如果 frps 设置了 token，这里也需要配置:
# auth.token = "your_secure_token"

[[proxies]]
name = "van-nav-http"           # 代理规则的名字，自定义，方便识别
type = "http"                   # 代理类型为 HTTP
localIP = "10.138.0.4"          # 目标服务器上 van-nav 服务的 IP (第一步确定的)
localPort = 8080                # 目标服务器上 van-nav 服务监听的端口 (第二步映射的)
customDomains = ["nat1.status.aptzone.cc"] # 希望通过访问的域名 (需解析到控制面板服务器IP)

• serverAddr: 你的 控制面板服务器 的公网 IP 地址。
• serverPort: 连接 frps 的 bindPort。
• [[proxies]]: 定义一个具体的代理规则。
• name: 代理规则的唯一标识。
• type = "http": 表明这是一个 HTTP 类型的代理。frps 会使用 vhostHttpPort 来处理这类代理的请求。
• localIP: 目标服务器上内部服务监听的 IP 地址。
• localPort: 目标服务器上内部服务监听的端口。
• customDomains: 指定将哪些域名的请求转发到这个 localIP:localPort。这个域名必须已经解析到你的 控制面板服务器 的公网 IP (18.138.249.128)。

5. 使用 systemd 运行 frp

为了让 frps 和 frpc 在后台稳定运行并在服务器重启后自动启动，推荐使用 systemd 进行管理。

注意：以下步骤假设 frps、frpc 及其配置文件位于 /root/frp/ 目录下。请根据你的实际路径修改 ExecStart 中的路径。

配置 frps 的 systemd 服务 (在控制面板服务器上)

1. 创建 systemd 服务单元文件：

   1	sudo vim /etc/systemd/system/frps.service

2. 在文件中添加以下内容：

   1 2 3 4 5 6 7 8 9 10 11 12

   [Unit] Description=FRP Server Service After=network.target [Service] Type=simple User=root # 或者一个专门运行 frps 的非 root 用户 Restart=on-failure ExecStart=/root/frp/frps -c /root/frp/frps.toml # 确保路径正确 [Install] WantedBy=multi-user.target

3. 保存并退出编辑器，然后重新加载 systemd 配置：

   1	sudo systemctl daemon-reload

4. 启动并设置开机自启 frps 服务：

   1 2	sudo systemctl start frps sudo systemctl enable frps

配置 frpc 的 systemd 服务 (在目标服务器上)

1. 创建 systemd 服务单元文件：

   1	sudo vim /etc/systemd/system/frpc.service

2. 在文件中添加以下内容：

   1 2 3 4 5 6 7 8 9 10 11 12

   [Unit] Description=FRP Client Service After=network.target [Service] Type=simple User=root # 或者一个专门运行 frpc 的非 root 用户 Restart=on-failure ExecStart=/root/frp/frpc -c /root/frp/frpc.toml # 确保路径正确 [Install] WantedBy=multi-user.target

3. 保存并退出编辑器，然后重新加载 systemd 配置：

   1	sudo systemctl daemon-reload

4. 启动并设置开机自启 frpc 服务：

   1 2	sudo systemctl start frpc sudo systemctl enable frpc

检查服务状态

你可以使用以下命令检查 frps 和 frpc 服务的运行状态和日志：

1
2
3
4
5
6
7

# 在控制面板服务器上检查 frps
sudo systemctl status frps
journalctl -u frps -f --no-pager # 查看实时日志

# 在目标服务器上检查 frpc
sudo systemctl status frpc
journalctl -u frpc -f --no-pager # 查看实时日志

如果一切顺利，frpc 应该已经成功连接到 frps。此时，理论上，发送到 控制面板服务器 18.138.249.128 的 8080 端口（vhostHttpPort）且 Host 头为 nat1.status.aptzone.cc 的 HTTP 请求，应该会被转发到 目标服务器 的 10.138.0.4:8080。

你可以尝试直接访问 http://18.138.249.128:8080 并在请求中指定 Host 头，或者更常见地，通过下一步配置的反向代理来访问。

6. 配置反向代理 (以 Nginx Proxy Manager 为例)

通常我们不希望用户通过 IP 和端口号（如 :8080）访问服务，而是直接通过标准的 HTTP (80) 或 HTTPS (443) 端口访问域名。这就需要一个反向代理服务器（如 Nginx、Caddy 或 Nginx Proxy Manager）部署在 控制面板服务器 上。

如果你正在使用 Nginx Proxy Manager (NPM)，请在 NPM 中添加一个新的代理主机 (Proxy Host)：

• Domain Names: nat1.status.aptzone.cc (你在 frpc.toml 中配置的 customDomains)
• Scheme: http
• Forward Hostname / IP: 18.138.249.128 (或者 127.0.0.1，因为 NPM 和 frps 都在这台控制面板服务器上)
• Forward Port: 8080 (你在 frps.toml 中配置的 vhostHttpPort)
• (可选但推荐) 在 SSL 选项卡中为此域名申请并启用 SSL 证书 (例如 Let’s Encrypt)，实现 HTTPS 访问。

工作流程解释：

1. 用户浏览器访问 https://nat1.status.aptzone.cc (假设配置了 SSL)。
2. DNS 将域名解析到控制面板服务器的 IP 18.138.249.128。
3. 请求到达控制面板服务器的 443 端口，被 Nginx Proxy Manager 接收。
4. NPM 根据域名 nat1.status.aptzone.cc 找到对应的代理规则。
5. NPM 将请求 (解密后变为 HTTP) 转发给本机 (127.0.0.1 或 18.138.249.128) 的 8080 端口。
6. frps 在 8080 端口 (vhostHttpPort) 监听到这个请求。
7. frps 检查请求的 Host 头 (nat1.status.aptzone.cc)，找到与之关联的 frpc 客户端连接。
8. frps 通过 bindPort (7000) 建立的隧道，将请求转发给目标服务器上对应的 frpc 实例。
9. frpc 收到请求，将其转发给 localIP:localPort，即 10.138.0.4:8080 上的 van-nav 服务。
10. van-nav 处理请求并将响应原路返回。

完成以上所有步骤后，你就应该能通过访问 http://nat1.status.aptzone.cc 或 https://nat1.status.aptzone.cc (如果配置了 SSL) 来访问部署在内网目标服务器上的 van-nav 服务了。

Heroku 部署方式概览

Heroku 主要提供三种部署应用的方式：

1. Heroku Git: 通过 Heroku 提供的 Git 远程仓库部署代码，Heroku 使用 Buildpacks 自动构建和运行应用。
2. GitHub: 直接连接 GitHub 仓库，实现自动或手动部署。
3. Container Registry: 将构建好的 Docker 镜像推送到 Heroku 的容器注册表进行部署。

本文将重点介绍第三种方法：使用 Heroku Container Registry 部署预先构建好的 Docker 镜像。

下面，我将以部署 One-API（一个 API 管理和分发项目）为例，详细说明在 Heroku 上部署 Docker 容器的具体步骤。

环境与准备

• 操作系统: 示例使用 Ubuntu 22.04，但步骤适用于其他支持 Docker 和 Heroku CLI 的系统。
• 必要工具:
  • Docker (已安装并运行)
  • Heroku CLI (Heroku 命令行工具)
• Heroku 账号: 你需要一个 Heroku 注册账号。
• 待部署的 Docker 镜像:
  • 你需要一个已经构建好的、可以在本地成功运行的 Docker 镜像。本文以本地已有的 calciumion/new-api:latest 镜像为例。
  • 关键要求: 该 Docker 镜像启动的应用 必须 监听由 Heroku 运行时动态注入的 $PORT 环境变量所指定的端口号。大多数 Web 框架能自动识别或可以配置为使用此环境变量。同时，建议在 Dockerfile 中使用 EXPOSE $PORT 或具体的端口号（如果你的应用固定监听某个端口，但监听 $PORT 是最推荐的做法）。

我的本地 Ubuntu 环境，可以看到 calciumion/new-api 镜像已存在：

部署步骤

1. 安装 Heroku CLI

Heroku CLI 是与 Heroku 平台交互的主要工具。

• 对于 Debian/Ubuntu 系统，可以使用官方脚本安装：

  1	curl [https://cli-assets.heroku.com/install-ubuntu.sh](https://cli-assets.heroku.com/install-ubuntu.sh) | sh

• 对于 macOS, Windows 或其他 Linux 发行版，请参考 Heroku 官方文档 进行安装。

安装完成后，可以通过 heroku --version 验证安装。

2. 登录 Heroku

在终端执行登录命令，它会打开浏览器引导你完成登录授权过程：

1

heroku login

3. 创建 Heroku 应用

在部署之前，你需要在 Heroku 上创建一个应用。应用名称 (<your-app-name>) 在 Heroku 全平台上必须是唯一的。

1
2

# 将 <your-app-name> 替换为你想要的应用名称，例如 newapi0819
heroku create newapi0819

成功后，Heroku 会返回应用的访问 URL 和 Git 仓库 URL。

4. 设置应用堆栈为 Container (关键步骤)

默认情况下，Heroku 应用使用 Buildpack 堆栈来构建源代码。因为我们要部署的是预构建的 Docker 镜像，所以需要将应用的堆栈（Stack）明确设置为 container。

1
2

# 将 newapi0819 替换为你的应用名称
heroku stack:set container -a newapi0819

5. 登录 Heroku Container Registry

你需要登录到 Heroku 自己的 Docker 镜像注册表，才能推送镜像：

1

heroku container:login

6. 标记 (Tag) 本地 Docker 镜像

将你本地准备好的 Docker 镜像，按照 Heroku Container Registry 的格式进行标记。格式为：registry.heroku.com/<app-name>/<process-type>。

• <app-name>: 你在第 3 步创建的应用名称 (例如 newapi0819)。
• <process-type>: 定义这个容器扮演的角色。对于处理 Web 请求的应用，通常使用 web。其他类型如 worker 用于后台任务。

假设你的本地镜像是 calciumion/new-api:latest，应用名为 newapi0819，进程类型为 web：

1

docker tag calciumion/new-api:latest [registry.heroku.com/newapi0819/web](https://registry.heroku.com/newapi0819/web)

7. 推送 Docker 镜像到 Heroku

将标记好的镜像推送到 Heroku Container Registry：

1

docker push [registry.heroku.com/newapi0819/web](https://registry.heroku.com/newapi0819/web)

推送过程可能需要一些时间，具体取决于镜像大小和网络速度。

8. 发布 (Release) 镜像到应用

推送完成后，你需要执行 release 命令，告诉 Heroku 使用这个新推送的镜像来运行你的应用。

1
2

# 发布 web 进程类型的容器
heroku container:release web -a newapi0819

Heroku 会拉取镜像并在新的 Dyno（Heroku 的容器实例）中启动它。

9. 验证部署

部署完成后，可以通过以下方式验证：

• 查看实时日志:

  1	heroku logs --tail -a newapi0819

  观察是否有错误信息，确认应用是否成功启动并监听在 $PORT 上。

• 打开应用 URL:

  1	heroku open -a newapi0819

  或者直接在浏览器中访问 https://newapi0819.herokuapp.com (将 newapi0819 替换为你的应用名)。

注意事项

1. 环境变量: 如果你的 Docker 应用依赖环境变量（例如数据库连接字符串、API 密钥等），你需要在 Heroku 应用的设置 (Settings) -> “Config Vars” 部分进行配置。Heroku 会将这些 Config Vars 作为环境变量注入到运行的容器中。不要 将敏感信息硬编码在 Docker 镜像里。
2. 短暂文件系统与数据持久化: Heroku 的 Dyno 文件系统是 短暂的 (Ephemeral)。这意味着每次 Dyno 重启（至少每天发生一次，或在部署、配置更改、平台维护、崩溃后），所有写入容器本地文件系统的更改都会丢失。如果你的应用需要持久化存储数据（如数据库内容、用户上传的文件等），必须 使用 Heroku Add-ons（例如 Heroku Postgres, Heroku Redis）或外部的云数据库/云存储服务（如 AWS RDS, AWS S3）。
3. 监听 $PORT: 再次强调，部署到 Heroku 的 Web 应用 必须 监听 $PORT 环境变量指定的端口。Heroku 的路由层会将外部的 80/443 端口请求路由到你的容器内部监听的这个动态端口上。
4. Heroku 赠金/额度: 如果你通过 GitHub 学生包或其他途径获得了 Heroku 额度，请注意其使用规则。例如，文中提到的 $13/月使用上限和 24 个月有效期。Heroku 的定价和优惠政策可能会变化，请参考 Heroku 官方文档获取最新信息。免费套餐通常也有一定的限制（如 Dyno 休眠机制）。

通过以上步骤，你应该能够成功地将你的 Docker 容器化应用部署到 Heroku 平台上。

• 操作系统: Ubuntu 22.04
• 编程语言: C++11
• 构建工具: Make
• 数据库: MySQL 8.0
• 容器化平台: Docker

技术栈

• 消息队列: RabbitMQ（使用 SimpleAmqpClient 库，Docker 部署）
• 对象存储服务: 阿里云对象存储（Alibaba Cloud OSS）
• 服务注册中心: Consul（使用 ppconsul 库）
• Web框架: wfrest（C++ 异步 Web 框架）
• RPC机制: sRPC（基于 Workflow 框架）

安装与配置指南

为了顺利运行本项目，请确保安装和配置必要的环境和依赖，并根据需要调整配置文件中的相关参数，以适应具体环境和需求。

1. 安装 ppconsul

ppconsul 是 Consul 的 C++ 客户端库。

1.1 安装必要的依赖

1

sudo apt-get update && sudo apt-get install cmake libcurl4-openssl-dev libboost-all-dev

1.2 下载并构建 ppconsul

1

git clone https://github.com/oliora/ppconsul.git && cd ppconsul && mkdir build && cd build && cmake .. && make && sudo make install && sudo ldconfig

2. Consul 部署与使用

按照以下步骤部署和配置 Consul：

2.1 启动 Consul 服务器容器

1

sudo docker pull consul:1.15.3 && sudo docker run --hostname consulsvr1 --name consul_node_1 -d -p 8500:8500 -p 8301:8301 -p 8302:8302 -p 8600:8600 consul:1.15.3 agent -server -bootstrap-expect 2 -ui -bind=0.0.0.0 -client=0.0.0.0

2.2 获取分配的 IP 地址

1

sudo docker inspect --format '{{.NetworkSettings.IPAddress}}' consul_node_1

2.3 启动其它两个 Consul 节点并加入集群

确保将上述命令中的 <IP_ADDRESS> 替换为实际的 IP 地址。

1

sudo docker run --hostname consulsvr2 --name consul_node_2 -d -p 8501:8500 consul:1.15.3 agent -server -ui -bind=0.0.0.0 -client=0.0.0.0 -join <IP_ADDRESS> && sudo docker run --hostname consulsvr3 --name consul_node_3 -d -p 8502:8500 consul:1.15.3 agent -server -ui -bind=0.0.0.0 -client=0.0.0.0 -join <IP_ADDRESS>

2.4 查看集群状态

1

sudo docker exec -t consul_node_1 consul members

2.5 测试 Consul UI 和 API

启动并测试后，您可以通过以下 URL 访问 Consul 服务：

• UI: http://:8500/ui/dc1/services
• API: http://:8500/v1/agent/services

3. 安装阿里云OSS SDK并设置OSS环境变量

3.1 安装必要的依赖

1

sudo apt-get install libssl-dev libcurl4-gnutls-dev

3.2 设置环境变量

编辑 ~/.bashrc 文件：

1

nano ~/.bashrc

在文件末尾添加以下内容：

1
2

export OSS_ACCESS_KEY_ID="your-access-key-id"
export OSS_ACCESS_KEY_SECRET="your-access-key-secret"

保存并关闭文件后，使其生效：

1

source ~/.bashrc

3.3 修改 oss.hpp 文件配置

确保在 oss.hpp 文件中正确配置了阿里云OSS的相关信息，如 Endpoint 和 BucketName。

4. 安装并配置 Nginx

4.1 安装 Nginx

1

sudo apt install nginx && sudo systemctl status nginx

4.2 配置 Nginx

编辑 Nginx 配置文件：

1

sudo vim /etc/nginx/nginx.conf

将配置文件修改为以下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

user root;
worker_processes  1;

events {
    worker_connections  1024;
}

http {
    #include       mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       8868;
        server_name  localhost;

        location / {
            # 将路径修改为服务器上传下载文件保存地址(pwd)
            root /root/myproject/tmp;
        }
    }
}

4.3 检查配置文件语法是否正确

1

sudo nginx -t

如果输出显示配置文件语法正确：

1
2

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

4.4 重新加载或重启 Nginx 服务

重新加载配置：

1

sudo systemctl reload nginx

如果需要，您可以选择重启 Nginx 服务：

1

sudo systemctl restart nginx

5. MySQL 安装与配置

5.1 安装 MySQL

1

sudo apt install -y mysql-server-8.0 libmysqlclient-dev

安装完成后，MySQL 服务会自动启动。

5.2 检查 MySQL 状态

1

sudo systemctl status mysql

5.3 设置 MySQL root 用户密码

由于安装时没有设置密码，使用以下命令登录并设置密码：

1

sudo mysql

在 MySQL 控制台中执行以下 SQL 语句，将 root 用户的密码设置为 1234：

1
2
3

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '1234';
UPDATE mysql.user SET host='%' WHERE user='root';
FLUSH PRIVILEGES;

5.4 重新登录 MySQL

1

mysql -uroot -p

输入密码 1234 进行登录。

5.5 打开 MySQL 配置文件

MySQL 的 bind-address 通常位于配置文件 mysqld.cnf 中。

1

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

注意：配置文件的路径可能因系统或 MySQL 版本而异。如果上面的路径不存在，可以尝试以下路径之一：

• /etc/mysql/my.cnf
• /etc/my.cnf

5.6 修改 bind-address 的值

在打开的配置文件中，查找以下行：

1

bind-address = 127.0.0.1

根据您的需求修改 bind-address 的值：

• 允许仅本地访问（默认设置）：

  1	bind-address = 127.0.0.1

• 允许所有网络接口访问：

  1	bind-address = 0.0.0.0

5.7 重启 MySQL 服务以应用更改

1

sudo systemctl restart mysql

5.8 验证 MySQL 是否绑定到新的地址

您可以使用 ss 或 netstat 命令来验证 MySQL 是否正确绑定到指定的地址和端口（默认为 3306）。

使用 ss：

1

sudo ss -tuln | grep 3306

5.9 导入数据库

运行 tbl_sql.sql 文件以导入数据库：

1

mysql -uroot -p your_database < tbl_sql.sql

6. 安装并配置 RabbitMQ

6.1 启动 RabbitMQ 容器

1

sudo docker run -d --hostname rabbitsvr --name rabbit -p 5672:5672 -p 15672:15672 -p 25672:25672 -v /data/rabbitmq:/var/lib/rabbitmq rabbitmq:management

6.2 访问 RabbitMQ 管理界面

打开浏览器访问 http://:15672 进行管理和配置。

6.3 根据 amqp.hpp 完成配置

确保根据项目需求配置 RabbitMQ 的队列和交换机，具体配置可参考 amqp.hpp 文件中的实现。

7. 安装 AMQP 的 C++ 客户端 SDK

7.1 下载源码包

请确保已下载以下源码包：

• rabbitmq-c-0.11.0.tar.gz
• SimpleAmqpClient-2.5.1.tar.gz

7.2 安装依赖

1

sudo apt install libboost-dev libboost-system-dev libboost-chrono-dev

7.3 构建并安装

对于 rabbitmq-c

1

tar -xzf rabbitmq-c-0.11.0.tar.gz && cd rabbitmq-c-0.11.0 && mkdir build && cd build && cmake .. && make && sudo make install && sudo ldconfig

对于 SimpleAmqpClient

1

tar -xzf SimpleAmqpClient-2.5.1.tar.gz && cd SimpleAmqpClient-2.5.1 && mkdir build && cd build && cmake .. && make && sudo make install && sudo ldconfig

8. 安装 Workflow

8.1 下载源码包

请确保已下载 workflow-0.11.3.tar.gz。

8.2 安装依赖并构建

1

sudo apt install cmake && tar -xzf workflow-0.11.3.tar.gz && cd workflow-0.11.3 && mkdir build && cd build && cmake .. && make && sudo make install && sudo ldconfig

9. 安装 wfrest

9.1 下载源码包

请确保已下载 wfrest-0.9.6.tar.gz。

9.2 构建并安装

1

tar -xzf wfrest-0.9.6.tar.gz && cd wfrest-0.9.6 && mkdir build && cd build && cmake .. && make && sudo make install && sudo ldconfig

10. 安装 Protobuf

10.1 下载源码包

请确保已下载 protobuf-3.20.1.tar.gz。

10.2 构建并安装

1

tar -xzf protobuf-3.20.1.tar.gz && cd protobuf-3.20.1 && sudo apt-get install autoconf automake libtool curl make g++ unzip && ./autogen.sh && ./configure && make && sudo make install && sudo ldconfig

10.3 验证Protobuf

执行protoc，如果出现操作指南说明安装成功了。

11. 安装 srpc

11.1 下载源码包

请确保已下载 srpc-0.10.2.tar.gz。

11.2 安装依赖并构建

1

sudo apt install liblz4-dev libsnappy-dev && tar -xzf srpc-0.10.2.tar.gz && cd srpc-0.10.2 && mkdir build && cd build && cmake .. && make && sudo make install && sudo ldconfig

常见问题

Q1: 为什么需要使用 nlohmann::json，而不是 wfrest 自带的 Json 类？

A1: 项目中选择使用 nlohmann::json，是因为 wfrest 自带的 Json 类在处理嵌套 JSON 结构时存在一定的限制，导致JSON构造失败。

图解递归过程以及复杂度

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#include <stdio.h>

#define SIZE(a) (sizeof(a)/sizeof(a[0]))
#define N 7

void print_array(int arr[], int n) {
 for (int i = 0; i < n; i++) {
  printf("%d ", arr[i]);
 }
 printf("\n");
}

void merge_sort(int arrp[], int n);
int main(void) {

 int arr[N] = { 38,27,43,3,9,82,10 };
 print_array(arr, N);
 merge_sort(arr,N);

 return 0;
}
int tmp[N];
void merge(int arr[], int left, int mid, int right) {
 int i = left, j = mid + 1, k = left;
 while (i <= mid && j <= right)
 {
  if (arr[i] <= arr[j])
  {
   tmp[k++] = arr[i++];
  }
  else
  {
   tmp[k++] = arr[j++];
  }
 }
 while (i <= mid)
 {
  tmp[k++] = arr[i++];
 }
 while (j <= right)
 {
  tmp[k++] = arr[j++];
 }
 for (int k = left; k <= right; k++) {
  arr[k] = tmp[k];
 }
}
void m_sort(int arr[], int left, int right) {
 if (left >= right)
 {
  return;
 }
 int mid = left + (right - left >> 1);
 m_sort(arr, left, mid);
 m_sort(arr, mid + 1, right);
 merge(arr, left,mid, right);

 print_array(arr, N);
}

void merge_sort(int arr[], int n) {
 m_sort(arr, 0, n - 1);
}

代码运行结果

初始数组为：

1

38 27 43 3 9 82 10

排序过程中的数组变化：

1
2
3
4
5
6
7

38 27 43 3 9 82 10
27 38 43 3 9 82 10
27 38 3 43 9 82 10
3 27 38 43 9 82 10
3 27 38 43 9 82 10
3 27 38 43 9 10 82
3 9 10 27 38 43 82

给定一个只包含小写字母的字符串，目标是编写一个函数，将字符串中的字符去重并按字典序排序。

初始方法

使用布尔数组作为哈希表来记录字符是否出现过，然后使用qsort函数对结果进行排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

void remove_duplicate_and_sort(char* str) {
    bool hash[26] = { 0 };
    int index = 0;

    for (int i = 0; str[i]; i++) {
        if (!hash[str[i] - 'a']) {
            hash[str[i] - 'a'] = true;
            str[index++] = str[i];
        }
    }

    str[index] = '\0';
    qsort(str, index, sizeof(char), (int(*)(const void*, const void*)) strcmp);
}

int main(void) {
    char str[100];
    printf("请输入一个字符串：\n");
    scanf("%s", str);
    remove_duplicate_and_sort(str);
    printf("处理后的字符串是：%s\n", str);
    return 0;
}

优化方法：使用位图

通过引入位图（BitMap）的概念，可以进一步提高算法的效率。位图使用一个位来标记某个元素对应的状态，相比布尔数组更节省空间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdio.h>
#include "BitMap.h"

void remove_duplicate_and_sort(char* str) {
    BitMap* bm = bitmap_create(26);
    char* p = str;
    while (*p) {
        bitmap_set(bm, *p - 'a');
        p++;
    }
    p = str;
    for (int i = 0; i < bm->bits; i++) {
        if (bitmap_isset(bm, i)) {
            *p++ = 'a' + i;
        }
    }
    *p = '\0';
    bitmap_destroy(bm);
}

int main(void) {
    char str[] = "bcabc";
    remove_duplicate_and_sort(str);
    puts(str); // 输出处理后的字符串
    return 0;
}

这种方法相比使用布尔数组，可以显著减少内存的使用量，尤其是在处理大量数据时更为显著。通过位操作实现的位图，其性能也比使用数组进行标记要高效。

补充

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//BitMap.h
#include <stdbool.h>
#include <stdint.h>

typedef uint32_t Word;   // uint32_t: 1.大小确定 (32bits);  2.无符号整数

typedef struct {
    uint32_t* array;
    size_t    bits;
} BitMap;

BitMap* bitmap_create(size_t bits);
void bitmap_destroy(BitMap* bm);

void bitmap_set(BitMap* bm, size_t n);
void bitmap_unset(BitMap* bm, size_t n);
bool bitmap_isset(BitMap* bm, size_t n);
void bitmap_clear(BitMap* bm);

void grow_capacity(BitMap* bm, size_t bits)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// BitMap.c
#include "BitMap.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define BITS_PER_WORD 32
#define BITMAP_SHIFT   5 // 2^5 = 32
#define BITMAP_MASK 0x1F
// 存储bits位，需要多少个word
#define BITMAP_SIZE(bits) ((bits + BITS_PER_WORD - 1) >> BITMAP_SHIFT)

BitMap* bitmap_create(size_t bits) {
 BitMap* bm = malloc(sizeof(BitMap));
 bm->array = calloc(BITMAP_SIZE(bits), BITS_PER_WORD >> 3);
 bm->bits = bits;
 return bm;
}

void bitmap_set(BitMap* bm, size_t n) {
 if (n >= bm->bits) {
  if (BITMAP_SIZE(n + 1) > BITMAP_SIZE(bm->bits)) {
   // 扩容
   grow_capacity(bm, n + 1);
  }
  bm->bits = n + 1;
 }
 // 设置第n位 
 // 如何表示第n位 (word, offset)
 size_t word = n >> BITMAP_SHIFT;
 size_t offset = n & BITMAP_MASK; // n%32
 bm->array[word] |= (0x1 << offset);
}
void bitmap_unset(BitMap* bm, size_t n) {
 if (n > bm->bits)
 {
  return;
 }
 size_t word = n >> BITMAP_SHIFT;
 size_t offset = n & BITMAP_MASK; // n%32
 bm->array[word] &= ~(0x1 << offset);
}

bool bitmap_isset(BitMap* bm, size_t n) {
 if (n > bm->bits)
 {
  return;
 }
 size_t word = n >> BITMAP_SHIFT;
 size_t offset = n & BITMAP_MASK; // n%32
 bm->array[word] &= (0x1 << offset);
}
void bitmap_clear(BitMap* bm) {
 memset(bm->array, 0, BITMAP_SIZE(bm->bits) * sizeof(Word));
}

void bitmap_destroy(BitMap* bm) {
 free(bm->array);
 free(bm);
}
void grow_capacity(BitMap* bm, size_t bits)
{
 Word* new_array = realloc(bm->array, BITMAP_SIZE(bits) * sizeof(Word));//字*字节/字 == 字节数
 if (!new_array)
 {
  printf("error realloc in grow_capacity\n");
  exit(1);
 }
 bm->array = new_array;
 int bytes = (BITMAP_SIZE(bits) - BITMAP_SIZE(bm->bits)) * sizeof(Word);
 memset(bm->array+BITMAP_SIZE(bm->bits), 0, bytes);
}

在C语言中，数组是一片连续的内存空间，这片内存空间被划分为大小相等的小空间。在介绍动态数组之前，让我们先简单回顾一下数组的基本特性。

数组的优点

• 访问速度快：可以通过下标索引直接访问元素，时间复杂度为O(1)。
• 内存连续：有利于局部性原理，高速缓存命中率高。

数组的缺点

• 大小固定：数组大小必须在声明时确定，之后无法改变。若数组空间不够，需要重新定义更大的数组。
• 空间静态分配：若申请了较大的数组但实际使用较少，会造成内存浪费。
• 插入和删除效率低：需要移动大量元素，时间复杂度为O(n)。

为了克服数组的上述缺点，我们引入了动态内存分配的概念。

为什么需要动态内存分配？

• 栈空间有限, 不适合存放大数据。
• 栈帧大小在编译期间确定, 栈空间不能存放动态大小的数据。
• 每个线程都有自己的栈, 不适合存放多线程共享的数据。

常见的内存分配函数有malloc, calloc, realloc, free。接下来我们将通过一个实例来展示如何在C语言中实现动态数组。

C语言实现动态数组

首先，我们需要定义一个动态数组的结构体和相关操作。这些操作包括创建数组、添加元素、删除元素、增长容量以及销毁数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// vector.h
#include <stdlib.h>

typedef int E;

typedef struct {
 E* elements;
 int size;
 int capacity;
} Vector;

Vector* vector_create(void);
Vector* vector_create_calloc(void);
void push_back(Vector* v, E val);
void push_front(Vector* v, E val);
E pop_back(Vector* v);
E pop_front(Vector* v);
void grow_capacity(Vector* v);
void vector_destory(Vector* v);

接下来，我们实现这些函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

// vector.c
#include "vector.h"
#include <stdio.h>
#include <stdlib.h>
#define DEFAULT_CAPACITY 4
#define PREALLOC_MAX 1024
Vector* vector_create(void) {
 Vector* v = malloc(sizeof(Vector));
 if (!v)
 {
  printf("Error: malloc fail in vector_create\n");
  exit(1);
 }
 E* p = malloc(sizeof(E) * DEFAULT_CAPACITY);
 if (!p)
 {
  printf("Error: malloc fail in vector_create\n");
  exit(1);
 }
 v->elements = p;
 v->capacity = DEFAULT_CAPACITY;
 v->size = 0;
}

Vector* vector_create_calloc(void) {
 Vector* v = calloc(1, sizeof(Vector));
 if (v == NULL) {
  printf("Error: calloc failed\n");
  exit(1);
 }
 v->elements = calloc(DEFAULT_CAPACITY, sizeof(E));
 if (v->elements == NULL) {
  printf("Error: calloc failed\n");
  exit(1);
 }
 v->capacity = DEFAULT_CAPACITY;
 v->size = 0;
 return v;
}

void grow_capacity(Vector* v) {
 int new_capacity = v->capacity < PREALLOC_MAX ?
  v->capacity << 1 : v->capacity + PREALLOC_MAX;
 E* p = realloc(v->elements, new_capacity * sizeof(E));
 if (!p)
 {
  printf("ERROR: grow_capacity");
  exit(1);
 }
 v->elements = p;
 v->capacity = new_capacity;
}
void push_back(Vector* v, E val) {
 if (v->capacity == v->size)
 {
  grow_capacity(v);
 }
 v->elements[v->size++] = val;
}
// 在数组最前面添加元素，所有元素依次后移
void push_front(Vector* v, E val) {
 if (v->capacity == v->size)
 {
  grow_capacity(v);
 }
 v->size++;
 for (int i = v->size - 2; i > 0; i--)
 {
  v->elements[i + 1] = v->elements[i];
 }
 v->elements[0] = val;
}
// 删除最后一个元素, 并把最后一个元素返回
E pop_back(Vector* v) {
 return v->elements[v->size--];
}
// 删除第一个元素，并把第一个元素返回
E pop_front(Vector* v) {
 int t = v->elements[0];
 for (int i = 0; i < v->size - 1; i++)
 {
  v->elements[i] = v->elements[i + 1];
 }
 v->size--;
 return t;
}

void vector_destory(Vector* v) {
 free(v->elements);
 free(v);
}

现在，我们可以在主函数中测试我们的动态数组了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// main.c
#include <stdio.h>
#include "vector.h"

void print_vector(Vector* v) {
    printf("向量大小: %d, 容量: %d\n", v->size, v->capacity);
    printf("元素: ");
    for (int i = 0; i < v->size; i++) {
        printf("%d ", v->elements[i]);
    }
    printf("\n");
}

int main(void) {
    printf("使用malloc创建向量:\n");
    Vector* v1 = vector_create();
    push_back(v1, 1);
    push_back(v1, 2);
    push_back(v1, 3);
    print_vector(v1);

    printf("使用realloc扩容向量:\n");
    for (int i = 4; i <= 10; i++) {
        push_back(v1, i);
    }
    print_vector(v1);

    printf("使用calloc创建向量:\n");
    Vector* v2 = vector_create_calloc();
    push_back(v2, 1);
    push_back(v2, 2);
    push_back(v2, 3);
    push_back(v2, 4);
    push_back(v2, 5);
    print_vector(v2);

    printf("使用free销毁向量\n");
    vector_destory(v1);
    vector_destory(v2);

    return 0;
}

运行上述代码，我们得到以下输出结果：

下面我们来一个简单的总结，并讲两点注意事项：

1. malloc函数分配的内存块包含未初始化的垃圁数据，而calloc函数分配的内存块会被自动初始化为0。
2. malloc函数只接受一个参数，即要分配的字节数。而calloc函数接受两个参数，一个是要分配的元素的数量，另一个是每个元素的大小。这使得calloc更适合用于数组的分配。
3. 由于calloc会初始化分配的内存，所以它可能比malloc稍微慢一些，尤其是在分配大量内存时。

注意事项

1. use after free
2. double free

在本文中，我们将探讨一些常用的 C 语言字符串库函数，包括 strlen(), strcpy(), strncpy(), strcat(), strncat() 和 strcmp()。对于每个函数，我们将展示其用法，并提供一个自定义的实现。

1. strlen()

strlen()函数接受一个字符串作为参数，并返回字符串的长度。请注意，它不计算结尾的 \0。

1
2

strlen("ABC") = 3
strlen("") = 0

下面是一个常用的计算字符串长度的方法：

1
2
3
4
5

const char* p = s;
while(*p){  //搜索字符串的末尾，即`\0`
 p++;
}
return p - s;

2. strcpy() & strncpy()

接下来我们来看 strcpy() 和 strncpy() 函数。这两个函数用于复制字符串。

首先是 strcpy() 函数的使用：

1
2
3

char s1[MAXLINE];
strcpy(s1, "Hello World.");
s1[MAXLINE - 1] = '\0';

然后是 strncpy() 函数的使用：

1
2
3

char s2[MAXLINE];
strncpy(s2, "Hello world", MAXLINE - 1);
s2[MAXLINE - 1] = '\0';

下面是 strcpy() 和 strncpy() 的自定义实现：

1
2
3
4
5
6
7
8
9
10
11
12
13

char* my_strcpy(char* s1, const char* s2) {
 char* p = s1;
    while(*s1++ = *s2++)
        ;
    return p;
}

char* my_strncpy(char* s1, const char* s2, int count) {
    char* p = s1;
    while((count-- > 0) && (*s1++ = *s2++))
        ;
    return p;
}

3. strcat() & strncat()

接下来我们来看 strcat() 和 strncat() 函数。这两个函数用于连接字符串。

首先是 strcat() 函数的使用：

1
2

char s1[MAXLINE] = "Hello ";
strcat(s1, "world\n");

然后是 strncat() 函数的使用：

1
2

char s2[MAXLINE] = "Hello ";
strncat(s2, "world\n", MAXLINE - strlen(s2) - 1);

下面是 strcat() 和 strncat() 的自定义实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

char* my_strcat(char* s1, const char* s2){
 char* p = s1;
    while(*s1){
        s1++;
    } //s1 == '\0'
    while(*s1++ = *s2++)
        ;
    return p;
}

char* my_strncat(char* s1, const char* s2, size_t count){
 char* p = s1;
    while(*s1){
        s1++;
    } //s1 == '\0'
    while((count--) && (*s1++ = *s2++))
        ;
    return p;
}

4. strcmp()

最后，我们来看 strcmp() 函数。这个函数用于比较两个字符串。

1
2

printf("strcmp(%s, %s) = %d\n", "ABCDef", "ABCDe", strcmp("ABCDef", "ABCDe"));
// strcmp(ABCDef, ABCDe) = 1

下面是 strcmp() 的自定义实现：

1
2
3
4
5
6
7
8
9
10
11