diff --git a/WFConsulClient.cc b/WFConsulClient.cc
new file mode 100644
index 0000000..8e1bef2
--- /dev/null
+++ b/WFConsulClient.cc
@@ -0,0 +1,1477 @@
+/*
+  Copyright (c) 2022 Sogou, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+  Authors: Wang Zhenpeng (wangzhenpeng@sogou-inc.com)
+*/
+
+#include <string.h>
+#include <string>
+#include <vector>
+#include <utility>
+#include <functional>
+#include "json_parser.h" // JSON解析工具
+#include "StringUtil.h"  // 字符串工具
+#include "URIParser.h"   // URI解析工具
+#include "HttpUtil.h"    // HTTP相关工具
+#include "WFConsulClient.h" // Consul客户端相关定义
+
+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)) // 设置回调函数
+{
+	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; // 设置 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<struct ConsulServiceInstance>& result);
+
+// 解析服务列表结果的静态函数
+static bool parse_list_service_result(const json_value_t *root,
+							std::vector<struct ConsulServiceTags>& result);
+
+
+// 获取服务发现结果
+bool WFConsulTask::get_discover_result(
+	std::vector<struct ConsulServiceInstance>& result)
+{
+	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_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);  // 销毁 JSON 对象
+	if (ret)                   // 如果解析成功
+		errno = errno_bak;      // 恢复原始 errno
+
+	return ret;                // 返回解析结果
+}
+
+
+// 获取服务列表结果
+bool WFConsulTask::get_list_service_result(
+	std::vector<struct ConsulServiceTags>& result)
+{
+	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_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);  // 销毁 JSON 对象
+	if (ret)                   // 如果解析成功
+		errno = errno_bak;      // 恢复原始 errno
+
+	return ret;                // 返回解析结果
+}
+
+
+// 分发任务，根据 API 类型选择相应的任务处理逻辑
+void WFConsulTask::dispatch()
+{
+	WFHttpTask *task;  // 定义 HTTP 任务指针
+
+	if (this->finish)  // 如果任务已完成
+	{
+		this->subtask_done();  // 标记子任务完成
+		return;                // 退出
+	}
+
+	// 根据 API 类型选择处理任务
+	switch(this->api_type)
+	{
+	case CONSUL_API_TYPE_DISCOVER:         // 如果是服务发现任务
+		task = create_discover_task();    // 创建服务发现任务
+		break;
+
+	case CONSUL_API_TYPE_LIST_SERVICE:     // 如果是服务列表任务
+		task = create_list_service_task(); // 创建服务列表任务
+		break;
+
+	case CONSUL_API_TYPE_DEREGISTER:       // 如果是注销服务任务
+		task = create_deregister_task();   // 创建注销服务任务
+		break;
+
+	case CONSUL_API_TYPE_REGISTER:         // 如果是注册服务任务
+		task = create_register_task();     // 创建注册服务任务
+		if (task)
+			break;
+
+		// 如果任务创建失败，设置错误状态
+		if (1)
+		{
+			this->state = WFT_STATE_SYS_ERROR; // 设置系统错误状态
+			this->error = errno;              // 设置错误码
+		}
+		else
+		{
+	default:
+			this->state = WFT_STATE_TASK_ERROR; // 设置任务错误状态
+			this->error = WFT_ERR_CONSUL_API_UNKNOWN; // 设置未知 API 错误
+		}
+
+		this->finish = true;  // 标记任务完成
+		this->subtask_done(); // 标记子任务完成
+		return;
+	}
+
+	// 将任务插入到工作队列
+	series_of(this)->push_front(this);  // 将当前任务加入队列
+	series_of(this)->push_front(task); // 将新任务加入队列
+	this->subtask_done();              // 标记子任务完成
+}
+
+
+// 标记任务完成，并执行回调或清理逻辑
+SubTask *WFConsulTask::done()
+{
+	SeriesWork *series = series_of(this); // 获取当前任务的工作队列
+
+	if (finish)  // 如果任务已完成
+	{
+		if (this->callback)   // 如果有回调函数
+			this->callback(this); // 执行回调函数
+
+		delete this;          // 删除任务对象
+	}
+
+	return series->pop();     // 从队列中弹出任务
+}
+
+
+// 将毫秒时间转换为字符串形式（如 "5s" 或 "3m"）
+static std::string convert_time_to_str(int milliseconds)
+{
+	std::string str_time;      // 保存时间字符串
+	int seconds = milliseconds / 1000; // 将毫秒转换为秒
+
+	if (seconds >= 180)        // 如果时间超过 3 分钟
+		str_time = std::to_string(seconds / 60) + "m"; // 转换为分钟形式
+	else
+		str_time = std::to_string(seconds) + "s";     // 转换为秒形式
+
+	return str_time;           // 返回时间字符串
+}
+
+
+// 生成服务发现请求的 URL
+std::string WFConsulTask::generate_discover_request()
+{
+	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; // 添加 passing 参数
+
+	// 添加 token 参数用于鉴权
+	url += "&token=" + this->config.get_token();
+
+	// 添加过滤表达式参数
+	url += "&filter=" + this->config.get_filter_expr();
+
+	// 检查是否启用 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; // 返回生成的 URL
+}
+
+
+// 创建服务发现任务
+WFHttpTask *WFConsulTask::create_discover_task()
+{
+	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; // 返回创建的任务
+}
+
+
+// 创建服务列表任务
+WFHttpTask *WFConsulTask::create_list_service_task()
+{
+	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( // 创建 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; // 返回创建的任务
+}
+
+
+static void print_json_value(const json_value_t *val, int depth,
+							 std::string& json_str);
+
+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 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( // 创建 HTTP 任务
+		url, 0, this->retry_max, register_callback);
+
+	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); // 创建 JSON 对象根节点
+	if (root) // 如果创建成功
+	{
+		// 构建服务注册请求 JSON 数据
+		if (create_register_request(root, &this->service, this->config))
+			print_json_value(root, 0, payload); // 将 JSON 数据转为字符串
+
+		json_value_destroy(root); // 销毁 JSON 对象
+		// 如果请求体不为空且追加到请求成功
+		if (!payload.empty() && req->append_output_body(payload))
+		{
+			task->user_data = this; // 设置用户数据为当前任务对象
+			return task; // 返回创建的任务
+		}
+	}
+
+	task->dismiss(); // 如果失败，销毁任务
+	return NULL; // 返回空指针
+}
+
+
+// 创建服务注销任务
+WFHttpTask *WFConsulTask::create_deregister_task()
+{
+	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( // 创建 HTTP 任务
+		url, 0, this->retry_max, register_callback);
+
+	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; // 返回创建的任务
+}
+
+
+// 检查任务执行结果
+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; // 返回失败
+	}
+
+	// 获取任务的 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; // 返回失败
+	}
+
+	return true; // 返回成功
+}
+
+
+// 从 HTTP 响应头中获取 Consul 索引
+long long WFConsulTask::get_consul_index(HttpResponse *resp)
+{
+	long long consul_index = 0; // 初始化 Consul 索引为 0
+
+	// 创建 HTTP 头游标以遍历响应头
+	protocol::HttpHeaderCursor cursor(resp);
+	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) // 如果索引小于 0，则重置为 0
+			consul_index = 0;
+	}
+
+	return consul_index; // 返回 Consul 索引
+}
+
+
+// 服务发现任务的回调函数
+void WFConsulTask::discover_callback(WFHttpTask *task)
+{
+	WFConsulTask *t = (WFConsulTask*)task->user_data; // 获取任务的用户数据
+
+	// 检查任务执行结果
+	if (WFConsulTask::check_task_result(task, t))
+	{
+		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(); // 设置任务状态
+	}
+
+	// 将 HTTP 响应转移到任务对象
+	t->http_resp = std::move(*task->get_resp());
+	t->finish = true; // 标记任务完成
+}
+
+
+// 服务列表任务的回调函数
+void WFConsulTask::list_service_callback(WFHttpTask *task)
+{
+	WFConsulTask *t = (WFConsulTask*)task->user_data; // 获取任务的用户数据
+
+	// 检查任务执行结果
+	if (WFConsulTask::check_task_result(task, t))
+		t->state = task->get_state(); // 设置任务状态
+
+	// 将 HTTP 响应转移到任务对象
+	t->http_resp = std::move(*task->get_resp());
+	t->finish = true; // 标记任务完成
+}
+
+
+// 服务注册任务的回调函数
+void WFConsulTask::register_callback(WFHttpTask *task)
+{
+	WFConsulTask *t = (WFConsulTask *)task->user_data; // 获取任务的用户数据
+
+	// 检查任务执行结果
+	if (WFConsulTask::check_task_result(task, t))
+		t->state = task->get_state(); // 设置任务状态
+
+	// 将 HTTP 响应转移到任务对象
+	t->http_resp = std::move(*task->get_resp());
+	t->finish = true; // 标记任务完成
+}
+
+
+// 初始化 Consul 客户端
+int WFConsulClient::init(const std::string& proxy_url, ConsulConfig config)
+{
+	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) // 如果指定了端口，则追加端口信息
+		{
+			this->proxy_url += ":";
+			this->proxy_url += uri.port;
+		}
+
+		this->config = std::move(config); // 将配置赋值给客户端
+		return 0; // 返回成功
+	}
+	else if (uri.state == URI_STATE_INVALID) // 如果 URI 无效
+		errno = EINVAL; // 设置错误码为无效参数
+
+	return -1; // 返回失败
+}
+
+
+// 初始化 Consul 客户端（使用默认配置）
+int WFConsulClient::init(const std::string& proxy_url)
+{
+	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)
+{
+	// 创建一个新的 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; // 返回创建的任务
+}
+
+
+// 创建服务列表任务
+WFConsulTask *WFConsulClient::create_list_service_task(
+	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; // 返回创建的任务
+}
+
+
+// 创建服务注册任务
+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)
+{
+	// 创建一个新的 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; // 返回创建的任务
+}
+
+
+// 创建服务注销任务
+WFConsulTask *WFConsulClient::create_deregister_task(
+	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; // 返回创建的任务
+}
+
+
+// 创建带标签的地址对象
+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) // 如果添加失败，返回 false
+		return false;
+
+	// 获取新创建的嵌套对象
+	json_object_t *obj = json_value_object(val);
+	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; // 地址对象创建成功
+}
+
+
+// 创建健康检查配置
+static bool create_health_check(const ConsulConfig& config, json_object_t *obj)
+{
+	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) // 如果添加失败，返回 false
+		return false;
+
+	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()) // 如果 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;
+
+		json_object_t *header_obj = json_value_object(val);
+		if (!header_obj)
+			return false;
+
+		// 遍历并添加所有 HTTP 头部字段
+		for (const auto& header : *config.get_http_headers())
+		{
+			val = json_object_append(header_obj, header.first.c_str(),
+									 JSON_VALUE_ARRAY);
+			if (!val)
+				return false;
+
+			json_array_t *arr = json_value_array(val);
+			if (!arr)
+				return false;
+
+			// 添加头部字段对应的多个值
+			for (const auto& value : header.second)
+			{
+				if (!json_array_append(arr, JSON_VALUE_STRING, value.c_str()))
+					return false;
+			}
+		}
+	}
+
+	// 添加 TCP 检查地址
+	str = config.get_check_tcp();
+	if (!str.empty())
+	{
+		if (!json_object_append(obj, "TCP", JSON_VALUE_STRING, str.c_str()))
+			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; // 健康检查配置创建成功
+}
+
+
+// 创建服务注册请求
+static bool create_register_request(const json_value_t *root,
+									const struct ConsulService *service,
+									const ConsulConfig& config)
+{
+	const json_value_t *val; // 临时存储 JSON 值
+	json_object_t *obj; // 临时存储 JSON 对象
+
+	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,
+								service->service_namespace.c_str()))
+			return false;
+	}
+
+	// 添加服务标签数组
+	val = json_object_append(obj, "Tags", JSON_VALUE_ARRAY);
+	if (!val)
+		return false;
+
+	json_array_t *arr = json_value_array(val);
+	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;
+
+	json_object_t *meta_obj = json_value_object(val);
+	if (!meta_obj)
+		return false;
+
+	// 遍历并添加所有元数据
+	for (const auto& meta_kv : service->meta)
+	{
+		if (!json_object_append(meta_obj, meta_kv.first.c_str(),
+								JSON_VALUE_STRING, meta_kv.second.c_str()))
+			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;
+
+	json_object_t *tagged_obj = json_value_object(val);
+	if (!tagged_obj)
+		return false;
+
+	// 创建所有类型的带标签地址
+	if (!create_tagged_address(service->lan, "lan", tagged_obj))
+		return false;
+
+	if (!create_tagged_address(service->lan_ipv4, "lan_ipv4", tagged_obj))
+		return false;
+
+	if (!create_tagged_address(service->lan_ipv6, "lan_ipv6", tagged_obj))
+		return false;
+
+	if (!create_tagged_address(service->virtual_address, "virtual", tagged_obj))
+		return false;
+
+	if (!create_tagged_address(service->wan, "wan", tagged_obj))
+		return false;
+
+	if (!create_tagged_address(service->wan_ipv4, "wan_ipv4", tagged_obj))
+		return false;
+
+	if (!create_tagged_address(service->wan_ipv6, "wan_ipv6", tagged_obj))
+		return false;
+
+	// 创建健康检查配置
+	if (!create_health_check(config, obj))
+		return false;
+
+	return true; // 服务注册请求创建成功
+}
+
+
+// 解析服务列表结果
+static bool parse_list_service_result(const json_value_t *root,
+									  std::vector<struct ConsulServiceTags>& result)
+{
+	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) // 如果转换失败，返回 false
+		return false;
+
+	// 遍历 JSON 对象中的每个键值对
+	json_object_for_each(key, val, obj)
+	{
+		struct ConsulServiceTags instance; // 定义一个服务标签实例
+
+		instance.service_name = key; // 将键作为服务名称
+		arr = json_value_array(val); // 获取值作为数组
+		if (!arr) // 如果值不是数组，返回 false
+			return false;
+
+		const json_value_t *tag_val; // 遍历数组的每个值
+		json_array_for_each(tag_val, arr)
+		{
+			str = json_value_string(tag_val); // 获取值的字符串形式
+			if (!str) // 如果值不是字符串，返回 false
+				return false;
+
+			instance.tags.emplace_back(str); // 将标签添加到实例
+		}
+
+		result.emplace_back(std::move(instance)); // 将实例添加到结果列表
+	}
+
+	return true; // 返回成功
+}
+
+
+// 解析发现节点信息
+static bool parse_discover_node(const json_object_t *obj,
+								struct ConsulServiceInstance *instance)
+{
+	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); // 获取 "Node" 对象
+	if (!obj)
+		return false;
+
+	// 获取 "ID" 字段
+	val = json_object_find("ID", obj);
+	if (!val)
+		return false;
+
+	str = json_value_string(val); // 转换为字符串
+	if (!str)
+		return false;
+
+	instance->node_id = str; // 设置节点 ID
+
+	// 获取 "Node" 字段
+	val = json_object_find("Node", obj);
+	if (!val)
+		return false;
+
+	str = json_value_string(val);
+	if (!str)
+		return false;
+
+	instance->node_name = str; // 设置节点名称
+
+	// 获取 "Address" 字段
+	val = json_object_find("Address", obj);
+	if (!val)
+		return false;
+
+	str = json_value_string(val);
+	if (!str)
+		return false;
+
+	instance->node_address = str; // 设置节点地址
+
+	// 获取 "Datacenter" 字段
+	val = json_object_find("Datacenter", obj);
+	if (!val)
+		return false;
+
+	str = json_value_string(val);
+	if (!str)
+		return false;
+
+	instance->dc = str; // 设置数据中心
+
+	// 解析 "Meta" 信息
+	val = json_object_find("Meta", obj);
+	if (!val)
+		return false;
+
+	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;  // 存储元数据值
+
+	// 遍历 "Meta" 对象
+	json_object_for_each(meta_k, meta_v, meta_obj)
+	{
+		str = json_value_string(meta_v); // 获取元数据值
+		if (!str)
+			return false;
+
+		instance->node_meta[meta_k] = str; // 添加元数据键值对
+	}
+
+	// 获取 "CreateIndex" 字段
+	val = json_object_find("CreateIndex", obj);
+	if (val)
+		instance->create_index = json_value_number(val); // 设置创建索引
+
+	// 获取 "ModifyIndex" 字段
+	val = json_object_find("ModifyIndex", obj);
+	if (val)
+		instance->modify_index = json_value_number(val); // 设置修改索引
+
+	return true; // 返回成功
+}
+
+
+// 解析服务发现结果
+static bool parse_discover_result(const json_value_t *root,
+								  std::vector<struct ConsulServiceInstance>& result)
+{
+	const json_array_t *arr = json_value_array(root); // 获取 JSON 数组
+	const json_value_t *val;  // 存储数组值
+	const json_object_t *obj; // 存储 JSON 对象
+
+	if (!arr) // 如果不是数组，返回 false
+		return false;
+
+	// 遍历数组
+	json_array_for_each(val, arr)
+	{
+		struct ConsulServiceInstance instance; // 创建服务实例
+
+		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)); // 添加实例到结果列表
+	}
+
+	return true; // 返回成功
+}
+
+
+// 解析服务信息
+static bool parse_service(const json_object_t *obj,
+						  struct ConsulService *service)
+{
+	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); // 将值转换为对象
+	if (!obj)
+		return false;
+
+	// 解析服务 ID
+	val = json_object_find("ID", obj);
+	if (!val)
+		return false;
+
+	str = json_value_string(val); // 将值转换为字符串
+	if (!str)
+		return false;
+
+	service->service_id = str; // 设置服务 ID
+
+	// 解析服务名称
+	val = json_object_find("Service", obj);
+	if (!val)
+		return false;
+
+	str = json_value_string(val);
+	if (!str)
+		return false;
+
+	service->service_name = str; // 设置服务名称
+
+	// 解析命名空间
+	val = json_object_find("Namespace", obj);
+	if (val)
+	{
+		str = json_value_string(val);
+		if (!str)
+			return false;
+
+		service->service_namespace = str; // 设置命名空间
+	}
+
+	// 解析服务地址
+	val = json_object_find("Address", obj);
+	if (!val)
+		return false;
+
+	str = json_value_string(val);
+	if (!str)
+		return false;
+
+	service->service_address.first = str; // 设置服务地址
+
+	// 解析服务端口
+	val = json_object_find("Port", obj);
+	if (!val)
+		return false;
+
+	service->service_address.second = json_value_number(val); // 设置服务端口
+
+	// 解析带标签地址
+	val = json_object_find("TaggedAddresses", obj);
+	if (!val)
+		return false;
+
+	parse_tagged_address("lan", val, service->lan);
+	parse_tagged_address("lan_ipv4", val, service->lan_ipv4);
+	parse_tagged_address("lan_ipv6", val, service->lan_ipv6);
+	parse_tagged_address("virtual", val, service->virtual_address);
+	parse_tagged_address("wan", val, service->wan);
+	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); // 获取数组
+	if (tags_arr)
+	{
+		const json_value_t *tags_value;
+		json_array_for_each(tags_value, tags_arr) // 遍历数组
+		{
+			str = json_value_string(tags_value); // 获取标签字符串
+			if (!str)
+				return false;
+
+			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); // 获取元数据对象
+	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) // 遍历元数据
+	{
+		str = json_value_string(meta_v);
+		if (!str)
+			return false;
+
+		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; // 返回成功
+}
+
+
+// 解析健康检查信息
+static bool parse_health_check(const json_object_t *obj,
+							   struct ConsulServiceInstance *instance)
+{
+	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); // 转换为数组
+	if (!check_arr)
+		return false;
+
+	const json_value_t *arr_val;
+	json_array_for_each(arr_val, check_arr) // 遍历数组
+	{
+		obj = json_value_object(arr_val); // 获取数组中的对象
+		if (!obj)
+			return false;
+
+		// 解析服务名称
+		val = json_object_find("ServiceName", obj);
+		if (!val)
+			return false;
+
+		str = json_value_string(val);
+		if (!str)
+			return false;
+
+		std::string check_service_name = str;
+
+		// 解析服务 ID
+		val = json_object_find("ServiceID", obj);
+		if (!val)
+			return false;
+
+		str = json_value_string(val);
+		if (!str)
+			return false;
+
+		std::string check_service_id = str;
+		if (check_service_id.empty() || check_service_name.empty())
+			continue;
+
+		// 解析检查 ID
+		val = json_object_find("CheckID", obj);
+		if (!val)
+			return false;
+
+		str = json_value_string(val);
+		if (!str)
+			return false;
+
+		instance->check_id = str;
+
+		// 解析检查名称
+		val = json_object_find("Name", obj);
+		if (!val)
+			return false;
+
+		str = json_value_string(val);
+		if (!str)
+			return false;
+
+		instance->check_name = str;
+
+		// 解析检查状态
+		val = json_object_find("Status", obj);
+		if (!val)
+			return false;
+
+		str = json_value_string(val);
+		if (!str)
+			return false;
+
+		instance->check_status = str;
+
+		// 解析备注
+		val = json_object_find("Notes", obj);
+		if (val)
+		{
+			str = json_value_string(val);
+			if (!str)
+				return false;
+
+			instance->check_notes = str;
+		}
+
+		// 解析输出
+		val = json_object_find("Output", obj);
+		if (val)
+		{
+			str = json_value_string(val);
+			if (!str)
+				return false;
+
+			instance->check_output = str;
+		}
+
+		// 解析检查类型
+		val = json_object_find("Type", obj);
+		if (val)
+		{
+			str = json_value_string(val);
+			if (!str)
+				return false;
+
+			instance->check_type = str;
+		}
+
+		break; // 只解析一个有效的健康检查
+	}
+
+	return true; // 返回成功
+}
+
+// 解析服务发现结果
+static bool parse_discover_result(const json_value_t *root,
+								  std::vector<struct ConsulServiceInstance>& result)
+{
+	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; // 定义服务实例
+
+		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)); // 添加实例到结果
+	}
+
+	return true; // 返回成功
+}
+
+
+// 打印 JSON 对象，递归地将其转换为字符串格式
+static void print_json_object(const json_object_t *obj, int depth,
+							  std::string& json_str)
+{
+	const char *name;          // JSON 对象的键
+	const json_value_t *val;   // JSON 对象的值
+	int n = 0;                 // 键值对的计数器
+	int i;
+
+	json_str += "{\n";         // 开始对象
+
+	// 遍历 JSON 对象中的每个键值对
+	json_object_for_each(name, val, obj)
+	{
+		if (n != 0)            // 如果不是第一个键值对，添加逗号换行
+			json_str += ",\n";
+
+		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 += "    ";
+
+	json_str += "}";           // 结束对象
+}
+
+
+// 打印 JSON 数组，递归地将其转换为字符串格式
+static void print_json_array(const json_array_t *arr, int depth,
+							 std::string& json_str)
+{
+	const json_value_t *val;   // JSON 数组的值
+	int n = 0;                 // 数组值的计数器
+	int i;
+
+	json_str += "[\n";         // 开始数组
+
+	// 遍历 JSON 数组中的每个值
+	json_array_for_each(val, arr)
+	{
+		if (n != 0)            // 如果不是第一个值，添加逗号换行
+			json_str += ",\n";
+
+		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 += "    ";
+
+	json_str += "]";           // 结束数组
+}
+
+
+// 打印 JSON 字符串，处理特殊字符转义
+static void print_json_string(const char *str, std::string& json_str)
+{
+	json_str += "\"";          // 开始字符串
+
+	// 遍历字符串中的每个字符
+	while (*str)
+	{
+		switch (*str)
+		{
+		case '\r':             // 回车符转义
+			json_str += "\\r";
+			break;
+		case '\n':             // 换行符转义
+			json_str += "\\n";
+			break;
+		case '\f':             // 换页符转义
+			json_str += "\\f";
+			break;
+		case '\b':             // 退格符转义
+			json_str += "\\b";
+			break;
+		case '\"':             // 双引号转义
+			json_str += "\\\"";
+			break;
+		case '\t':             // 制表符转义
+			json_str += "\\t";
+			break;
+		case '\\':             // 反斜杠转义
+			json_str += "\\\\";
+			break;
+		default:               // 其他字符直接添加
+			json_str += *str;
+			break;
+		}
+		str++;                 // 指向下一个字符
+	}
+	json_str += "\"";          // 结束字符串
+}
+
+
+// 打印 JSON 数字
+static void print_json_number(double number, std::string& json_str)
+{
+	long long integer = 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)) // 获取值的类型
+	{
+	case JSON_VALUE_STRING:       // 如果是字符串
+		print_json_string(json_value_string(val), json_str);
+		break;
+	case JSON_VALUE_NUMBER:       // 如果是数字
+		print_json_number(json_value_number(val), json_str);
+		break;
+	case JSON_VALUE_OBJECT:       // 如果是对象
+		print_json_object(json_value_object(val), depth, json_str);
+		break;
+	case JSON_VALUE_ARRAY:        // 如果是数组
+		print_json_array(json_value_array(val), depth, json_str);
+		break;
+	case JSON_VALUE_TRUE:         // 如果是布尔值 true
+		json_str += "true";
+		break;
+	case JSON_VALUE_FALSE:        // 如果是布尔值 false
+		json_str += "false";
+		break;
+	case JSON_VALUE_NULL:         // 如果是 null
+		json_str += "null";
+		break;
+	}
+}
+