diff --git a/src/client/WFConsulClient.cc b/src/client/WFConsulClient.cc index 7bcf946..e0d8767 100644 --- a/src/client/WFConsulClient.cc +++ b/src/client/WFConsulClient.cc @@ -21,238 +21,291 @@ #include #include #include -#include "json_parser.h" -#include "StringUtil.h" -#include "URIParser.h" -#include "HttpUtil.h" -#include "WFConsulClient.h" +#include "json_parser.h" // JSON解析工具 +#include "StringUtil.h" // 字符串工具 +#include "URIParser.h" // URI解析工具 +#include "HttpUtil.h" // HTTP相关工具 +#include "WFConsulClient.h" // Consul客户端相关定义 -using namespace protocol; +using namespace protocol; // 使用协议相关命名空间 +// WFConsulTask 构造函数 WFConsulTask::WFConsulTask(const std::string& proxy_url, const std::string& service_namespace, const std::string& service_name, const std::string& service_id, int retry_max, consul_callback_t&& cb) : - proxy_url(proxy_url), - callback(std::move(cb)) + proxy_url(proxy_url), // 初始化代理地址 + callback(std::move(cb)) // 设置回调函数 { - this->service.service_name = service_name; - this->service.service_namespace = service_namespace; - this->service.service_id = service_id; - this->api_type = CONSUL_API_TYPE_UNKNOWN; - this->retry_max = retry_max; - this->finish = false; - this->consul_index = 0; + this->service.service_name = service_name; // 初始化服务名称 + this->service.service_namespace = service_namespace; // 初始化服务命名空间 + this->service.service_id = service_id; // 初始化服务 ID + this->api_type = CONSUL_API_TYPE_UNKNOWN; // 设置 API 类型为未知 + this->retry_max = retry_max; // 设置最大重试次数 + this->finish = false; // 标记任务未完成 + this->consul_index = 0; // 初始化 Consul 索引为 0 } +// 设置服务相关信息 void WFConsulTask::set_service(const struct protocol::ConsulService *service) { - this->service.tags = service->tags; - this->service.meta = service->meta; - this->service.tag_override = service->tag_override; - this->service.service_address = service->service_address; - this->service.lan = service->lan; - this->service.lan_ipv4 = service->lan_ipv4; - this->service.lan_ipv6 = service->lan_ipv6; - this->service.virtual_address = service->virtual_address; - this->service.wan = service->wan; - this->service.wan_ipv4 = service->wan_ipv4; - this->service.wan_ipv6 = service->wan_ipv6; + this->service.tags = service->tags; // 设置服务标签 + this->service.meta = service->meta; // 设置服务元信息 + this->service.tag_override = service->tag_override; // 设置标签覆盖标志 + this->service.service_address = service->service_address; // 设置服务地址 + this->service.lan = service->lan; // 设置本地局域网地址 + this->service.lan_ipv4 = service->lan_ipv4; // 设置 IPv4 地址 + this->service.lan_ipv6 = service->lan_ipv6; // 设置 IPv6 地址 + this->service.virtual_address = service->virtual_address; // 设置虚拟地址 + this->service.wan = service->wan; // 设置广域网地址 + this->service.wan_ipv4 = service->wan_ipv4; // 设置 IPv4 地址 + this->service.wan_ipv6 = service->wan_ipv6; // 设置 IPv6 地址 } + +// 解析服务发现结果的静态函数 static bool parse_discover_result(const json_value_t *root, std::vector& result); + +// 解析服务列表结果的静态函数 static bool parse_list_service_result(const json_value_t *root, std::vector& result); + +// 获取服务发现结果 bool WFConsulTask::get_discover_result( std::vector& result) { - json_value_t *root; - int errno_bak; - bool ret; + json_value_t *root; // JSON 根节点 + int errno_bak; // 备份当前 errno 值 + bool ret; // 返回结果标志 + // 检查当前 API 类型是否为服务发现 if (this->api_type != CONSUL_API_TYPE_DISCOVER) { - errno = EPERM; - return false; + errno = EPERM; // 设置权限错误 + return false; // 返回失败 } - errno_bak = errno; - errno = EBADMSG; - std::string body = HttpUtil::decode_chunked_body(&this->http_resp); - root = json_value_parse(body.c_str()); - if (!root) - return false; + errno_bak = errno; // 备份 errno + errno = EBADMSG; // 设置消息错误 + std::string body = HttpUtil::decode_chunked_body(&this->http_resp); // 解码 HTTP 响应的分块数据 + root = json_value_parse(body.c_str()); // 解析 JSON 数据 + if (!root) // 如果解析失败 + return false; // 返回失败 - ret = parse_discover_result(root, result); - json_value_destroy(root); - if (ret) - errno = errno_bak; + ret = parse_discover_result(root, result); // 解析服务发现结果 + json_value_destroy(root); // 销毁 JSON 对象 + if (ret) // 如果解析成功 + errno = errno_bak; // 恢复原始 errno - return ret; + return ret; // 返回解析结果 } + +// 获取服务列表结果 bool WFConsulTask::get_list_service_result( std::vector& result) { - json_value_t *root; - int errno_bak; - bool ret; + json_value_t *root; // JSON 根节点 + int errno_bak; // 备份当前 errno 值 + bool ret; // 返回结果标志 + // 检查当前 API 类型是否为服务列表 if (this->api_type != CONSUL_API_TYPE_LIST_SERVICE) { - errno = EPERM; - return false; + errno = EPERM; // 设置权限错误 + return false; // 返回失败 } - errno_bak = errno; - errno = EBADMSG; - std::string body = HttpUtil::decode_chunked_body(&this->http_resp); - root = json_value_parse(body.c_str()); - if (!root) - return false; + errno_bak = errno; // 备份 errno + errno = EBADMSG; // 设置消息错误 + std::string body = HttpUtil::decode_chunked_body(&this->http_resp); // 解码 HTTP 响应的分块数据 + root = json_value_parse(body.c_str()); // 解析 JSON 数据 + if (!root) // 如果解析失败 + return false; // 返回失败 - ret = parse_list_service_result(root, result); - json_value_destroy(root); - if (ret) - errno = errno_bak; + ret = parse_list_service_result(root, result); // 解析服务列表结果 + json_value_destroy(root); // 销毁 JSON 对象 + if (ret) // 如果解析成功 + errno = errno_bak; // 恢复原始 errno - return ret; + return ret; // 返回解析结果 } + +// 分发任务，根据 API 类型选择相应的任务处理逻辑 void WFConsulTask::dispatch() { - WFHttpTask *task; + WFHttpTask *task; // 定义 HTTP 任务指针 - if (this->finish) + if (this->finish) // 如果任务已完成 { - this->subtask_done(); - return; + this->subtask_done(); // 标记子任务完成 + return; // 退出 } + // 根据 API 类型选择处理任务 switch(this->api_type) { - case CONSUL_API_TYPE_DISCOVER: - task = create_discover_task(); + case CONSUL_API_TYPE_DISCOVER: // 如果是服务发现任务 + task = create_discover_task(); // 创建服务发现任务 break; - case CONSUL_API_TYPE_LIST_SERVICE: - task = create_list_service_task(); + case CONSUL_API_TYPE_LIST_SERVICE: // 如果是服务列表任务 + task = create_list_service_task(); // 创建服务列表任务 break; - case CONSUL_API_TYPE_DEREGISTER: - task = create_deregister_task(); + case CONSUL_API_TYPE_DEREGISTER: // 如果是注销服务任务 + task = create_deregister_task(); // 创建注销服务任务 break; - case CONSUL_API_TYPE_REGISTER: - task = create_register_task(); + case CONSUL_API_TYPE_REGISTER: // 如果是注册服务任务 + task = create_register_task(); // 创建注册服务任务 if (task) break; + // 如果任务创建失败，设置错误状态 if (1) { - this->state = WFT_STATE_SYS_ERROR; - this->error = errno; + this->state = WFT_STATE_SYS_ERROR; // 设置系统错误状态 + this->error = errno; // 设置错误码 } else { default: - this->state = WFT_STATE_TASK_ERROR; - this->error = WFT_ERR_CONSUL_API_UNKNOWN; + this->state = WFT_STATE_TASK_ERROR; // 设置任务错误状态 + this->error = WFT_ERR_CONSUL_API_UNKNOWN; // 设置未知 API 错误 } - this->finish = true; - this->subtask_done(); + this->finish = true; // 标记任务完成 + this->subtask_done(); // 标记子任务完成 return; } - series_of(this)->push_front(this); - series_of(this)->push_front(task); - this->subtask_done(); + // 将任务插入到工作队列 + series_of(this)->push_front(this); // 将当前任务加入队列 + series_of(this)->push_front(task); // 将新任务加入队列 + this->subtask_done(); // 标记子任务完成 } + +// 标记任务完成，并执行回调或清理逻辑 SubTask *WFConsulTask::done() { - SeriesWork *series = series_of(this); + SeriesWork *series = series_of(this); // 获取当前任务的工作队列 - if (finish) + if (finish) // 如果任务已完成 { - if (this->callback) - this->callback(this); + if (this->callback) // 如果有回调函数 + this->callback(this); // 执行回调函数 - delete this; + delete this; // 删除任务对象 } - return series->pop(); + return series->pop(); // 从队列中弹出任务 } + +// 将毫秒时间转换为字符串形式（如 "5s" 或 "3m"） static std::string convert_time_to_str(int milliseconds) { - std::string str_time; - int seconds = milliseconds / 1000; + std::string str_time; // 保存时间字符串 + int seconds = milliseconds / 1000; // 将毫秒转换为秒 - if (seconds >= 180) - str_time = std::to_string(seconds / 60) + "m"; + if (seconds >= 180) // 如果时间超过 3 分钟 + str_time = std::to_string(seconds / 60) + "m"; // 转换为分钟形式 else - str_time = std::to_string(seconds) + "s"; + str_time = std::to_string(seconds) + "s"; // 转换为秒形式 - return str_time; + return str_time; // 返回时间字符串 } + +// 生成服务发现请求的 URL std::string WFConsulTask::generate_discover_request() { - std::string url = this->proxy_url; + std::string url = this->proxy_url; // 初始化 URL 为代理地址 + // 添加服务健康检查路径 url += "/v1/health/service/" + this->service.service_name; + + // 添加数据中心参数 url += "?dc=" + this->config.get_datacenter(); + + // 添加服务命名空间参数 url += "&ns=" + this->service.service_namespace; + + // 获取 passing 参数值，表示是否仅返回通过健康检查的服务实例 std::string passing = this->config.get_passing() ? "true" : "false"; - url += "&passing=" + passing; + url += "&passing=" + passing; // 添加 passing 参数 + + // 添加 token 参数用于鉴权 url += "&token=" + this->config.get_token(); + + // 添加过滤表达式参数 url += "&filter=" + this->config.get_filter_expr(); - //consul blocking query + // 检查是否启用 Consul 阻塞查询 if (this->config.blocking_query()) { + // 添加索引参数，用于阻塞查询的初始状态 url += "&index=" + std::to_string(this->get_consul_index()); + + // 添加等待时间参数，表示阻塞查询的超时时间 url += "&wait=" + convert_time_to_str(this->config.get_wait_ttl()); } - return url; + return url; // 返回生成的 URL } + +// 创建服务发现任务 WFHttpTask *WFConsulTask::create_discover_task() { - std::string url = generate_discover_request(); - WFHttpTask *task = WFTaskFactory::create_http_task(url, 0, this->retry_max, - discover_callback); - HttpRequest *req = task->get_req(); + std::string url = generate_discover_request(); // 调用生成服务发现 URL 的函数 + WFHttpTask *task = WFTaskFactory::create_http_task( // 创建 HTTP 任务 + url, 0, this->retry_max, discover_callback); + HttpRequest *req = task->get_req(); // 获取 HTTP 请求对象 + + // 添加 HTTP 请求头，指定内容类型为 JSON req->add_header_pair("Content-Type", "application/json"); - task->user_data = this; - return task; + + task->user_data = this; // 设置用户数据为当前任务对象 + return task; // 返回创建的任务 } + +// 创建服务列表任务 WFHttpTask *WFConsulTask::create_list_service_task() { - std::string url = this->proxy_url; + std::string url = this->proxy_url; // 初始化 URL 为代理地址 + // 添加服务目录路径和鉴权 token url += "/v1/catalog/services?token=" + this->config.get_token(); + + // 添加数据中心参数 url += "&dc=" + this->config.get_datacenter(); + + // 添加服务命名空间参数 url += "&ns=" + this->service.service_namespace; - - WFHttpTask *task = WFTaskFactory::create_http_task(url, 0, this->retry_max, - list_service_callback); - HttpRequest *req = task->get_req(); + WFHttpTask *task = WFTaskFactory::create_http_task( // 创建 HTTP 任务 + url, 0, this->retry_max, list_service_callback); + + HttpRequest *req = task->get_req(); // 获取 HTTP 请求对象 + + // 添加 HTTP 请求头，指定内容类型为 JSON req->add_header_pair("Content-Type", "application/json"); - task->user_data = this; - return task; + + task->user_data = this; // 设置用户数据为当前任务对象 + return task; // 返回创建的任务 } + static void print_json_value(const json_value_t *val, int depth, std::string& json_str); @@ -260,290 +313,365 @@ static bool create_register_request(const json_value_t *root, const struct ConsulService *service, const ConsulConfig& config); +// 创建服务注册任务 WFHttpTask *WFConsulTask::create_register_task() { - std::string payload; + std::string payload; // 定义用于存储请求体的字符串 - std::string url = this->proxy_url; + std::string url = this->proxy_url; // 初始化 URL 为代理地址 + // 添加服务注册路径和替换检查选项 url += "/v1/agent/service/register?replace-existing-checks="; url += this->config.get_replace_checks() ? "true" : "false"; - WFHttpTask *task = WFTaskFactory::create_http_task(url, 0, this->retry_max, - register_callback); - HttpRequest *req = task->get_req(); + WFHttpTask *task = WFTaskFactory::create_http_task( // 创建 HTTP 任务 + url, 0, this->retry_max, register_callback); - req->set_method(HttpMethodPut); - req->add_header_pair("Content-Type", "application/json"); + HttpRequest *req = task->get_req(); // 获取 HTTP 请求对象 + + req->set_method(HttpMethodPut); // 设置 HTTP 方法为 PUT + req->add_header_pair("Content-Type", "application/json"); // 添加内容类型头 + // 如果存在鉴权 token，则添加到请求头 if (!this->config.get_token().empty()) req->add_header_pair("X-Consul-Token", this->config.get_token()); - json_value_t *root = json_value_create(JSON_VALUE_OBJECT); - if (root) + json_value_t *root = json_value_create(JSON_VALUE_OBJECT); // 创建 JSON 对象根节点 + if (root) // 如果创建成功 { + // 构建服务注册请求 JSON 数据 if (create_register_request(root, &this->service, this->config)) - print_json_value(root, 0, payload); + print_json_value(root, 0, payload); // 将 JSON 数据转为字符串 - json_value_destroy(root); + json_value_destroy(root); // 销毁 JSON 对象 + // 如果请求体不为空且追加到请求成功 if (!payload.empty() && req->append_output_body(payload)) { - task->user_data = this; - return task; + task->user_data = this; // 设置用户数据为当前任务对象 + return task; // 返回创建的任务 } } - task->dismiss(); - return NULL; + task->dismiss(); // 如果失败，销毁任务 + return NULL; // 返回空指针 } + +// 创建服务注销任务 WFHttpTask *WFConsulTask::create_deregister_task() { - std::string url = this->proxy_url; + std::string url = this->proxy_url; // 初始化 URL 为代理地址 + // 添加服务注销路径，包含服务 ID 和命名空间参数 url += "/v1/agent/service/deregister/" + this->service.service_id; url += "?ns=" + this->service.service_namespace; - WFHttpTask *task = WFTaskFactory::create_http_task(url, 0, this->retry_max, - register_callback); - HttpRequest *req = task->get_req(); + WFHttpTask *task = WFTaskFactory::create_http_task( // 创建 HTTP 任务 + url, 0, this->retry_max, register_callback); - req->set_method(HttpMethodPut); - req->add_header_pair("Content-Type", "application/json"); + HttpRequest *req = task->get_req(); // 获取 HTTP 请求对象 + req->set_method(HttpMethodPut); // 设置 HTTP 方法为 PUT + req->add_header_pair("Content-Type", "application/json"); // 添加内容类型头 + + // 如果存在鉴权 token，则添加到请求头 std::string token = this->config.get_token(); if (!token.empty()) req->add_header_pair("X-Consul-Token", token); - task->user_data = this; - return task; + task->user_data = this; // 设置用户数据为当前任务对象 + return task; // 返回创建的任务 } + +// 检查任务执行结果 bool WFConsulTask::check_task_result(WFHttpTask *task, WFConsulTask *consul_task) { + // 如果任务状态不是成功状态 if (task->get_state() != WFT_STATE_SUCCESS) { - consul_task->state = task->get_state(); - consul_task->error = task->get_error(); - return false; + consul_task->state = task->get_state(); // 设置任务状态 + consul_task->error = task->get_error(); // 设置错误信息 + return false; // 返回失败 } + // 获取任务的 HTTP 响应 protocol::HttpResponse *resp = task->get_resp(); + + // 检查 HTTP 响应状态码是否为 "200" if (strcmp(resp->get_status_code(), "200") != 0) { - consul_task->state = WFT_STATE_TASK_ERROR; - consul_task->error = WFT_ERR_CONSUL_CHECK_RESPONSE_FAILED; - return false; + consul_task->state = WFT_STATE_TASK_ERROR; // 设置任务错误状态 + consul_task->error = WFT_ERR_CONSUL_CHECK_RESPONSE_FAILED; // 设置响应失败错误 + return false; // 返回失败 } - return true; + return true; // 返回成功 } + +// 从 HTTP 响应头中获取 Consul 索引 long long WFConsulTask::get_consul_index(HttpResponse *resp) { - long long consul_index = 0; + long long consul_index = 0; // 初始化 Consul 索引为 0 - // get consul-index from http header + // 创建 HTTP 头游标以遍历响应头 protocol::HttpHeaderCursor cursor(resp); - std::string consul_index_str; + std::string consul_index_str; // 用于存储 Consul 索引字符串 + + // 查找 "X-Consul-Index" 响应头 if (cursor.find("X-Consul-Index", consul_index_str)) { + // 将字符串转换为长整型 consul_index = strtoll(consul_index_str.c_str(), NULL, 10); - if (consul_index < 0) + if (consul_index < 0) // 如果索引小于 0，则重置为 0 consul_index = 0; } - return consul_index; + return consul_index; // 返回 Consul 索引 } + +// 服务发现任务的回调函数 void WFConsulTask::discover_callback(WFHttpTask *task) { - WFConsulTask *t = (WFConsulTask*)task->user_data; + WFConsulTask *t = (WFConsulTask*)task->user_data; // 获取任务的用户数据 + // 检查任务执行结果 if (WFConsulTask::check_task_result(task, t)) { - protocol::HttpResponse *resp = task->get_resp(); - long long consul_index = t->get_consul_index(resp); - long long last_consul_index = t->get_consul_index(); + protocol::HttpResponse *resp = task->get_resp(); // 获取 HTTP 响应 + long long consul_index = t->get_consul_index(resp); // 获取当前 Consul 索引 + long long last_consul_index = t->get_consul_index(); // 获取上一次的 Consul 索引 + + // 更新 Consul 索引，如果当前索引小于上次索引，则重置为 0 t->set_consul_index(consul_index < last_consul_index ? 0 : consul_index); - t->state = task->get_state(); + t->state = task->get_state(); // 设置任务状态 } + // 将 HTTP 响应转移到任务对象 t->http_resp = std::move(*task->get_resp()); - t->finish = true; + t->finish = true; // 标记任务完成 } + +// 服务列表任务的回调函数 void WFConsulTask::list_service_callback(WFHttpTask *task) { - WFConsulTask *t = (WFConsulTask*)task->user_data; + WFConsulTask *t = (WFConsulTask*)task->user_data; // 获取任务的用户数据 + // 检查任务执行结果 if (WFConsulTask::check_task_result(task, t)) - t->state = task->get_state(); + t->state = task->get_state(); // 设置任务状态 + // 将 HTTP 响应转移到任务对象 t->http_resp = std::move(*task->get_resp()); - t->finish = true; + t->finish = true; // 标记任务完成 } + +// 服务注册任务的回调函数 void WFConsulTask::register_callback(WFHttpTask *task) { - WFConsulTask *t = (WFConsulTask *)task->user_data; + WFConsulTask *t = (WFConsulTask *)task->user_data; // 获取任务的用户数据 + // 检查任务执行结果 if (WFConsulTask::check_task_result(task, t)) - t->state = task->get_state(); + t->state = task->get_state(); // 设置任务状态 + // 将 HTTP 响应转移到任务对象 t->http_resp = std::move(*task->get_resp()); - t->finish = true; + t->finish = true; // 标记任务完成 } + +// 初始化 Consul 客户端 int WFConsulClient::init(const std::string& proxy_url, ConsulConfig config) { - ParsedURI uri; + ParsedURI uri; // 定义用于存储解析后的 URI 的对象 + // 解析代理 URL if (URIParser::parse(proxy_url, uri) >= 0) { + // 构建完整的代理 URL this->proxy_url = uri.scheme; this->proxy_url += "://"; this->proxy_url += uri.host; - if (uri.port) + if (uri.port) // 如果指定了端口，则追加端口信息 { this->proxy_url += ":"; this->proxy_url += uri.port; } - this->config = std::move(config); - return 0; + this->config = std::move(config); // 将配置赋值给客户端 + return 0; // 返回成功 } - else if (uri.state == URI_STATE_INVALID) - errno = EINVAL; + else if (uri.state == URI_STATE_INVALID) // 如果 URI 无效 + errno = EINVAL; // 设置错误码为无效参数 - return -1; + return -1; // 返回失败 } + +// 初始化 Consul 客户端（使用默认配置） int WFConsulClient::init(const std::string& proxy_url) { - return this->init(proxy_url, ConsulConfig()); + return this->init(proxy_url, ConsulConfig()); // 调用带配置参数的 init 函数 } + +// 创建服务发现任务 WFConsulTask *WFConsulClient::create_discover_task( - const std::string& service_namespace, - const std::string& service_name, - int retry_max, - consul_callback_t cb) + const std::string& service_namespace, + const std::string& service_name, + int retry_max, + consul_callback_t cb) { + // 创建一个新的 Consul 任务 WFConsulTask *task = new WFConsulTask(this->proxy_url, service_namespace, service_name, "", retry_max, std::move(cb)); - task->set_api_type(CONSUL_API_TYPE_DISCOVER); - task->set_config(this->config); - return task; + + task->set_api_type(CONSUL_API_TYPE_DISCOVER); // 设置任务类型为服务发现 + task->set_config(this->config); // 设置任务的配置信息 + return task; // 返回创建的任务 } + +// 创建服务列表任务 WFConsulTask *WFConsulClient::create_list_service_task( - const std::string& service_namespace, - int retry_max, - consul_callback_t cb) + const std::string& service_namespace, + int retry_max, + consul_callback_t cb) { + // 创建一个新的 Consul 任务 WFConsulTask *task = new WFConsulTask(this->proxy_url, service_namespace, "", "", retry_max, std::move(cb)); - task->set_api_type(CONSUL_API_TYPE_LIST_SERVICE); - task->set_config(this->config); - return task; + + task->set_api_type(CONSUL_API_TYPE_LIST_SERVICE); // 设置任务类型为服务列表 + task->set_config(this->config); // 设置任务的配置信息 + return task; // 返回创建的任务 } + +// 创建服务注册任务 WFConsulTask *WFConsulClient::create_register_task( - const std::string& service_namespace, - const std::string& service_name, - const std::string& service_id, - int retry_max, - consul_callback_t cb) + const std::string& service_namespace, + const std::string& service_name, + const std::string& service_id, + int retry_max, + consul_callback_t cb) { + // 创建一个新的 Consul 任务 WFConsulTask *task = new WFConsulTask(this->proxy_url, service_namespace, service_name, service_id, retry_max, std::move(cb)); - task->set_api_type(CONSUL_API_TYPE_REGISTER); - task->set_config(this->config); - return task; + + task->set_api_type(CONSUL_API_TYPE_REGISTER); // 设置任务类型为服务注册 + task->set_config(this->config); // 设置任务的配置信息 + return task; // 返回创建的任务 } + +// 创建服务注销任务 WFConsulTask *WFConsulClient::create_deregister_task( - const std::string& service_namespace, - const std::string& service_id, - int retry_max, - consul_callback_t cb) + const std::string& service_namespace, + const std::string& service_id, + int retry_max, + consul_callback_t cb) { + // 创建一个新的 Consul 任务 WFConsulTask *task = new WFConsulTask(this->proxy_url, service_namespace, "", service_id, retry_max, std::move(cb)); - task->set_api_type(CONSUL_API_TYPE_DEREGISTER); - task->set_config(this->config); - return task; + + task->set_api_type(CONSUL_API_TYPE_DEREGISTER); // 设置任务类型为服务注销 + task->set_config(this->config); // 设置任务的配置信息 + return task; // 返回创建的任务 } + +// 创建带标签的地址对象 static bool create_tagged_address(const ConsulAddress& consul_address, const std::string& name, json_object_t *tagged_obj) { + // 如果地址为空，直接返回成功 if (consul_address.first.empty()) return true; + // 向 JSON 对象中添加名为 name 的嵌套对象 const json_value_t *val = json_object_append(tagged_obj, name.c_str(), JSON_VALUE_OBJECT); - if (!val) + if (!val) // 如果添加失败，返回 false return false; + // 获取新创建的嵌套对象 json_object_t *obj = json_value_object(val); - if (!obj) + if (!obj) // 如果对象获取失败，返回 false return false; + // 向嵌套对象中添加 "Address" 字段 if (!json_object_append(obj, "Address", JSON_VALUE_STRING, consul_address.first.c_str())) return false; + // 向嵌套对象中添加 "Port" 字段 if (!json_object_append(obj, "Port", JSON_VALUE_NUMBER, (double)consul_address.second)) return false; - return true; + return true; // 地址对象创建成功 } + +// 创建健康检查配置 static bool create_health_check(const ConsulConfig& config, json_object_t *obj) { - const json_value_t *val; - std::string str; + const json_value_t *val; // 存储添加字段的返回值 + std::string str; // 临时字符串存储变量 + // 如果未启用健康检查，直接返回成功 if (!config.get_health_check()) return true; + // 在 JSON 对象中添加 "Check" 字段 val = json_object_append(obj, "Check", JSON_VALUE_OBJECT); - if (!val) + if (!val) // 如果添加失败，返回 false return false; - obj = json_value_object(val); - if (!obj) + obj = json_value_object(val); // 获取 "Check" 对象 + if (!obj) // 如果对象获取失败，返回 false return false; + // 添加健康检查的名称 str = config.get_check_name(); if (!json_object_append(obj, "Name", JSON_VALUE_STRING, str.c_str())) return false; + // 添加健康检查的备注 str = config.get_check_notes(); if (!json_object_append(obj, "Notes", JSON_VALUE_STRING, str.c_str())) return false; + // 添加健康检查的 HTTP URL str = config.get_check_http_url(); - if (!str.empty()) + if (!str.empty()) // 如果 URL 不为空 { if (!json_object_append(obj, "HTTP", JSON_VALUE_STRING, str.c_str())) return false; + // 添加 HTTP 方法 str = config.get_check_http_method(); if (!json_object_append(obj, "Method", JSON_VALUE_STRING, str.c_str())) return false; + // 添加 HTTP 请求体 str = config.get_http_body(); if (!json_object_append(obj, "Body", JSON_VALUE_STRING, str.c_str())) return false; + // 添加 HTTP 头部信息 val = json_object_append(obj, "Header", JSON_VALUE_OBJECT); if (!val) return false; @@ -552,6 +680,7 @@ static bool create_health_check(const ConsulConfig& config, json_object_t *obj) if (!header_obj) return false; + // 遍历并添加所有 HTTP 头部字段 for (const auto& header : *config.get_http_headers()) { val = json_object_append(header_obj, header.first.c_str(), @@ -563,6 +692,7 @@ static bool create_health_check(const ConsulConfig& config, json_object_t *obj) if (!arr) return false; + // 添加头部字段对应的多个值 for (const auto& value : header.second) { if (!json_array_append(arr, JSON_VALUE_STRING, value.c_str())) @@ -571,6 +701,7 @@ static bool create_health_check(const ConsulConfig& config, json_object_t *obj) } } + // 添加 TCP 检查地址 str = config.get_check_tcp(); if (!str.empty()) { @@ -578,53 +709,64 @@ static bool create_health_check(const ConsulConfig& config, json_object_t *obj) return false; } + // 添加初始状态 str = config.get_initial_status(); if (!json_object_append(obj, "Status", JSON_VALUE_STRING, str.c_str())) return false; + // 添加自动注销时间 str = convert_time_to_str(config.get_auto_deregister_time()); if (!json_object_append(obj, "DeregisterCriticalServiceAfter", JSON_VALUE_STRING, str.c_str())) return false; + // 添加检查间隔时间 str = convert_time_to_str(config.get_check_interval()); if (!json_object_append(obj, "Interval", JSON_VALUE_STRING, str.c_str())) return false; + // 添加检查超时时间 str = convert_time_to_str(config.get_check_timeout()); if (!json_object_append(obj, "Timeout", JSON_VALUE_STRING, str.c_str())) return false; + // 添加连续成功次数限制 if (!json_object_append(obj, "SuccessBeforePassing", JSON_VALUE_NUMBER, (double)config.get_success_times())) return false; + // 添加连续失败次数限制 if (!json_object_append(obj, "FailuresBeforeCritical", JSON_VALUE_NUMBER, (double)config.get_failure_times())) return false; - return true; + return true; // 健康检查配置创建成功 } + +// 创建服务注册请求 static bool create_register_request(const json_value_t *root, const struct ConsulService *service, const ConsulConfig& config) { - const json_value_t *val; - json_object_t *obj; + const json_value_t *val; // 临时存储 JSON 值 + json_object_t *obj; // 临时存储 JSON 对象 - obj = json_value_object(root); + obj = json_value_object(root); // 获取根对象 if (!obj) return false; + // 添加服务 ID if (!json_object_append(obj, "ID", JSON_VALUE_STRING, service->service_id.c_str())) return false; + // 添加服务名称 if (!json_object_append(obj, "Name", JSON_VALUE_STRING, service->service_name.c_str())) return false; + // 如果命名空间非空，则添加命名空间 if (!service->service_namespace.empty()) { if (!json_object_append(obj, "ns", JSON_VALUE_STRING, @@ -632,6 +774,7 @@ static bool create_register_request(const json_value_t *root, return false; } + // 添加服务标签数组 val = json_object_append(obj, "Tags", JSON_VALUE_ARRAY); if (!val) return false; @@ -640,20 +783,24 @@ static bool create_register_request(const json_value_t *root, if (!arr) return false; + // 遍历并添加所有标签 for (const auto& tag : service->tags) { if (!json_array_append(arr, JSON_VALUE_STRING, tag.c_str())) return false; } + // 添加服务地址 if (!json_object_append(obj, "Address", JSON_VALUE_STRING, service->service_address.first.c_str())) return false; + // 添加服务端口 if (!json_object_append(obj, "Port", JSON_VALUE_NUMBER, (double)service->service_address.second)) return false; + // 添加元数据对象 val = json_object_append(obj, "Meta", JSON_VALUE_OBJECT); if (!val) return false; @@ -662,6 +809,7 @@ static bool create_register_request(const json_value_t *root, if (!meta_obj) return false; + // 遍历并添加所有元数据 for (const auto& meta_kv : service->meta) { if (!json_object_append(meta_obj, meta_kv.first.c_str(), @@ -669,10 +817,12 @@ static bool create_register_request(const json_value_t *root, return false; } + // 添加标签覆盖选项 int type = service->tag_override ? JSON_VALUE_TRUE : JSON_VALUE_FALSE; if (!json_object_append(obj, "EnableTagOverride", type)) return false; + // 添加带标签的地址 val = json_object_append(obj, "TaggedAddresses", JSON_VALUE_OBJECT); if (!val) return false; @@ -681,6 +831,7 @@ static bool create_register_request(const json_value_t *root, if (!tagged_obj) return false; + // 创建所有类型的带标签地址 if (!create_tagged_address(service->lan, "lan", tagged_obj)) return false; @@ -702,74 +853,84 @@ static bool create_register_request(const json_value_t *root, if (!create_tagged_address(service->wan_ipv6, "wan_ipv6", tagged_obj)) return false; - // create health check + // 创建健康检查配置 if (!create_health_check(config, obj)) return false; - return true; + return true; // 服务注册请求创建成功 } + +// 解析服务列表结果 static bool parse_list_service_result(const json_value_t *root, - std::vector& result) + std::vector& result) { - const json_object_t *obj; - const json_value_t *val; - const json_array_t *arr; - const char *key; - const char *str; + const json_object_t *obj; // 存储 JSON 对象 + const json_value_t *val; // 存储 JSON 值 + const json_array_t *arr; // 存储 JSON 数组 + const char *key; // 存储键 + const char *str; // 存储字符串值 + // 将根值转换为 JSON 对象 obj = json_value_object(root); - if (!obj) + if (!obj) // 如果转换失败，返回 false return false; + // 遍历 JSON 对象中的每个键值对 json_object_for_each(key, val, obj) { - struct ConsulServiceTags instance; + struct ConsulServiceTags instance; // 定义一个服务标签实例 - instance.service_name = key; - arr = json_value_array(val); - if (!arr) + instance.service_name = key; // 将键作为服务名称 + arr = json_value_array(val); // 获取值作为数组 + if (!arr) // 如果值不是数组，返回 false return false; - const json_value_t *tag_val; + const json_value_t *tag_val; // 遍历数组的每个值 json_array_for_each(tag_val, arr) { - str = json_value_string(tag_val); - if (!str) + str = json_value_string(tag_val); // 获取值的字符串形式 + if (!str) // 如果值不是字符串，返回 false return false; - instance.tags.emplace_back(str); + instance.tags.emplace_back(str); // 将标签添加到实例 } - result.emplace_back(std::move(instance)); + result.emplace_back(std::move(instance)); // 将实例添加到结果列表 } - return true; + return true; // 返回成功 } + +// 解析发现节点信息 static bool parse_discover_node(const json_object_t *obj, struct ConsulServiceInstance *instance) { - const json_value_t *val; - const char *str; + const json_value_t *val; // 存储 JSON 值 + const char *str; // 存储字符串值 + // 查找并解析 "Node" 信息 val = json_object_find("Node", obj); if (!val) return false; - obj = json_value_object(val); + obj = json_value_object(val); // 获取 "Node" 对象 if (!obj) return false; + // 获取 "ID" 字段 val = json_object_find("ID", obj); if (!val) return false; - str = json_value_string(val); + str = json_value_string(val); // 转换为字符串 if (!str) return false; - instance->node_id = str; + instance->node_id = str; // 设置节点 ID + + // 获取 "Node" 字段 val = json_object_find("Node", obj); if (!val) return false; @@ -778,7 +939,9 @@ static bool parse_discover_node(const json_object_t *obj, if (!str) return false; - instance->node_name = str; + instance->node_name = str; // 设置节点名称 + + // 获取 "Address" 字段 val = json_object_find("Address", obj); if (!val) return false; @@ -787,7 +950,9 @@ static bool parse_discover_node(const json_object_t *obj, if (!str) return false; - instance->node_address = str; + instance->node_address = str; // 设置节点地址 + + // 获取 "Datacenter" 字段 val = json_object_find("Datacenter", obj); if (!val) return false; @@ -796,99 +961,110 @@ static bool parse_discover_node(const json_object_t *obj, if (!str) return false; - instance->dc = str; + instance->dc = str; // 设置数据中心 + // 解析 "Meta" 信息 val = json_object_find("Meta", obj); if (!val) return false; - const json_object_t *meta_obj = json_value_object(val); + const json_object_t *meta_obj = json_value_object(val); // 获取 "Meta" 对象 if (!meta_obj) return false; - const char *meta_k; - const json_value_t *meta_v; + const char *meta_k; // 存储元数据键 + const json_value_t *meta_v; // 存储元数据值 + // 遍历 "Meta" 对象 json_object_for_each(meta_k, meta_v, meta_obj) { - str = json_value_string(meta_v); + str = json_value_string(meta_v); // 获取元数据值 if (!str) return false; - instance->node_meta[meta_k] = str; + instance->node_meta[meta_k] = str; // 添加元数据键值对 } + // 获取 "CreateIndex" 字段 val = json_object_find("CreateIndex", obj); if (val) - instance->create_index = json_value_number(val); + instance->create_index = json_value_number(val); // 设置创建索引 + // 获取 "ModifyIndex" 字段 val = json_object_find("ModifyIndex", obj); if (val) - instance->modify_index = json_value_number(val); + instance->modify_index = json_value_number(val); // 设置修改索引 - return true; + return true; // 返回成功 } -static bool parse_tagged_address(const char *name, - const json_value_t *tagged_val, - ConsulAddress& tagged_address) + +// 解析服务发现结果 +static bool parse_discover_result(const json_value_t *root, + std::vector& result) { - const json_value_t *val; - const json_object_t *obj; - const char *str; + const json_array_t *arr = json_value_array(root); // 获取 JSON 数组 + const json_value_t *val; // 存储数组值 + const json_object_t *obj; // 存储 JSON 对象 - obj = json_value_object(tagged_val); - if (!obj) + if (!arr) // 如果不是数组，返回 false return false; - val = json_object_find(name, obj); - if (!val) - return false; + // 遍历数组 + json_array_for_each(val, arr) + { + struct ConsulServiceInstance instance; // 创建服务实例 - obj = json_value_object(val); - if (!obj) - return false; + obj = json_value_object(val); // 获取数组中的对象 + if (!obj) + return false; - val = json_object_find("Address", obj); - if (!val) - return false; + // 解析节点信息 + if (!parse_discover_node(obj, &instance)) + return false; - str = json_value_string(val); - if (!str) - return false; + // 解析服务信息 + if (!parse_service(obj, &instance.service)) + return false; - tagged_address.first = str; - val = json_object_find("Port", obj); - if (!val) - return false; + // 解析健康检查 + parse_health_check(obj, &instance); - tagged_address.second = json_value_number(val); - return true; + result.emplace_back(std::move(instance)); // 添加实例到结果列表 + } + + return true; // 返回成功 } + +// 解析服务信息 static bool parse_service(const json_object_t *obj, struct ConsulService *service) { - const json_value_t *val; - const char *str; + const json_value_t *val; // 用于存储 JSON 值 + const char *str; // 用于存储字符串值 + // 获取 "Service" 对象 val = json_object_find("Service", obj); if (!val) return false; - obj = json_value_object(val); + obj = json_value_object(val); // 将值转换为对象 if (!obj) return false; + // 解析服务 ID val = json_object_find("ID", obj); if (!val) return false; - str = json_value_string(val); + str = json_value_string(val); // 将值转换为字符串 if (!str) return false; - service->service_id = str; + service->service_id = str; // 设置服务 ID + + // 解析服务名称 val = json_object_find("Service", obj); if (!val) return false; @@ -897,7 +1073,9 @@ static bool parse_service(const json_object_t *obj, if (!str) return false; - service->service_name = str; + service->service_name = str; // 设置服务名称 + + // 解析命名空间 val = json_object_find("Namespace", obj); if (val) { @@ -905,9 +1083,10 @@ static bool parse_service(const json_object_t *obj, if (!str) return false; - service->service_namespace = str; + service->service_namespace = str; // 设置命名空间 } + // 解析服务地址 val = json_object_find("Address", obj); if (!val) return false; @@ -916,13 +1095,16 @@ static bool parse_service(const json_object_t *obj, if (!str) return false; - service->service_address.first = str; + service->service_address.first = str; // 设置服务地址 + // 解析服务端口 val = json_object_find("Port", obj); if (!val) return false; - service->service_address.second = json_value_number(val); + service->service_address.second = json_value_number(val); // 设置服务端口 + + // 解析带标签地址 val = json_object_find("TaggedAddresses", obj); if (!val) return false; @@ -935,71 +1117,78 @@ static bool parse_service(const json_object_t *obj, parse_tagged_address("wan_ipv4", val, service->wan_ipv4); parse_tagged_address("wan_ipv6", val, service->wan_ipv6); + // 解析标签列表 val = json_object_find("Tags", obj); if (!val) return false; - const json_array_t *tags_arr = json_value_array(val); + const json_array_t *tags_arr = json_value_array(val); // 获取数组 if (tags_arr) { const json_value_t *tags_value; - json_array_for_each(tags_value, tags_arr) + json_array_for_each(tags_value, tags_arr) // 遍历数组 { - str = json_value_string(tags_value); + str = json_value_string(tags_value); // 获取标签字符串 if (!str) return false; - service->tags.emplace_back(str); + service->tags.emplace_back(str); // 添加标签到服务 } } + // 解析元数据 val = json_object_find("Meta", obj); if (!val) return false; - const json_object_t *meta_obj = json_value_object(val); + const json_object_t *meta_obj = json_value_object(val); // 获取元数据对象 if (!meta_obj) return false; const char *meta_k; const json_value_t *meta_v; - json_object_for_each(meta_k, meta_v, meta_obj) + json_object_for_each(meta_k, meta_v, meta_obj) // 遍历元数据 { str = json_value_string(meta_v); if (!str) return false; - service->meta[meta_k] = str; + service->meta[meta_k] = str; // 添加元数据键值对 } + // 检查标签覆盖选项 val = json_object_find("EnableTagOverride", obj); if (val) service->tag_override = (json_value_type(val) == JSON_VALUE_TRUE); - return true; + return true; // 返回成功 } + +// 解析健康检查信息 static bool parse_health_check(const json_object_t *obj, struct ConsulServiceInstance *instance) { - const json_value_t *val; - const char *str; + const json_value_t *val; // 存储 JSON 值 + const char *str; // 存储字符串值 + // 获取 "Checks" 数组 val = json_object_find("Checks", obj); if (!val) return false; - const json_array_t *check_arr = json_value_array(val); + const json_array_t *check_arr = json_value_array(val); // 转换为数组 if (!check_arr) return false; const json_value_t *arr_val; - json_array_for_each(arr_val, check_arr) + json_array_for_each(arr_val, check_arr) // 遍历数组 { - obj = json_value_object(arr_val); + obj = json_value_object(arr_val); // 获取数组中的对象 if (!obj) return false; + // 解析服务名称 val = json_object_find("ServiceName", obj); if (!val) return false; @@ -1009,6 +1198,8 @@ static bool parse_health_check(const json_object_t *obj, return false; std::string check_service_name = str; + + // 解析服务 ID val = json_object_find("ServiceID", obj); if (!val) return false; @@ -1021,6 +1212,7 @@ static bool parse_health_check(const json_object_t *obj, if (check_service_id.empty() || check_service_name.empty()) continue; + // 解析检查 ID val = json_object_find("CheckID", obj); if (!val) return false; @@ -1031,6 +1223,7 @@ static bool parse_health_check(const json_object_t *obj, instance->check_id = str; + // 解析检查名称 val = json_object_find("Name", obj); if (!val) return false; @@ -1040,6 +1233,8 @@ static bool parse_health_check(const json_object_t *obj, return false; instance->check_name = str; + + // 解析检查状态 val = json_object_find("Status", obj); if (!val) return false; @@ -1049,6 +1244,8 @@ static bool parse_health_check(const json_object_t *obj, return false; instance->check_status = str; + + // 解析备注 val = json_object_find("Notes", obj); if (val) { @@ -1059,6 +1256,7 @@ static bool parse_health_check(const json_object_t *obj, instance->check_notes = str; } + // 解析输出 val = json_object_find("Output", obj); if (val) { @@ -1069,6 +1267,7 @@ static bool parse_health_check(const json_object_t *obj, instance->check_output = str; } + // 解析检查类型 val = json_object_find("Type", obj); if (val) { @@ -1079,172 +1278,198 @@ static bool parse_health_check(const json_object_t *obj, instance->check_type = str; } - break; //only one effective service health check + break; // 只解析一个有效的健康检查 } - return true; + return true; // 返回成功 } +// 解析服务发现结果 static bool parse_discover_result(const json_value_t *root, - std::vector& result) + std::vector& result) { - const json_array_t *arr = json_value_array(root); - const json_value_t *val; - const json_object_t *obj; + const json_array_t *arr = json_value_array(root); // 转换为数组 + const json_value_t *val; // 存储数组中的值 + const json_object_t *obj; // 存储 JSON 对象 if (!arr) return false; + // 遍历数组 json_array_for_each(val, arr) { - struct ConsulServiceInstance instance; + struct ConsulServiceInstance instance; // 定义服务实例 - obj = json_value_object(val); + obj = json_value_object(val); // 获取数组中的对象 if (!obj) return false; + // 解析节点信息 if (!parse_discover_node(obj, &instance)) return false; + // 解析服务信息 if (!parse_service(obj, &instance.service)) return false; + // 解析健康检查 parse_health_check(obj, &instance); - result.emplace_back(std::move(instance)); + + result.emplace_back(std::move(instance)); // 添加实例到结果 } - return true; + return true; // 返回成功 } + +// 打印 JSON 对象，递归地将其转换为字符串格式 static void print_json_object(const json_object_t *obj, int depth, std::string& json_str) { - const char *name; - const json_value_t *val; - int n = 0; + const char *name; // JSON 对象的键 + const json_value_t *val; // JSON 对象的值 + int n = 0; // 键值对的计数器 int i; - json_str += "{\n"; + json_str += "{\n"; // 开始对象 + + // 遍历 JSON 对象中的每个键值对 json_object_for_each(name, val, obj) { - if (n != 0) + if (n != 0) // 如果不是第一个键值对，添加逗号换行 json_str += ",\n"; - n++; - for (i = 0; i < depth + 1; i++) + n++; // 键值对计数加 1 + for (i = 0; i < depth + 1; i++) // 根据深度添加缩进 json_str += " "; + // 添加键 json_str += "\""; json_str += name; json_str += "\": "; + + // 递归打印值 print_json_value(val, depth + 1, json_str); } - json_str += "\n"; - for (i = 0; i < depth; i++) + json_str += "\n"; // 对象内容结束 + for (i = 0; i < depth; i++) // 根据深度添加缩进 json_str += " "; - json_str += "}"; + json_str += "}"; // 结束对象 } + +// 打印 JSON 数组，递归地将其转换为字符串格式 static void print_json_array(const json_array_t *arr, int depth, std::string& json_str) { - const json_value_t *val; - int n = 0; + const json_value_t *val; // JSON 数组的值 + int n = 0; // 数组值的计数器 int i; - json_str += "[\n"; + json_str += "[\n"; // 开始数组 + + // 遍历 JSON 数组中的每个值 json_array_for_each(val, arr) { - if (n != 0) + if (n != 0) // 如果不是第一个值，添加逗号换行 json_str += ",\n"; - n++; - for (i = 0; i < depth + 1; i++) + n++; // 值计数加 1 + for (i = 0; i < depth + 1; i++) // 根据深度添加缩进 json_str += " "; + // 递归打印值 print_json_value(val, depth + 1, json_str); } - json_str += "\n"; - for (i = 0; i < depth; i++) + json_str += "\n"; // 数组内容结束 + for (i = 0; i < depth; i++) // 根据深度添加缩进 json_str += " "; - json_str += "]"; + json_str += "]"; // 结束数组 } + +// 打印 JSON 字符串，处理特殊字符转义 static void print_json_string(const char *str, std::string& json_str) { - json_str += "\""; + json_str += "\""; // 开始字符串 + + // 遍历字符串中的每个字符 while (*str) { switch (*str) { - case '\r': + case '\r': // 回车符转义 json_str += "\\r"; break; - case '\n': + case '\n': // 换行符转义 json_str += "\\n"; break; - case '\f': + case '\f': // 换页符转义 json_str += "\\f"; break; - case '\b': + case '\b': // 退格符转义 json_str += "\\b"; break; - case '\"': + case '\"': // 双引号转义 json_str += "\\\""; break; - case '\t': + case '\t': // 制表符转义 json_str += "\\t"; break; - case '\\': + case '\\': // 反斜杠转义 json_str += "\\\\"; break; - default: + default: // 其他字符直接添加 json_str += *str; break; } - str++; + str++; // 指向下一个字符 } - json_str += "\""; + json_str += "\""; // 结束字符串 } + +// 打印 JSON 数字 static void print_json_number(double number, std::string& json_str) { - long long integer = number; + long long integer = number; // 检查数字是否是整数 - if (integer == number) - json_str += std::to_string(integer); - else - json_str += std::to_string(number); + if (integer == number) // 如果是整数 + json_str += std::to_string(integer); // 转换为整数字符串 + else // 如果是浮点数 + json_str += std::to_string(number); // 转换为浮点数字符串 } + +// 根据值的类型打印 JSON 值 static void print_json_value(const json_value_t *val, int depth, std::string& json_str) { - switch (json_value_type(val)) + switch (json_value_type(val)) // 获取值的类型 { - case JSON_VALUE_STRING: + case JSON_VALUE_STRING: // 如果是字符串 print_json_string(json_value_string(val), json_str); break; - case JSON_VALUE_NUMBER: + case JSON_VALUE_NUMBER: // 如果是数字 print_json_number(json_value_number(val), json_str); break; - case JSON_VALUE_OBJECT: + case JSON_VALUE_OBJECT: // 如果是对象 print_json_object(json_value_object(val), depth, json_str); break; - case JSON_VALUE_ARRAY: + case JSON_VALUE_ARRAY: // 如果是数组 print_json_array(json_value_array(val), depth, json_str); break; - case JSON_VALUE_TRUE: + case JSON_VALUE_TRUE: // 如果是布尔值 true json_str += "true"; break; - case JSON_VALUE_FALSE: + case JSON_VALUE_FALSE: // 如果是布尔值 false json_str += "false"; break; - case JSON_VALUE_NULL: + case JSON_VALUE_NULL: // 如果是 null json_str += "null"; break; }