利用 curl 解析 HTML

Andrei Novichkov | 13 十一月, 2019

概述

我们讨论这样一种情况，即当使用常规请求无法从某个网站获得数据时。 在这种情况下能够做什么呢？ 第一个可能的想法是寻找可以使用 GET 或 POST 请求进行访问的资源。 有时，这样的资源根本不存在。 例如，这可能涉及某些独有指标的操作，或访问一些罕有更新的统计信息。

也许有人会问：“这有什么意义？”，一个简单的解决方案是直接从 MQL 脚本访问网站页面，并在已知页面位置读取已知数量的持仓信息。 然后，可以进一步处理接收到的字符串。 这是可能的方法之一。 但是在这种情况下，MQL 脚本代会与特定页面的 HTML 代码紧密绑定。 若是 HTML 代码变化了怎么办？ 这就是为什么我们需要一个解析器来，可将 HTML 文档整理为类似树形的操作（详细信息将在单独的章节中进行讨论）。 如果我们以 MQL 实现解析器，那么就性能而言是否更佳便捷、高效？ 这样的代码能够维护得当吗？ 这就是为什么解析功能应放在单独的函数库中来实现的原因。 不过，解析器无法解决所有问题。 它会执行所期望的功能。 但如果网站设计发生重大变化，并换用了其他类名和属性该怎么办？ 在这种情况下，我们将需要修改搜索对象或事件的多个对象。 所以，我们的目标之一是尽快以最小的工作量创建必要的代码。 如果我们有现成的部件可用则更好。 在上述状况下，这可令开发人员轻松维护代码，并快速对其进行编辑。

我们将选择一个页面不太大的网站，并尝试从该网站获取感兴趣的数据。 在这种情况下，数据的类型并不重要，尽管如此，我们还是来尝试创建一个有用的工具。 当然，该数据必须可用终端的 MQL 脚本进行处理。 程序代码将创建为标准 DLL。

在本文中，我们将实现的工具不支持异步调用和多线程。

现有解决方案

对于开发人员而言，从互联网上获取数据并进行处理的可能性一直很具有吸引力。 mql5.com 网站上有几篇文章，阐述了一些有趣且多样化的方法：

• MQL5-RPC， 从 MQL5 远程过程调用。 这篇文章提供了有关如何运用 XML-RPC 技术访问资源，并从中接收数据的详细分析。 该请求直接从 MQL 脚本发送。
  
• 使用 CSS 选择器从 HTML 页面提取结构化数据。 该示例展示如何利用 MQL 获取数据，并创建 HTML 代码解析器。
• 自己动手开发多线程异步 MQL5 WebRequest。 这篇文章提供了创建异步请求的有趣版本，且无需运用 MQL 手段进一步分析。

定义任务

我们将针对以下网站进行实验：https://www.mataf.net/en/forex/tools/volatility。 顾名思义，该站点提供有关货币对波动率的数据。 波动率以三种不同单位显示：点数，美元和百分比。 该网站页面不太庞大，因此可以有效地接收并解析，从中获得所需的数值。 对源文本的初步研究表明，我们必须从单独的表格单元中获取所存储的数值。 因此，我们将主要任务分为两个子任务：

1. 获取和存储页面。
2. 解析获取的页面，接收文档结构，并依据此结构搜索所需的信息。 数据处理并传递给客户端。

#include <curl\curl.h>

typedef size_t (*callback)(void*, size_t, size_t, void*);

typedef struct MemoryStruct {
        vector<char> membuff;
        size_t size = 0;
} MSTRUCT, *PMSTRUCT;

typedef struct FileStruct {
        std::string CalcName() {
                char cd[MAX_PATH];
                char fl[MAX_PATH];
                srand(unsigned(std::time(0)));
                ::GetCurrentDirectoryA(MAX_PATH, cd);
                ::GetTempFileNameA(cd, "_cUrl", std::rand(), fl);
                return std::string(fl);
        }
        std::string filename;
        FILE* stream = nullptr;
} FSTRUCT, *PFSTRUCT;

size_t CCurlExec::WriteMemoryCallback(void * contents, size_t size, size_t nmemb, void * userp)
{
        size_t realsize = size * nmemb;
        PMSTRUCT mem = (PMSTRUCT)userp;
        vector<char>tmp;
        char* data = (char*)contents;
        tmp.insert(tmp.end(), data, data + realsize);
        if (tmp.size() <= 0) return 0;
        mem->membuff.insert(mem->membuff.end(), tmp.begin(), tmp.end() );
        mem->size += realsize;
        return realsize;
}

bool CCurlExec::GetFiletoMem(const char* pUri)
{
        CURL *curl;
        CURLcode res;
        res  = curl_global_init(CURL_GLOBAL_ALL);
        if (res == CURLE_OK) {
                curl = curl_easy_init();
                if (curl) {
                        curl_easy_setopt(curl, CURLOPT_URL, pUri);
                        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
                        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
                        curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, m_errbuf);
                        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 20L);
                        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 60L);
                        curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
                        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); //redirects
#ifdef __DEBUG__ 
                        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
#endif
                        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
                        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &m_mchunk);
                        res = curl_easy_perform(curl);
                        if (res != CURLE_OK) PrintCurlErr(m_errbuf, res);
                        curl_easy_cleanup(curl);
                }// if (curl)
                curl_global_cleanup();
        } else PrintCurlErr(m_errbuf, res);
        return (res == CURLE_OK)? true: false;
}

注意 curl 操作的重要方面。 首先，执行两个初始化，结果就是用户收到指向 curl “核心”以及指向“句柄”的指针，这些指针会在稍后的调用中用到。 配置进一步的连接，这可能涉及很多设定。 在这种情况下，我们判断连接地址，需要检查证书，指定出错信息的写入缓冲区，判断超时区间，“user-agent” 标头，需要处理重定向，指定处理接收数据所要调用的函数（上述默认方法），和存储数据的对象。 设置 CURLOPT_VERBOSE 选项启用显示有关正在执行的操作的详细信息，这对于调试很有用。 指定所有选项后，将调用 curl 函数 curl_easy_perform。 它执行主要操作。 之后，数据将被清除。

我们来添加另一种通用方法：

bool CCurlExec::GetFile(const char * pUri, callback pFunc, void * pTarget)
{
        CURL *curl;
        CURLcode res;
        res = curl_global_init(CURL_GLOBAL_ALL);
        if (res == CURLE_OK) {
                curl = curl_easy_init();
                if (curl) {
                        curl_easy_setopt(curl, CURLOPT_URL, pUri);
                        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
                        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
                        curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, m_errbuf);
                        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 20L);
                        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 60L);
                        curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
                        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); 
#ifdef __DEBUG__ 
                        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
#endif
                        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, pFunc);
                        curl_easy_setopt(curl, CURLOPT_WRITEDATA, pTarget);
                        res = curl_easy_perform(curl);
                        if (res != CURLE_OK) PrintCurlErr(m_errbuf, res);
                        curl_easy_cleanup(curl);
                }// if (curl)
                curl_global_cleanup();
        }       else PrintCurlErr(m_errbuf, res);

        return (res == CURLE_OK) ? true : false;
}

此方法令开发人员可以使用自定义回调函数来处理接收到的数据（pFunc 参数），并使用自定义对象来存储此数据（pTarget 参数）。 因此，HTML 页面可以轻松保存为任何格式，如 csv 文件。

我们看看如何无需深入详节即可将信息保存到文件中。 前面已经提到了相应的回调函数，以及可用于选择文件名的辅助对象 FSTRUCT。 然而，在大多数情况下，操作到此还没有结束。 若要获取文件名，可以预先设置文件名（在这种情况下，应预先检查该名称的文件是否存在），或者可以允许函数库获取可读且有意义的文件名。 该名称应从实际地址获得，即在处理重定向后读取数据的地方。 以下方法展示了如何获取实际地址 

bool CCurlExec::GetFiletoFile(const char * pUri)

完整的方法代码已在存档中提供。 “ curl” 中提供的解析地址的工具：

std::string CCurlExec::ParseUri(const char* pUri) {
#if !CURL_AT_LEAST_VERSION(7, 62, 0)
#error "this example requires curl 7.62.0 or later"
        return  std::string();
#endif
        CURLU *h  = curl_url();
        if (!h) {
                cerr << "curl_url(): out of memory" << endl;
                return std::string();
        }
        std::string szres{};
        if (pUri == nullptr) return  szres;
        char* path;
        CURLUcode res;
        res = curl_url_set(h, CURLUPART_URL, pUri, 0);
        if ( res == CURLE_OK) {
                res = curl_url_get(h, CURLUPART_PATH, &path, 0);
                if ( res == CURLE_OK) {
                        std::vector <string> elem;
                        std::string pth = path;
                        if (pth[pth.length() - 1] == '/') {
                                szres = "index.html";
                        }
                        else {
                                Split(pth, elem);
                                cout << elem[elem.size() - 1] << endl;
                                szres =  elem[elem.size() - 1];
                        }
                        curl_free(path);
                }// if (curl_url_get(h, CURLUPART_PATH, &path, 0) == CURLE_OK)
        }// if (curl_url_set(h, CURLUPART_URL, pUri, 0) == CURLE_OK)
        return szres;
}

如您所见，curl 正确地从 uri 中提取到 “PATH”，并检查 PATH 是否以 '/' 字符结尾。 如果是这样，文件名应为 “index.html”。 否则，“PATH” 将被拆分为单独的元素，而文件名将是结果列表中的最后一个元素。

以上两种方法都是在项目中实现的，尽管通常将数据保存到文件的任务不在本文的讨论范围之内。

除了所描述的方法之外，CCurlExec 类还提供了两种基本方法，用来访问内存缓冲区，从网络接收的数据会保存到该缓冲区当中。 数据可以表示为

std::vector<char>

std::string

这要取决于 html 解析器的进一步选择。 在此无需研究 CCurlExec 类的其他方法和属性，因为在我们的项目里不会用到它们。

在结束本章之前，我想再补充一点。 curl 函数库是线程安全的。 在本示例中它以同步使用，为此使用 curl_easy_init 类型的方法。 名称中带有 “easy” 的所有 curl 函数只能用于同步。 而函数库里提供的异步调用方法，其名称里包含 “multi”。 例如，curl_easy_init 具有异步模拟函数 curl_multi_init。 在 curl 中调用异步函数并不是很复杂，但是它涉及到冗长的调用代码。 所以，我们现在不会考虑异步操作，但稍后我们可能会再次讨论。

HTML 解析类

我们尝试寻找现成的控件来执行此任务。 有许多不同的控件可用。 选择控件时，请使用与上一章相同的准则。 在本例中，首选项是 Google 的 Gumbo 项目。 可以在 github 上找到它。 随附的项目存档中提供了相应的链接。 您可以自行编译项目，这可能比使用 curl 更容易。 无论如何，随附的项目包含所有必需的文件：

• gumbo.lib 在 lib 项目文件夹中可用
• gumbo.dll 包含在 debug 和 release 文件夹中

#include <gumbo\gumbo.h>

        GumboOutput* output = gumbo_parse(input); 
//      ... do something with output ...
        gumbo_destroy_output(&options, output);

typedef enum {
        byPips = 2,
        byCurr = 3,
        byPerc = 4
} VOLTYPE;

double CVolatility::FindData(const std::string& szHtml, const std::string& pair, VOLTYPE vtype)
{
        if (pair.empty()) return -1;
        m_pair = pair;
        TOUPPER(m_pair);
        m_column = vtype;
        GumboOutput* output = gumbo_parse(szHtml.c_str() );
        double res = FindTable(output->root);
        const GumboOptions mGumboDefaultOptions = { &malloc_wrapper, &free_wrapper, NULL, 8, false, -1, GUMBO_TAG_LAST, GUMBO_NAMESPACE_HTML };
        gumbo_destroy_output(&mGumboDefaultOptions, output);
        return res;
}// void CVolatility::FindData(char * pHtml)

double CVolatility::FindTable(GumboNode * node) {
        double res = -1;
        if (node->type != GUMBO_NODE_ELEMENT) {
                return res; 
        }
        GumboAttribute* ptable;
        if ( (node->v.element.tag == GUMBO_TAG_TABLE)                          && \
                (ptable = gumbo_get_attribute(&node->v.element.attributes, "id") ) && \
                (m_idtable.compare(ptable->value) == 0) )                          {
                GumboVector* children = &node->v.element.children;
                GumboNode*   pchild = nullptr;
                for (unsigned i = 0; i < children->length; ++i) {
                        pchild = static_cast<GumboNode*>(children->data[i]);
                        if (pchild && pchild->v.element.tag == GUMBO_TAG_TBODY) {
                                return FindTableRow(pchild);
                        }
                }//for (int i = 0; i < children->length; ++i)
        }
        else {
                for (unsigned int i = 0; i < node->v.element.children.length; ++i) {
                        res = FindTable(static_cast<GumboNode*>(node->v.element.children.data[i]));
                        if ( res != -1) return res;
                }// for (unsigned int i = 0; i < node->v.element.children.length; ++i) 
        }
        return res;
}//void CVolatility::FindData(GumboNode * node, const std::string & szHtml)

double CVolatility::FindTableRow(GumboNode* node) {
        std::string szRow = "row_" + m_pair;
        GumboAttribute* prow       = nullptr;
        GumboNode*      child_node = nullptr;
        GumboVector* children = &node->v.element.children;
        for (unsigned int i = 0; i < children->length; ++i) {
                child_node = static_cast<GumboNode*>(node->v.element.children.data[i]);
                if ( (child_node->v.element.tag == GUMBO_TAG_TR) && \
                         (prow = gumbo_get_attribute(&child_node->v.element.attributes, "id")) && \
                        (szRow.compare(prow->value) == 0)) {
                        return GetVolatility(child_node);
                }
        }// for (unsigned int i = 0; i < node->v.element.children.length; ++i)
        return -1;
}// double CVolatility::FindVolatility(GumboNode * node)

double CVolatility::GetVolatility(GumboNode* node)
{
        double res = -1;
        GumboNode*      child_node = nullptr;
        GumboVector* children = &node->v.element.children;
        int j = 0;
        for (unsigned int i = 0; i < children->length; ++i) {
                child_node = static_cast<GumboNode*>(node->v.element.children.data[i]);
                if (child_node->v.element.tag == GUMBO_TAG_TD && j++ == (int)m_column) {
                        GumboNode* ch = static_cast<GumboNode*>(child_node->v.element.children.data[0]);
                        std::string t{ ch->v.text.text };
                        std::replace(t.begin(), t.end(), ',', '.');
                        res = std::stod(t);
                        break;
                }// if (child_node->v.element.tag == GUMBO_TAG_TD && j++ == (int)m_column)
        }// for (unsigned int i = 0; i < children->length; ++i) {
        return res;
}

#ifdef GETANDPARSE_EXPORTS
#define GETANDPARSE_API extern "C" __declspec(dllexport)
#else
#define GETANDPARSE_API __declspec(dllimport)
#endif

GETANDPARSE_API double GetVolatility(const wchar_t* wszPair, UINT vtype);

const static char vol_url[] = "https://www.mataf.net/ru/forex/tools/volatility";

GETANDPARSE_API double GetVolatility(const wchar_t*  wszPair, UINT vtype) {
        if (!wszPair) return -1;
        if (vtype < 2 || vtype > 4) return -1;

        std::wstring w{ wszPair };
        std::string s(w.begin(), w.end());

        CCurlExec cc;
        cc.GetFiletoMem(vol_url);
        CVolatility cv;
        return cv.FindData(cc.GetBufferAsString(), s, (VOLTYPE)vtype);
}

#property copyright "Copyright 2019, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property script_show_inputs

#import "GETANDPARSE.dll"
double GetVolatility(string wszPair,uint vtype);
#import
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum ReqType 
  {
   byPips    = 2, //Volatility by Pips
   byCurr    = 3, //Volatility by Currency
   byPercent = 4  //Volatility by Percent
  };

input string  PairName="EURUSD";
input ReqType tpe=byPips; 
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+

void OnStart()
  {
   double res=GetVolatility(PairName,tpe);
   PrintFormat("Volatility for %s is %.3f",PairName,res);
  }

结束语

我们讨论了一种以最简化的形式解析页面 HTML 的方法。 该函数库由现成的控件构成。 该代码已大大简化，以便帮助初学者理解该思路。 该解决方案的主要缺点是同步执行。 直至函数库接收到 HTML 页面，并对其进行处理，否则脚本无法受控。 这也许要花费一些时间，而这种情况对于指标和智能交易系统是无法接受的。 在此类应用程序中需要运用另一种方式。 我们将在后续文章中尝试找到更好的解决方案。

本文中用到的程序