Introdução ao Connexus (Parte 1): Como usar a função WebRequest?
205
5
Introdução
No mundo da programação financeira, especialmente no contexto do MetaTrader 5, a capacidade de interagir com servidores remotos via HTTP é vital. Seja para obter dados de mercado em tempo real, enviar ordens de negociação para uma API ou até mesmo consultar serviços de terceiros, as requisições HTTP desempenham um papel crucial. No MQL5, a função WebRequest é a ferramenta nativa fornecida para essas comunicações, mas suas limitações a tornam pouco prática em muitos cenários.
O HTTP (Hypertext Transfer Protocol) é a base da comunicação na web, e dominar seu uso permite aos desenvolvedores criar integrações ricas e dinâmicas entre o MetaTrader 5 e outros serviços. O HTTP (Hypertext Transfer Protocol) é a base da comunicação na web, e dominar seu uso permite aos desenvolvedores criar integrações ricas e dinâmicas entre o MetaTrader 5 e outros serviços. Outra aplicação comum é consultar preços de criptomoedas em exchanges que oferecem APIs HTTP, permitindo que o EA opere em sincronia com esses mercados.
Apesar da importância das requisições HTTP, a implementação da função WebRequest no MQL5 não é exatamente o que se espera de uma ferramenta moderna e flexível. Isso coloca os desenvolvedores em uma posição desafiadora: ou se adaptam às limitações ou buscam alternativas. A série de artigos que estamos iniciando aqui tem como objetivo justamente isso — explorar as fraquezas da função WebRequest e construir uma biblioteca, o Connexus, que supere essas limitações e facilite o trabalho dos desenvolvedores de MQL5.
A função WebRequest abre uma ampla gama de possibilidades para integração com serviços externos. Desde a coleta de dados financeiros, que podem ser essenciais para decisões automatizadas de negociação, até a automação completa de processos, essa função permite que EAs interajam diretamente com a web. Isso possibilita, por exemplo, que seu robô de negociação obtenha informações em tempo real de fontes externas, como notícias econômicas ou dados de mercado de outras plataformas. Esses dados podem ser processados e usados para ajustar automaticamente suas estratégias de negociação, aumentando tanto a precisão quanto a eficiência de suas operações.
No entanto, como será demonstrado nos exemplos apresentados, o uso da função WebRequest pode não ser trivial. Enviar uma requisição HTTP pode parecer simples, mas você rapidamente encontrará desafios técnicos, como envio de cabeçalhos corretos, formatação de dados JSON, tratamento adequado das respostas do servidor e até mesmo lidar com erros e exceções que podem ocorrer durante a comunicação. Esses desafios ilustram que, embora poderosa, a função requer uma compreensão sólida dos protocolos e da comunicação entre sistemas, o que pode representar uma barreira significativa para desenvolvedores que estão começando a explorar essa área.
É exatamente aqui que entra a necessidade de uma ferramenta mais acessível e eficiente. A biblioteca Connexus, que será desenvolvida e aprimorada nos próximos artigos desta série, pretende superar essas limitações e tornar o processo de integração via WebRequest mais amigável e intuitivo. Com o Connexus, a ideia é que os desenvolvedores possam se concentrar no que realmente importa: a lógica de suas aplicações e EAs, sem precisar lidar diretamente com os detalhes técnicos das camadas mais baixas da programação de redes. Em vez de perder tempo depurando erros de formatação ou cabeçalhos, você poderá focar na integração dos seus sistemas de forma eficiente, com uma interface clara e funcional.
Esta série de artigos será dedicada a explorar profundamente as fraquezas da função WebRequest, suas limitações e como contorná-las no desenvolvimento de uma solução robusta. Além de continuar a discussão sobre o protocolo HTTP, abordaremos aspectos como autenticação em APIs, tratamento de grandes volumes de dados e implementação de recursos avançados, como controle de tempo de resposta e tratamento de múltiplas requisições simultâneas.
Portanto, se você tem interesse em aprimorar suas habilidades de desenvolvimento em MQL5, aprender mais sobre integração de sistemas e otimizar processos de comunicação via HTTP, fique ligado nas próximas publicações. Continuaremos a expandir o escopo deste projeto, guiando você no desenvolvimento da biblioteca Connexus para que ela se torne uma ferramenta indispensável no seu arsenal de desenvolvimento. O conhecimento adquirido aqui será útil não apenas para quem trabalha com MetaTrader, mas para qualquer desenvolvedor que precise integrar APIs e serviços web em suas aplicações.
Conhecendo o WebRequest
A função WebRequest é a principal ferramenta fornecida pelo MQL5 para realizar requisições HTTP. Em termos simples, ela permite que um programa em MQL5 envie uma solicitação para um servidor e receba uma resposta. Embora possa parecer simples, o uso prático do WebRequest revela uma série de armadilhas e complexidades que podem complicar o desenvolvimento.
A sintaxe básica da função tem duas versões:
int WebRequest( const string method, // HTTP method const string url, // URL const string cookie, // cookie const string referer, // referer int timeout, // timeout const char &data[], // the array of the HTTP message body int data_size, // data[] array size in bytes char &result[], // an array containing server response data string &result_headers // headers of server response );
int WebRequest( const string method, // HTTP method const string url, // URL const string headers, // headers int timeout, // timeout const char &data[], // the array of the HTTP message body char &result[], // an array containing server response data string &result_headers // headers of server response );
Os parâmetros da função WebRequest são vitais para o seu correto funcionamento, e entender cada um deles é essencial para qualquer desenvolvedor que queira utilizá-la de forma eficaz. Vamos explorar cada um desses parâmetros:
| Nome do Parâmetro | Tipo | Entrada/Saída | Descrição |
|---|---|---|---|
| method | string | in | Este parâmetro define o tipo de requisição HTTP que você deseja realizar. Os tipos mais comuns são GET e POST. O tipo GET é usado para solicitar dados de um servidor, enquanto o tipo POST é utilizado para enviar dados ao servidor. |
| url | string | in | Este é o endereço do servidor para o qual a solicitação será enviada. A URL deve ser completa, incluindo o protocolo (http ou https). |
| headers | string | in | Cabeçalhos HTTP adicionais podem ser passados como um array de strings. Cada string deve estar no formato "Chave: Valor". Esses cabeçalhos são usados para passar informações adicionais, como tokens de autenticação ou tipo de conteúdo, separados por uma quebra de linha "\r\n". |
| cookie | string | in | Valor do cookie. |
| referer | string | in | Valor do cabeçalho Referer da requisição HTTP. |
| timeout | int | in | Define o tempo máximo para aguardar uma resposta do servidor, em milissegundos. Um tempo limite adequado é crucial para garantir que o EA não fique travado esperando uma resposta que pode nunca chegar. |
| data | char[] | in | Para requisições POST, este parâmetro é usado para enviar dados ao servidor. Esses dados precisam estar na forma de um array de bytes, o que pode ser um desafio para desenvolvedores que não estão familiarizados com o tratamento de dados binários. |
| data_size | int | in | Este é o tamanho dos dados a serem enviados. Deve corresponder ao tamanho do array de dados para que a solicitação funcione corretamente. |
| result | char[] | out | Este parâmetro recebe a resposta do servidor, também como um array de bytes. Após a chamada da função, o array precisa ser decodificado para extrair as informações úteis. |
| result_headers | string | out | Este array de strings recebe os cabeçalhos da resposta do servidor, que podem conter informações importantes, como tipo de conteúdo e status de autenticação. |
Cada uma dessas configurações deve ser cuidadosamente ajustada para garantir que a requisição seja feita corretamente. Um erro em qualquer um desses parâmetros pode resultar em uma solicitação malformada ou na falha completa de comunicação com o servidor.
A função retorna um código de status HTTP que indica o sucesso ou a falha da operação. Embora o WebRequest cubra os conceitos básicos, sua implementação deixa muito a desejar. Ela exige que o desenvolvedor gerencie manualmente a criação de cabeçalhos, o tratamento de diferentes tipos de dados e a verificação de erros, tornando o processo tedioso e sujeito a erros. Um ponto positivo do WebRequest é que ele suporta tanto requisições GET quanto POST, o que permite interagir com uma ampla variedade de APIs.
Exemplo Prático da Função WebRequest
Para ilustrar o uso da função WebRequest, vamos construir um exemplo simples. Para isso, usaremos o httpbin.org, que é um serviço online gratuito que permite fazer e testar requisições HTTP. Ele foi criado por kennethreitz e é um projeto OpenSource (link). Este serviço funciona de maneira muito simples e descomplicada. Ele é basicamente um “espelho”. Você fica em frente ao espelho e faz uma pose ou faz uma pergunta. Isso é como enviar uma requisição para o HTTP Bin. O espelho reflete exatamente o que você está fazendo. Isso é como o HTTP Bin receber e refletir o que você enviou. É uma ferramenta útil para desenvolvedores que querem verificar exatamente o que está sendo enviado nas suas requisições HTTP ou que precisam simular diferentes tipos de requisições e respostas. Algumas das funcionalidades comuns do httpbin incluem:
- Envio de Requisições: Você pode enviar requisições HTTP de diferentes tipos, como GET, POST, PUT, DELETE, etc., para ver como o servidor responde.
- Teste de Cabeçalhos HTTP: Você pode enviar cabeçalhos personalizados e ver a resposta do servidor, o que é útil para depurar problemas relacionados a cabeçalhos.
- Envio de Dados no Corpo da Requisição: É possível testar o envio de dados no corpo da requisição e ver como o servidor os trata.
- Simulação de Status HTTP: Você pode solicitar que o servidor retorne códigos de status específicos, como 200, 404, 500, etc., para testar como sua aplicação lida com diferentes respostas de status.
- Simulação de Atrasos e Redirecionamentos: O httpbin.org permite simular atrasos de resposta ou redirecionamentos, ajudando a testar o comportamento do sistema em cenários mais complexos.
- Teste de Cookies: Você pode manipular cookies, vendo como eles são definidos e retornados pelo servidor.
É uma ferramenta prática para integrar sistemas que utilizam o protocolo HTTP. Vamos fazer a requisição GET mais simples possível usando o WebRequest.
Passo 1: Adicionar URL no Terminal
De acordo com a documentação: Para usar a função WebRequest(), adicione os endereços de servidor necessários à lista de URLs permitidas na aba "Ferramentas" da janela "Opções". A porta do servidor é automaticamente selecionada com base no protocolo especificado — 80 para "http://" e 443 para "https://".
Passo 2: Mão na Massa com o Código
No diretório <data_folder>/MQL5/Experts, crie uma pasta chamada Connexus. Vamos colocar nossos arquivos de teste nessa pasta. Para encontrar a pasta de dados, no menu principal do MetaTrader ou MetaEditor, selecione Arquivo > Abrir Pasta de Dados. Dentro dessa pasta, crie um arquivo chamado “WebRequest.mq5” e você terá algo assim:
//+------------------------------------------------------------------+ //| WebRequest.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- } //+------------------------------------------------------------------+
Usaremos apenas o evento OnInit() para testes por enquanto. Vamos definir algumas variáveis para realizar a requisição e passá-las para a função WebRequest.
int OnInit() { //--- Defining variables string method = "GET"; // HTTP verb in string (GET, POST, etc...) string url = "https://httpbin.org/get"; // Destination URL string headers = ""; // Request header int timeout = 5000; // Maximum waiting time 5 seconds char data[]; // Data we will send (body) array of type char char result[]; // Data received as an array of type char string result_headers; // String with response headers //--- Calling the function and getting the status_code int status_code = WebRequest(method,url,headers,timeout,data,result,result_headers); //--- Print the data Print("Status code: ",status_code); Print("Response: ",CharArrayToString(result)); // We use CharArrayToString to display the response in string form. //--- return(INIT_SUCCEEDED); }
Quando inserirmos o robô no gráfico, o terminal imprimirá a seguinte resposta:
WebRequest (WINV24,M1) Status code: 200 WebRequest (WINV24,M1) Resposta: { WebRequest (WINV24,M1) "args": {}, WebRequest (WINV24,M1) "headers": { WebRequest (WINV24,M1) "Accept": "*/*", WebRequest (WINV24,M1) "Accept-Encoding": "gzip, deflate", WebRequest (WINV24,M1) "Accept-Language": "pt,en;q=0.5", WebRequest (WINV24,M1) "Host": "httpbin.org", WebRequest (WINV24,M1) "User-Agent": "MetaTrader 5 Terminal/5.4476 (Windows NT 11.0.22631; x64)", WebRequest (WINV24,M1) "X-Amzn-Trace-Id": "Root=1-66d8cd53-0d6cd16368aa22e455db461c" WebRequest (WINV24,M1) }, WebRequest (WINV24,M1) "origin": "XXX.XXX.XX.XXX", WebRequest (WINV24,M1) "url": "https://httpbin.org/get" WebRequest (WINV24,M1) } WebRequest (WINV24,M1)
Observe que o código de status recebido foi 200, o que significa que a requisição foi bem-sucedida, e na resposta recebemos um JSON com alguns dados. No próximo artigo, exploraremos com mais detalhes como funciona a comunicação via protocolo HTTP. Agora vamos trocar o verbo HTTP para POST e enviar dados no corpo da requisição.
int OnInit() { //--- Defining variables string method = "POST"; // HTTP verb in string (GET, POST, etc...) string url = "https://httpbin.org/post"; // Destination URL string headers = ""; // Request header int timeout = 5000; // Maximum waiting time 5 seconds char data[]; // Data we will send (body) array of type char char result[]; // Data received as an array of type char string result_headers; // String with response headers //--- Treating body string body = "{\"key1\":\"value1\",\"key2\":\"value2\"}"; StringToCharArray(body,data,0,WHOLE_ARRAY,CP_UTF8); // Converts a string to a byte array //--- Calling the function and getting the status_code int status_code = WebRequest(method,url,headers,timeout,data,result,result_headers); //--- Print the data Print("Status code: ",status_code); Print("Response: ",CharArrayToString(result)); // We use CharArrayToString to display the response in string form. //--- return(INIT_SUCCEEDED); }
Certo, agora temos tudo funcionando, considerando que o httpbin vai retornar tudo o que enviarmos, ele deve devolver o corpo que enviamos, certo? Executar o código POST vai retornar:
WebRequest (WINV24,M1) Status code: 200 WebRequest (WINV24,M1) Resposta: { WebRequest (WINV24,M1) "args": {}, WebRequest (WINV24,M1) "data": "", WebRequest (WINV24,M1) "files": {}, WebRequest (WINV24,M1) "form": { WebRequest (WINV24,M1) "{\"key1\":\"value1\",\"key2\":\"value2\"}\u0000": "" WebRequest (WINV24,M1) }, WebRequest (WINV24,M1) "headers": { WebRequest (WINV24,M1) "Accept": "*/*", WebRequest (WINV24,M1) "Accept-Encoding": "gzip, deflate", WebRequest (WINV24,M1) "Accept-Language": "pt,en;q=0.5", WebRequest (WINV24,M1) "Content-Length": "34", WebRequest (WINV24,M1) "Content-Type": "application/x-www-form-urlencoded", WebRequest (WINV24,M1) "Host": "httpbin.org", WebRequest (WINV24,M1) "User-Agent": "MetaTrader 5 Terminal/5.4476 (Windows NT 11.0.22631; x64)", WebRequest (WINV24,M1) "X-Amzn-Trace-Id": "Root=1-66d9bc77-314c004a607c383b3197c15a" WebRequest (WINV24,M1) }, WebRequest (WINV24,M1) "json": null, WebRequest (WINV24,M1) "origin": "200.103.20.126", WebRequest (WINV24,M1) "url": "https://httpbin.org/post" WebRequest (WINV24,M1) } WebRequest (WINV24,M1)
Note que temos alguns campos adicionais, como “json” e “data”. Vamos entender cada um deles. O campo “data” deve mostrar o corpo que enviamos em formato de string, enquanto o campo “json” deve mostrar o corpo que enviamos em formato json. Mas por que ambos estão vazios se enviamos o corpo na requisição? Porque precisamos informar ao servidor que o tipo de conteúdo será json. Para isso, configuramos o cabeçalho da requisição, assim:
int OnInit() { //--- Defining variables string method = "POST"; // HTTP verb in string (GET, POST, etc...) string url = "https://httpbin.org/post"; // Destination URL string headers = "Content-Type: application/json";// Request header int timeout = 5000; // Maximum waiting time 5 seconds char data[]; // Data we will send (body) array of type char char result[]; // Data received as an array of type char string result_headers; // String with response headers //--- Treating body string body = "{\"key1\":\"value1\",\"key2\":\"value2\"}"; StringToCharArray(body,data,0,WHOLE_ARRAY,CP_UTF8); //--- Calling the function and getting the status_code int status_code = WebRequest(method,url,headers,timeout,data,result,result_headers); //--- Print the data Print("Status code: ",status_code); Print("Response: ",CharArrayToString(result)); // We use CharArrayToString to display the response in string form. //--- return(INIT_SUCCEEDED); }
WebRequest (WINV24,M1) Status code: 200 WebRequest (WINV24,M1) Resposta: { WebRequest (WINV24,M1) "args": {}, WebRequest (WINV24,M1) "data": "{\"key1\":\"value1\",\"key2\":\"value2\"}\u0000", WebRequest (WINV24,M1) "files": {}, WebRequest (WINV24,M1) "form": {}, WebRequest (WINV24,M1) "headers": { WebRequest (WINV24,M1) "Accept": "*/*", WebRequest (WINV24,M1) "Accept-Encoding": "gzip, deflate", WebRequest (WINV24,M1) "Accept-Language": "pt,en;q=0.5", WebRequest (WINV24,M1) "Content-Length": "34", WebRequest (WINV24,M1) "Content-Type": "application/json", WebRequest (WINV24,M1) "Host": "httpbin.org", WebRequest (WINV24,M1) "User-Agent": "MetaTrader 5 Terminal/5.4476 (Windows NT 11.0.22631; x64)", WebRequest (WINV24,M1) "X-Amzn-Trace-Id": "Root=1-66d9be03-59060f042f7090092787855e" WebRequest (WINV24,M1) }, WebRequest (WINV24,M1) "json": null, WebRequest (WINV24,M1) "origin": "200.103.20.126", WebRequest (WINV24,M1) "url": "https://httpbin.org/post" WebRequest (WINV24,M1) } WebRequest (WINV24,M1)
Note que agora os dados que enviamos aparecem no campo “data”, o que indica que estamos no caminho certo, mas perceba que o caractere \u0000 aparece porque o método StringToCharArray inclui o terminador nulo ao converter a string em array de bytes. Para evitar isso, podemos ajustar o tamanho do array. Vamos imprimir o corpo que estamos enviando para ver de onde está vindo esse caractere “\u0000”.
int OnInit() { //--- Defining variables string method = "POST"; // HTTP verb in string (GET, POST, etc...) string url = "https://httpbin.org/post"; // Destination URL string headers = "Content-Type: application/json";// Request header int timeout = 5000; // Maximum waiting time 5 seconds char data[]; // Data we will send (body) array of type char char result[]; // Data received as an array of type char string result_headers; // String with response headers //--- Tratando body string body = "{\"key1\":\"value1\",\"key2\":\"value2\"}"; StringToCharArray(body,data,0,WHOLE_ARRAY,CP_UTF8); Print("Body: ",body); Print("Body Size: ",StringLen(body)); ArrayPrint(data); Print("Array Size: ",ArraySize(data)); //--- Calling the function and getting the status_code int status_code = WebRequest(method,url,headers,timeout,data,result,result_headers); //--- Print the data Print("Status code: ",status_code); Print("Response: ",CharArrayToString(result)); // We use CharArrayToString to display the response in string form. //--- return(INIT_SUCCEEDED); }
WebRequest (WINV24,M1) Body: {"key1":"value1","key2":"value2"} WebRequest (WINV24,M1) Body Size: 33 WebRequest (WINV24,M1) 123 34 107 101 121 49 34 58 34 118 97 108 117 101 49 34 44 34 107 101 121 50 34 58 34 118 97 108 117 101 50 34 125 0 WebRequest (WINV24,M1) Array Size: 34 WebRequest (WINV24,M1) Status code: 200 WebRequest (WINV24,M1) Resposta: { WebRequest (WINV24,M1) "args": {}, WebRequest (WINV24,M1) "data": "{\"key1\":\"value1\",\"key2\":\"value2\"}\u0000", WebRequest (WINV24,M1) "files": {}, WebRequest (WINV24,M1) "form": {}, WebRequest (WINV24,M1) "headers": { WebRequest (WINV24,M1) "Accept": "*/*", WebRequest (WINV24,M1) "Accept-Encoding": "gzip, deflate", WebRequest (WINV24,M1) "Accept-Language": "pt,en;q=0.5", WebRequest (WINV24,M1) "Content-Length": "34", WebRequest (WINV24,M1) "Content-Type": "application/json", WebRequest (WINV24,M1) "Host": "httpbin.org", WebRequest (WINV24,M1) "User-Agent": "MetaTrader 5 Terminal/5.4476 (Windows NT 11.0.22631; x64)", WebRequest (WINV24,M1) "X-Amzn-Trace-Id": "Root=1-66d9bed3-2ebfcda024f637f436fc1d82" WebRequest (WINV24,M1) }, WebRequest (WINV24,M1) "json": null, WebRequest (WINV24,M1) "origin": "200.103.20.126", WebRequest (WINV24,M1) "url": "https://httpbin.org/post" WebRequest (WINV24,M1) } WebRequest (WINV24,M1)
Note que a string do corpo é um JSON válido, ou seja, ela abre e fecha colchetes, os valores estão separados por vírgulas e respeitam a regra chave:valor. Vamos ver o array de bytes que é gerado pela função StringToCharArray. Note que ele imprime o tamanho da string e do array, mas eles são diferentes. O array de bytes tem uma posição a mais do que a string. Além disso, note que na lista de valores, o último valor é "0" onde deveria ser 125, que é o caractere "}". Portanto, para resolver isso, vamos remover a última posição do array usando ArrayRemove().
int OnInit() { //--- Defining variables string method = "POST"; // HTTP verb in string (GET, POST, etc...) string url = "https://httpbin.org/post"; // Destination URL string headers = "Content-Type: application/json";// Request header int timeout = 5000; // Maximum waiting time 5 seconds char data[]; // Data we will send (body) array of type char char result[]; // Data received as an array of type char string result_headers; // String with response headers //--- Tratando body string body = "{\"key1\":\"value1\",\"key2\":\"value2\"}"; StringToCharArray(body,data,0,WHOLE_ARRAY,CP_UTF8); ArrayRemove(data,ArraySize(data)-1); Print("Body: ",body); Print("Body Size: ",StringLen(body)); ArrayPrint(data); Print("Array Size: ",ArraySize(data)); //--- Calling the function and getting the status_code int status_code = WebRequest(method,url,headers,timeout,data,result,result_headers); //--- Print the data Print("Status code: ",status_code); Print("Response: ",CharArrayToString(result)); // We use CharArrayToString to display the response in string form. //--- return(INIT_SUCCEEDED); }
WebRequest (WINV24,M1) Body: {"key1":"value1","key2":"value2"} WebRequest (WINV24,M1) Body Size: 33 WebRequest (WINV24,M1) 123 34 107 101 121 49 34 58 34 118 97 108 117 101 49 34 44 34 107 101 121 50 34 58 34 118 97 108 117 101 50 34 125 WebRequest (WINV24,M1) Array Size: 33 WebRequest (WINV24,M1) Status code: 200 WebRequest (WINV24,M1) Resposta: { WebRequest (WINV24,M1) "args": {}, WebRequest (WINV24,M1) "data": "{\"key1\":\"value1\",\"key2\":\"value2\"}", WebRequest (WINV24,M1) "files": {}, WebRequest (WINV24,M1) "form": {}, WebRequest (WINV24,M1) "headers": { WebRequest (WINV24,M1) "Accept": "*/*", WebRequest (WINV24,M1) "Accept-Encoding": "gzip, deflate", WebRequest (WINV24,M1) "Accept-Language": "pt,en;q=0.5", WebRequest (WINV24,M1) "Content-Length": "33", WebRequest (WINV24,M1) "Content-Type": "application/json", WebRequest (WINV24,M1) "Host": "httpbin.org", WebRequest (WINV24,M1) "User-Agent": "MetaTrader 5 Terminal/5.4476 (Windows NT 11.0.22631; x64)", WebRequest (WINV24,M1) "X-Amzn-Trace-Id": "Root=1-66d9c017-5985f48331dba63439d8192d" WebRequest (WINV24,M1) }, WebRequest (WINV24,M1) "json": { WebRequest (WINV24,M1) "key1": "value1", WebRequest (WINV24,M1) "key2": "value2" WebRequest (WINV24,M1) }, WebRequest (WINV24,M1) "origin": "200.103.20.126", WebRequest (WINV24,M1) "url": "https://httpbin.org/post" WebRequest (WINV24,M1) } WebRequest (WINV24,M1)
Agora, o tamanho da string e do array estão alinhados, e o servidor encontrou corretamente o conteúdo como JSON válido. Isso pode ser confirmado na resposta, onde o servidor retorna o JSON enviado nos campos "json" e "data". Após algumas configurações, conseguimos realizar uma simples requisição HTTP POST, enviando dados corretamente. No entanto, usar a função WebRequest não é trivial; requer um bom entendimento de como o protocolo funciona e das estruturas que estamos manipulando. Muitas vezes, até mesmo pequenos detalhes podem se tornar complicados, como vimos ao ajustar o código para obter uma resposta válida. O objetivo da biblioteca Connexus é justamente simplificar esse processo, permitindo que o usuário final não precise lidar com essas camadas mais baixas e abstratas da programação, evitando problemas complexos como o que enfrentamos agora, tornando o uso do WebRequest mais acessível e eficiente.
Conclusão
Ao longo deste artigo, exploramos em detalhes o uso da função WebRequest no MetaTrader 5, uma ferramenta essencial para desenvolvedores que desejam expandir as capacidades de seus Expert Advisors (EAs) por meio da comunicação com servidores e APIs externas. Usamos o serviço httpbin.org como exemplo prático para realizar requisições GET e POST, enviar e receber dados em formato JSON e compreender as respostas do servidor. Esta introdução é apenas o começo de uma jornada de integração de sistemas via HTTP, proporcionando a base para projetos muito mais complexos no futuro.
A jornada está apenas começando. Juntos, vamos transformar a função WebRequest em uma ferramenta simplificada, poderosa e acessível, simplificando o desenvolvimento de Expert Advisors e abrindo portas para novas possibilidades de automação e integração no MetaTrader 5.
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/15795
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.
Algoritmo do buraco negro — Black Hole Algorithm (BHA)
Criando um Painel Administrativo de Negociação em MQL5 (Parte II): Aprimorando a Responsividade e Mensagens Rápidas
Redes neurais em trading: Framework híbrido de negociação com codificação preditiva (Conclusão)
Exemplo de Otimização Estocástica e Controle Ótimo
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso
Olá, engenheiro joaopedrodev!
De qualquer forma, muito obrigado por este artigo muito interessante.
Mas há apenas um pequeno problema. É que, quando tento testar em condições reais o código que você forneceu, ou seja, a função "WebRequest" com o método POST, a solicitação chega sem problemas ao meu servidor. Somente os dados passados nos parâmetros (
"{\"key1\":\"value1\",\"key2\":\"value2\"}"), eles não chegam ao servidor. É possível que você tenha uma ideia para resolver isso? Obrigado, senhor
Olá, engenheiro joaopedrodev!
De qualquer forma, muito obrigado por este artigo muito interessante.
Mas há apenas um pequeno problema. É que, quando tento testar em condições reais o código que você forneceu, ou seja, a função "WebRequest" com o método POST, a solicitação chega sem problemas ao meu servidor. Só que os dados passados nos parâmetros (
), eles não chegam ao servidor. É possível que você tenha uma ideia para resolver isso? Obrigado, senhor
Olá @J M
Certifique-se de que está enviando esses dados no corpo da solicitação, para que o servidor receba corretamente os dados que você deseja enviar. Também peço que você use a versão mais recente da biblioteca que está anexada no último artigo Connexus Observer (Parte 8): Adicionando um observador de solicitação
Mas esse não é o ponto, precisamos de um símbolo na visão geral do mercado que possa carregar cotações de uma fonte externa (SQL, por exemplo).
Para essa finalidade, criei um símbolo personalizado e um serviço que, em segundo plano, atualiza seu histórico por meio das funções CustomRatesUpdate (via WebRequest) e CustomTicksAdd (via websocket).
Por meio de um EA, é complicado e requer uma conexão com um corretor de esquerda.
O uso do EA é realmente complicado. Use um serviço. Você não precisa se conectar a um corretor "esquerdo", obtenha cotações diretamente do provedor onde planeja negociar.
Portanto, o uso gratuito do MT5 ainda está em questão, e o WebRequest() é uma utopia.
Eu uso o MT5 livremente, sem nenhum problema. O WebRequest é bom para atualizações infrequentes do histórico e para enviar solicitações de negociação. Para atualizações em tempo real, use websockets.