当前位置： 首页 > news >正文

设计模式(C++)详解——职责链模式 (Chain of Responsibility)（2）

news 2025/9/24 9:49:51

职责链模式 (Chain of Responsibility) 生动解析：让请求在流水线上跳舞

引言：从一个咖啡店的故事开始

想象一下，你走进一家精致的咖啡店，想要一杯特调拿铁。你不会直接冲到后厨对咖啡师指手画脚，而是优雅地走到收银台。接下来发生的事情，就是职责链模式的完美写照：

你 → 收银员(接单) → 咖啡师(制作) → 甜品师(拉花) → 服务员(配送)

每个角色各司其职，像一条精心设计的流水线。这就是职责链模式的魅力所在！今天，就让我们像品味一杯好咖啡那样，细细品味这个精妙的设计模式。

第一章：初识职责链——什么是"责任接力赛"？

1.1 模式的灵魂：让请求去旅行

职责链模式的核心思想很简单：不要把所有鸡蛋放在一个篮子里。更准确地说，是"不要把所有请求交给一个处理者"。

想象一下公司的报销流程：

  • 小金额（<1000元）：部门经理审批
  • 中金额（1000-5000元）：财务总监审批
  • 大金额（>5000元）：CEO审批

如果让CEO审批所有报销单，他早就被埋没在文件堆里了！职责链模式就像是一个智能分拣系统，让每个请求自动找到合适的处理者。

1.2 三个火枪手：模式的核心角色

让我们用三个生动的角色来理解这个模式：

下一个
«抽象»
处理者
-下一个处理者
+设置下一个()
+处理请求()
具体处理者A
+处理请求()
具体处理者B
+处理请求()

🎭 角色一：抽象处理者 (Handler)

  • 像是接力赛的"跑道规则"
  • 定义处理请求的接口和方法
  • 知道下一个接棒者是谁

🎭 角色二：具体处理者 (Concrete Handler)

  • 像是接力赛的"运动员"
  • 真正处理请求的实干家
  • 决定是自己处理还是传给下一个人

🎭 角色三：请求 (Request)

  • 像是接力赛的"接力棒"
  • 包含请求的所有信息
  • 在处理者之间传递

第二章：深入浅出——职责链如何工作？

2.1 工作原理：请求的奇幻漂流

让我们通过一个生动的故事来理解职责链的工作原理：

故事时间：小明的请假条冒险记

小明想请5天假去旅游，他写了一张请假条（请求）。这张请假条开始了一段奇妙的旅程：

  1. 第一站：组长张姐

    • 张姐看了看：“5天？我只能批3天以内的，找经理吧！”
    • 请假条被传递到下一站

  2. 第二站：经理李总

    • 李总想了想：“5天正好在我的权限内，批了！”
    • 旅程结束，请假条被成功处理

如果李总也处理不了，请假条还会继续旅行，直到找到能处理的人！

用代码来描述这个旅程：

// 请假条类
class LeaveRequest {
public:LeaveRequest(int days, const std::string& reason) : m_days(days), m_reason(reason) {}int getDays() const { return m_days; }std::string getReason() const { return m_reason; }private:int m_days;std::string m_reason;
};// 抽象处理者
class Approver {
public:virtual ~Approver() = default;void setNextApprover(std::shared_ptr<Approver> next) {m_next = next;}virtual void processRequest(const LeaveRequest& request) = 0;protected:std::shared_ptr<Approver> m_next;
};// 具体处理者：组长
class GroupLeader : public Approver {
public:void processRequest(const LeaveRequest& request) override {if (request.getDays() <= 3) {std::cout << "组长审批通过：" << request.getReason() << std::endl;} else if (m_next) {std::cout << "组长无权限，转交经理..." << std::endl;m_next->processRequest(request);} else {std::cout << "无人能处理此请求！" << std::endl;}}
};

2.2 两种工作模式：快递派送 vs 急诊分诊

职责链有两种主要的工作方式：

🚚 模式一：快递派送式（纯职责链）

  • 请求必须被处理，不能中途丢弃
  • 就像快递，一定要送到收件人手中
  • 链的末端必须有"默认处理者"

🏥 模式二：急诊分诊式（不纯职责链）

  • 请求可能不被任何处理者处理
  • 就像急诊病人，如果病情太轻可能被建议去普通门诊
  • 更灵活，更符合现实场景

第三章：实战演练——构建真实的职责链系统

3.1 案例一：智能客服系统

让我们构建一个智能客服系统，看看职责链模式如何让客服变得更聪明：

#include <iostream>
#include <memory>
#include <string>
#include <vector>// 客户问题类
class CustomerProblem {
public:enum ProblemType { BILLING, TECHNICAL, COMPLAINT, GENERAL };CustomerProblem(ProblemType type, const std::string& description, int priority = 1): m_type(type), m_description(description), m_priority(priority) {}ProblemType getType() const { return m_type; }std::string getDescription() const { return m_description; }int getPriority() const { return m_priority; }private:ProblemType m_type;std::string m_description;int m_priority;
};// 智能客服处理者基类
class CustomerServiceHandler {
public:virtual ~CustomerServiceHandler() = default;void setNextHandler(std::shared_ptr<CustomerServiceHandler> next) {m_nextHandler = next;}virtual bool canHandle(const CustomerProblem& problem) = 0;virtual void handleProblem(const CustomerProblem& problem) = 0;void process(const CustomerProblem& problem) {if (canHandle(problem)) {std::cout << "【" << getHandlerName() << "】接手处理..." << std::endl;handleProblem(problem);std::cout << "问题处理完成！" << std::endl;} else if (m_nextHandler) {std::cout << "【" << getHandlerName() << "】无法处理，转交下一环节..." << std::endl;m_nextHandler->process(problem);} else {std::cout << "很抱歉，目前无法处理您的问题，已记录并转交专家团队。" << std::endl;}}virtual std::string getHandlerName() const = 0;protected:std::shared_ptr<CustomerServiceHandler> m_nextHandler;
};// 具体处理者：智能语音助手
class VoiceAssistant : public CustomerServiceHandler {
public:bool canHandle(const CustomerProblem& problem) override {// 语音助手只能处理简单常规问题return problem.getType() == CustomerProblem::GENERAL && problem.getPriority() <= 2;}void handleProblem(const CustomerProblem& problem) override {std::cout << "语音助手：正在为您查询解决方案..." << std::endl;// 模拟处理逻辑if (problem.getDescription().find("营业时间") != std::string::npos) {std::cout << "语音助手：我们的营业时间是每天9:00-18:00" << std::endl;} else if (problem.getDescription().find("地址") != std::string::npos) {std::cout << "语音助手：公司地址是北京市海淀区中关村大街1号" << std::endl;} else {std::cout << "语音助手：根据您的问题，我建议您..." << std::endl;}}std::string getHandlerName() const override { return "智能语音助手"; }
};// 具体处理者：在线客服
class OnlineAgent : public CustomerServiceHandler {
public:bool canHandle(const CustomerProblem& problem) override {// 在线客服处理技术问题和普通投诉return (problem.getType() == CustomerProblem::TECHNICAL && problem.getPriority() <= 4) ||(problem.getType() == CustomerProblem::COMPLAINT && problem.getPriority() <= 3);}void handleProblem(const CustomerProblem& problem) override {std::cout << "在线客服：您好，请问有什么可以帮您？" << std::endl;if (problem.getType() == CustomerProblem::TECHNICAL) {std::cout << "在线客服：正在分析您的技术问题..." << std::endl;std::cout << "在线客服：建议您尝试重启设备，如果问题依旧存在，我们将远程协助。" << std::endl;} else {std::cout << "在线客服：非常抱歉给您带来不便，我们将立即处理您的投诉。" << std::endl;}}std::string getHandlerName() const override { return "在线客服"; }
};// 具体处理者：专家团队
class ExpertTeam : public CustomerServiceHandler {
public:bool canHandle(const CustomerProblem& problem) override {// 专家团队处理所有复杂问题return problem.getPriority() >= 4 || problem.getType() == CustomerProblem::BILLING;}void handleProblem(const CustomerProblem& problem) override {std::cout << "专家团队：问题已接收，专家正在分析..." << std::endl;switch (problem.getType()) {case CustomerProblem::BILLING:std::cout << "专家团队：财务专家正在核对您的账单..." << std::endl;break;case CustomerProblem::TECHNICAL:std::cout << "专家团队：技术专家正在深度排查..." << std::endl;break;case CustomerProblem::COMPLAINT:std::cout << "专家团队：客户关系专家正在处理您的投诉..." << std::endl;break;default:std::cout << "专家团队：正在研究解决方案..." << std::endl;}std::cout << "专家团队：问题已解决，稍后会有专人回访。" << std::endl;}std::string getHandlerName() const override { return "专家团队"; }
};// 客服系统管理器
class CustomerServiceSystem {
public:CustomerServiceSystem() {// 构建职责链：语音助手 -> 在线客服 -> 专家团队m_handlers.push_back(std::make_shared<VoiceAssistant>());m_handlers.push_back(std::make_shared<OnlineAgent>());m_handlers.push_back(std::make_shared<ExpertTeam>());// 设置链式关系for (size_t i = 0; i < m_handlers.size() - 1; ++i) {m_handlers[i]->setNextHandler(m_handlers[i + 1]);}}void handleCustomerProblem(const CustomerProblem& problem) {std::cout << "\n=== 客户问题处理开始 ===" << std::endl;std::cout << "问题描述：" << problem.getDescription() << std::endl;std::cout << "问题类型：" << getProblemTypeName(problem.getType()) << std::endl;std::cout << "紧急程度：" << problem.getPriority() << "/5" << std::endl;if (!m_handlers.empty()) {m_handlers[0]->process(problem);}std::cout << "=== 处理流程结束 ===\n" << std::endl;}private:std::string getProblemTypeName(CustomerProblem::ProblemType type) {switch (type) {case CustomerProblem::BILLING: return "账单问题";case CustomerProblem::TECHNICAL: return "技术问题";case CustomerProblem::COMPLAINT: return "投诉建议";case CustomerProblem::GENERAL: return "常规咨询";default: return "未知类型";}}std::vector<std::shared_ptr<CustomerServiceHandler>> m_handlers;
};// 测试客户端
int main() {std::cout << "🤖 智能客服系统启动..." << std::endl;std::cout << "=========================================" << std::endl;CustomerServiceSystem css;// 模拟各种客户问题std::cout << "客户1：我想知道你们的营业时间？" << std::endl;css.handleCustomerProblem(CustomerProblem(CustomerProblem::GENERAL, "请问你们的营业时间是？", 1));std::cout << "客户2：我的账户无法登录，提示密码错误！" << std::endl;css.handleCustomerProblem(CustomerProblem(CustomerProblem::TECHNICAL, "账户登录失败，密码错误", 3));std::cout << "客户3：我的账单有严重错误，多扣了5000元！" << std::endl;css.handleCustomerProblem(CustomerProblem(CustomerProblem::BILLING, "账单错误，多扣款5000元", 5));std::cout << "客户4：我要投诉！产品质量太差了！" << std::endl;css.handleCustomerProblem(CustomerProblem(CustomerProblem::COMPLAINT, "产品质量差，要求退货赔偿", 4));return 0;
}

运行这个系统，你会看到每个问题如何像流水一样在职责链上流动，直到找到最合适的处理者。

3.2 案例二：游戏中的事件处理系统

游戏开发是职责链模式的另一个绝佳应用场景。想象一个角色扮演游戏中的事件处理：

#include <iostream>
#include <memory>
#include <string>
#include <vector>// 游戏事件类
class GameEvent {
public:enum EventType { KEYBOARD_INPUT,    // 键盘输入MOUSE_CLICK,       // 鼠标点击COLLISION,         // 碰撞检测AI_EVENT,          // AI事件UI_EVENT           // 界面事件};GameEvent(EventType type, const std::string& data, int priority = 1): m_type(type), m_data(data), m_priority(priority), m_handled(false) {}EventType getType() const { return m_type; }std::string getData() const { return m_data; }int getPriority() const { return m_priority; }bool isHandled() const { return m_handled; }void markHandled() { m_handled = true; }private:EventType m_type;std::string m_data;int m_priority;bool m_handled;
};// 游戏事件处理器基类
class EventHandler {
public:virtual ~EventHandler() = default;void setNextHandler(std::shared_ptr<EventHandler> next) {m_nextHandler = next;}virtual bool canHandle(const GameEvent& event) = 0;virtual void handleEvent(GameEvent& event) = 0;void processEvent(GameEvent& event) {if (event.isHandled()) {return; // 事件已被处理，停止传递}if (canHandle(event)) {std::cout << "【" << getHandlerName() << "】处理事件..." << std::endl;handleEvent(event);event.markHandled();} else if (m_nextHandler) {m_nextHandler->processEvent(event);}// 如果无人处理，事件会被忽略（比如不重要的背景事件）}virtual std::string getHandlerName() const = 0;protected:std::shared_ptr<EventHandler> m_nextHandler;
};// 具体处理器：UI事件处理器
class UIEventHandler : public EventHandler {
public:bool canHandle(const GameEvent& event) override {return event.getType() == GameEvent::UI_EVENT;}void handleEvent(GameEvent& event) override {std::cout << "UI处理器：更新界面元素 - " << event.getData() << std::endl;// 实际游戏中会更新按钮状态、显示提示等}std::string getHandlerName() const override { return "UI事件处理器"; }
};// 具体处理器：玩家输入处理器
class InputHandler : public EventHandler {
public:bool canHandle(const GameEvent& event) override {return event.getType() == GameEvent::KEYBOARD_INPUT || event.getType() == GameEvent::MOUSE_CLICK;}void handleEvent(GameEvent& event) override {if (event.getType() == GameEvent::KEYBOARD_INPUT) {std::cout << "输入处理器：处理键盘输入 - " << event.getData() << std::endl;// 处理移动、技能释放等} else {std::cout << "输入处理器：处理鼠标点击 - " << event.getData() << std::endl;// 处理物品选择、目标选择等}}std::string getHandlerName() const override { return "输入处理器"; }
};// 具体处理器：物理引擎处理器
class PhysicsHandler : public EventHandler {
public:bool canHandle(const GameEvent& event) override {return event.getType() == GameEvent::COLLISION;}void handleEvent(GameEvent& event) override {std::cout << "物理处理器：处理碰撞 - " << event.getData() << std::endl;// 计算碰撞反应、物理效果等}std::string getHandlerName() const override { return "物理处理器"; }
};// 具体处理器：AI处理器
class AIHandler : public EventHandler {
public:bool canHandle(const GameEvent& event) override {return event.getType() == GameEvent::AI_EVENT;}void handleEvent(GameEvent& event) override {std::cout << "AI处理器：处理AI行为 - " << event.getData() << std::endl;// 处理NPC决策、敌人AI等}std::string getHandlerName() const override { return "AI处理器"; }
};// 游戏事件管理器
class GameEventManager {
public:GameEventManager() {// 构建职责链：UI -> 输入 -> 物理 -> AI// 注意顺序很重要：UI事件优先，AI事件最后m_handlers.push_back(std::make_shared<UIEventHandler>());m_handlers.push_back(std::make_shared<InputHandler>());m_handlers.push_back(std::make_shared<PhysicsHandler>());m_handlers.push_back(std::make_shared<AIHandler>());// 设置链式关系for (size_t i = 0; i < m_handlers.size() - 1; ++i) {m_handlers[i]->setNextHandler(m_handlers[i + 1]);}}void dispatchEvent(GameEvent& event) {std::cout << "\n🎮 分发游戏事件：" << getEventTypeName(event.getType()) << std::endl;std::cout << "事件数据：" << event.getData() << std::endl;if (!m_handlers.empty()) {m_handlers[0]->processEvent(event);}if (event.isHandled()) {std::cout << "✅ 事件处理完成" << std::endl;} else {std::cout << "⚠️  事件未被处理（可能是背景事件）" << std::endl;}}private:std::string getEventTypeName(GameEvent::EventType type) {switch (type) {case GameEvent::KEYBOARD_INPUT: return "键盘输入";case GameEvent::MOUSE_CLICK: return "鼠标点击";case GameEvent::COLLISION: return "碰撞事件";case GameEvent::AI_EVENT: return "AI事件";case GameEvent::UI_EVENT: return "UI事件";default: return "未知事件";}}std::vector<std::shared_ptr<EventHandler>> m_handlers;
};// 游戏主循环模拟
int main() {std::cout << "🎮 游戏事件系统启动..." << std::endl;std::cout << "=========================================" << std::endl;GameEventManager eventManager;// 模拟游戏中的各种事件std::cout << "帧1：玩家按下W键（移动）" << std::endl;GameEvent event1(GameEvent::KEYBOARD_INPUT, "Key_W Pressed");eventManager.dispatchEvent(event1);std::cout << "\n帧2：玩家点击商店按钮" << std::endl;GameEvent event2(GameEvent::MOUSE_CLICK, "Shop_Button Clicked");eventManager.dispatchEvent(event2);std::cout << "\n帧3：玩家与墙壁碰撞" << std::endl;GameEvent event3(GameEvent::COLLISION, "Player-Wall Collision");eventManager.dispatchEvent(event3);std::cout << "\n帧4：敌人AI决策" << std::endl;GameEvent event4(GameEvent::AI_EVENT, "Enemy_001 Decision");eventManager.dispatchEvent(event4);std::cout << "\n帧5：血量条更新" << std::endl;GameEvent event5(GameEvent::UI_EVENT, "Health_Bar Update");eventManager.dispatchEvent(event5);return 0;
}

这个游戏事件系统展示了职责链模式在实时系统中的强大能力。每个事件自动找到合适的处理器，让游戏逻辑清晰有序。

第四章：高级技巧——让职责链更智能

4.1 动态链构建：可插拔的处理器

职责链最强大的特性之一是可以在运行时动态调整。就像乐高积木，你可以随时添加、移除或重新排列处理器：

class DynamicHandlerChain {
private:std::vector<std::shared_ptr<EventHandler>> m_handlers;public:// 添加处理器（支持多种方式）void addHandler(std::shared_ptr<EventHandler> handler) {m_handlers.push_back(handler);rebuildChain();}void insertHandler(int index, std::shared_ptr<EventHandler> handler) {if (index >= 0 && index <= m_handlers.size()) {m_handlers.insert(m_handlers.begin() + index, handler);rebuildChain();}}// 移除处理器void removeHandler(const std::string& handlerName) {m_handlers.erase(std::remove_if(m_handlers.begin(), m_handlers.end(),[&](auto& handler) { return handler->getHandlerName() == handlerName; }),m_handlers.end());rebuildChain();}// 启用/禁用处理器void setHandlerEnabled(const std::string& handlerName, bool enabled) {for (auto& handler : m_handlers) {if (handler->getHandlerName() == handlerName) {// 假设处理器有enable/disable方法// handler->setEnabled(enabled);}}}// 重新构建链式关系void rebuildChain() {for (size_t i = 0; i < m_handlers.size(); ++i) {if (i < m_handlers.size() - 1) {m_handlers[i]->setNextHandler(m_handlers[i + 1]);} else {m_handlers[i]->setNextHandler(nullptr);}}}
};

4.2 短路机制与条件传递

有时候，我们希望在某些条件下中断链条的传递：

class ConditionalHandler : public EventHandler {
public:void processEvent(GameEvent& event) override {if (event.isHandled()) {return; // 已处理，直接返回}if (!shouldProcess(event)) {// 不满足处理条件，直接传递给下一个if (m_nextHandler) {m_nextHandler->processEvent(event);}return;}if (canHandle(event)) {handleEvent(event);event.markHandled();// 处理完成后，根据条件决定是否继续传递if (shouldContinuePropagation(event)) {if (m_nextHandler) {m_nextHandler->processEvent(event);}}} else if (m_nextHandler) {m_nextHandler->processEvent(event);}}protected:virtual bool shouldProcess(const GameEvent& event) {// 默认所有事件都处理return true;}virtual bool shouldContinuePropagation(const GameEvent& event) {// 默认处理完成后停止传递return false;}
};

第五章：现实世界的职责链模式

5.1 在Web开发中的应用：中间件管道

现代Web框架（如Express.js、Spring MVC）广泛使用职责链模式：

// Express.js 中间件链
app.use(express.json());          // 解析JSON
app.use(express.urlencoded());    // 解析表单数据
app.use(cors());                  // 处理跨域
app.use(authMiddleware);          // 身份验证
app.use(loggingMiddleware);       // 日志记录
app.use(routes);                  // 路由处理// 每个中间件都像职责链中的一个处理器
function authMiddleware(req, res, next) {if (!req.headers.authorization) {return res.status(401).send('Unauthorized'); // 中断链}next(); // 传递给下一个中间件
}

5.2 在GUI框架中的应用：事件冒泡

图形界面框架中的事件处理也是职责链的典型应用：

// Java Swing 事件处理
button.addActionListener(e -> {// 按钮自身处理
});panel.addMouseListener(new MouseAdapter() {// 面板处理鼠标事件
});frame.addWindowListener(new WindowAdapter() {// 窗口处理窗口事件
});// 事件沿着组件树冒泡：按钮 → 面板 → 窗口

第六章：最佳实践与陷阱规避

6.1 职责链模式的黄金法则

✅ 该用的时候：

  • 多个对象可以处理同一请求，但具体处理者在运行时确定
  • 想在不明确指定接收者的情况下向多个对象发送请求
  • 需要动态指定处理者集合

❌ 不该用的时候：

  • 每个请求只能有一个处理者时
  • 客户端必须知道具体的处理者时
  • 处理顺序固定且不会改变时

6.2 常见陷阱及解决方案

陷阱1：无限循环

// 错误：处理器相互引用
handlerA.setNext(handlerB);
handlerB.setNext(handlerA); // 循环引用！// 正确：单向链状结构
handlerA.setNext(handlerB);
handlerB.setNext(handlerC);

陷阱2：性能问题

// 优化：缓存处理能力判断
class OptimizedHandler : public Handler {
private:std::unordered_map<std::string, bool> m_cache;public:bool canHandle(const Request& request) override {auto key = request.getType() + std::to_string(request.getPriority());if (m_cache.find(key) != m_cache.end()) {return m_cache[key];}bool result = // 复杂的判断逻辑m_cache[key] = result;return result;}
};

第七章：总结与展望

7.1 职责链模式的价值

职责链模式就像是一个精密的请求分拣系统，它带来的价值是巨大的：

  1. 降低耦合度：发送者不需要知道具体的接收者
  2. 增强灵活性：可以动态调整处理流程
  3. 简化代码：避免了复杂的条件判断语句
  4. 便于扩展：新增处理者非常容易

7.2 未来的发展方向

随着微服务和云原生架构的流行，职责链模式在新的领域大放异彩：

  • 服务网格：Envoy、Linkerd中的过滤器链
  • API网关：请求处理管道
  • 工作流引擎：任务执行链
  • 数据流水线：ETL处理流程

7.3 最后的思考

职责链模式教会我们一个重要的人生哲理：不是所有问题都需要你亲自解决。学会把问题传递给合适的人，既是编程的智慧，也是生活的智慧。

就像一支优秀的足球队，每个球员各司其职，通过精准的传球（请求传递）最终完成射门（问题解决）。职责链模式就是软件世界中的"团队配合"，让代码像冠军球队一样高效运转。

希望这次生动的旅程让你对职责链模式有了更深的理解和喜爱。下次当你看到流水线作业或者公司审批流程时，你会会心一笑：“看，这就是职责链模式在现实生活中的体现！”

记住，好的设计模式就像是烹饪中的秘方，掌握了它，你就能做出更加美味可口的"代码大餐"！🍳💻

“优秀的软件设计不是创建完美的系统，而是创建能够优雅演化的系统。” - 匿名

http://www.dtcms.com/a/399146.html

相关文章：

  • 群辉nas怎么做网站品牌推广服务
  • 【RabbitMQ】RabbitMQ核心机制
  • 网站开发软件三剑客wordpress分享可见
  • GelSight Modulus 触觉型3D轮廓仪助力航空航天精密检测
  • 北京 旅游攻略 颐和园(第一天下午逛) 长城最后一天早上逛 如果到北京早 也可以第一天长城
  • 网站的做用百度做网站按点击量收费吗
  • 程序的流程方式
  • python做网站验证码常州如何进行网站推广
  • C#语法回忆零散巩固（持续更新最新版）
  • MySQL数据库——11.2事务-隔离
  • 新能源知识库（108）AGC/AVC调度算法介绍
  • cocos 零基础入门学习笔记
  • 红安城市建设局投诉网站网页设计作品欣赏分析
  • 服务器网站后台登陆密码黄框显示南沙外贸网站建设
  • 超细整理，保险项目-性能测试bug+吞吐量+并发用户数分析（详细）
  • 英语学习-Saints012
  • 游戏要怎么防御ddos攻击
  • 【echarts】指令监听响应式尺寸变化 resize()
  • 当贝桌面 4.1.6 | 完美精简版，纯净无广，可永久使用
  • [Python编程] Python3 控制流程
  • 西安网站设计哪家公司好山东网站建设价格实惠
  • JavaScript 的作用域
  • TDengine 统计函数 APERCENTILE 用户手册
  • 【分布式】分布式ID生成方案、接口幂等、一致性哈希
  • 分布式 ID 生成方案实战指南：从选型到落地的全场景避坑手册（一）
  • 对比网站做企业网站需要用到的软件
  • HAProxy 与 Tomcat
  • Tomcat 配置与使用指南
  • 金融数据库--下载全市场可转债日线行情数据
  • 新能源知识库（105）什么是 日本JEMS平台