Einführung in Connexus (Teil 1): Wie verwendet man die WebRequest-Funktion?

MetaTrader 5 — Beispiele | 13 November 2024, 11:17

139

joaopedrodev

Einführung

In der Welt der Finanzprogrammierung, insbesondere im Zusammenhang mit MetaTrader 5, ist die Fähigkeit zur Interaktion mit Remote-Servern über HTTP von entscheidender Bedeutung. Ob es darum geht, Echtzeit-Marktdaten abzurufen, Handelsaufträge an eine API zu senden oder sogar Dienste von Drittanbietern abzufragen - HTTP-Anfragen spielen eine entscheidende Rolle. In MQL5 ist die Funktion WebRequest das systemeigene Werkzeug, das für solche Kommunikationen zur Verfügung steht, aber seine Einschränkungen machen es in vielen Szenarien unpraktisch.

HTTP (Hypertext Transfer Protocol) ist die Grundlage der Webkommunikation, und die Beherrschung dieses Protokolls ermöglicht es Entwicklern, umfangreiche und dynamische Integrationen zwischen MetaTrader 5 und anderen Diensten zu erstellen. Ein Expert Advisor (EA) kann zum Beispiel auf eine Nachrichten-API zugreifen, um seine Handelsstrategien auf der Grundlage globaler Ereignisse anzupassen. Eine weitere häufige Anwendung ist die Abfrage von Kryptowährungspreisen an Börsen, die HTTP-APIs anbieten, sodass der EA synchron mit diesen Märkten handeln kann.

Trotz der Bedeutung von HTTP-Anfragen ist die Implementierung der WebRequest-Funktion in MQL5 nicht gerade das, was man von einem modernen und flexiblen Werkzeug erwarten würde. Dies bringt die Entwickler in eine schwierige Lage: Entweder sie passen sich an die Einschränkungen an oder sie suchen nach Umgehungsmöglichkeiten. Die Artikelserie, die wir hier beginnen, zielt darauf ab, genau das zu tun - die Schwächen der WebRequest-Funktion zu untersuchen und eine Bibliothek, Connexus, zu erstellen, die diese Einschränkungen überwindet und die Arbeit von MQL5-Entwicklern erleichtert.

Die WebRequest-Funktion eröffnet eine breite Palette von Möglichkeiten zur Integration mit externen Diensten. Von der Erfassung von Finanzdaten, die für automatisierte Handelsentscheidungen wichtig sein können, bis hin zur vollständigen Automatisierung von Prozessen ermöglicht diese Funktion den EAs eine direkte Interaktion mit dem Web. So kann Ihr Handelsroboter beispielsweise Echtzeitinformationen aus externen Quellen beziehen, wie Wirtschaftsnachrichten oder Marktdaten von anderen Plattformen. Diese Daten können verarbeitet und verwendet werden, um Ihre Handelsstrategien automatisch anzupassen, was sowohl die Genauigkeit als auch die Effizienz Ihrer Operationen erhöht.

Wie in den vorgestellten Beispielen gezeigt wird, ist die Verwendung der WebRequest-Funktion jedoch nicht unbedingt trivial. Das Senden einer HTTP-Anfrage mag einfach erscheinen, aber Sie werden schnell auf technische Herausforderungen stoßen, wie z. B. das Senden der richtigen Kopfzeilen, das Formatieren von JSON-Daten, die korrekte Handhabung von Serverantworten und sogar der Umgang mit Fehlern und Ausnahmen, die während der Kommunikation auftreten können. Diese Herausforderungen zeigen, dass die Funktion zwar leistungsfähig ist, aber ein solides Verständnis von Protokollen und der Kommunikation zwischen Systemen voraussetzt, was für Entwickler, die gerade erst anfangen, diesen Bereich zu erforschen, eine erhebliche Hürde darstellen kann.

Genau an dieser Stelle wird ein besser zugängliches und effizienteres Instrument benötigt. Die Connexus-Bibliothek, die in den kommenden Artikeln dieser Reihe weiterentwickelt und verbessert wird, zielt darauf ab, diese Einschränkungen zu überwinden und den Integrationsprozess über WebRequest nutzerfreundlicher und intuitiver zu gestalten. Mit Connexus können sich Entwickler auf das konzentrieren, was wirklich wichtig ist: die Logik ihrer Anwendungen und EAs, ohne sich direkt mit den technischen Details der unteren Schichten der Netzwerkprogrammierung befassen zu müssen. Anstatt Zeit mit dem Debuggen von Formatierungs- oder Kopfzeilenfehlern zu verschwenden, können Sie sich auf die effiziente Integration Ihrer Systeme mit einer übersichtlichen und funktionalen Schnittstelle konzentrieren.

In dieser Artikelserie werden wir uns eingehend mit den Schwächen der WebRequest-Funktion befassen, mit ihren Einschränkungen und damit, wie wir sie bei der Entwicklung einer robusten Lösung umgehen können. Neben der Fortsetzung der Diskussion über das HTTP-Protokoll werden wir Aspekte wie die Authentifizierung in APIs, die Handhabung großer Datenmengen und die Implementierung fortgeschrittener Funktionen wie die Kontrolle der Antwortzeit und die Handhabung mehrerer gleichzeitiger Anfragen behandeln.

Wenn Sie also daran interessiert sind, Ihre MQL5-Entwicklungsfähigkeiten zu verbessern, mehr über die Systemintegration zu erfahren und HTTP-Kommunikationsprozesse zu optimieren, sollten Sie sich die kommenden Veröffentlichungen nicht entgehen lassen. Wir werden den Umfang dieses Projekts weiter ausbauen und Sie bei der Entwicklung der Connexus-Bibliothek anleiten, damit sie zu einem unverzichtbaren Werkzeug in Ihrem Entwicklungsarsenal wird. Das hier erworbene Wissen ist nicht nur für diejenigen nützlich, die mit MetaTrader arbeiten, sondern auch für jeden Entwickler, der APIs und Webdienste in seine Anwendungen integrieren muss.

Kennenlernen von WebRequest

Die Funktion WebRequest ist das Hauptwerkzeug von MQL5, um HTTP-Anfragen zu stellen. Einfach ausgedrückt, kann ein MQL5-Programm eine Anfrage an einen Server senden und eine Antwort erhalten. Obwohl es einfach erscheinen mag, offenbart die praktische Anwendung von WebRequest eine Reihe von Fallstricken und Komplexitäten, die die Entwicklung erschweren können.

Die grundlegende Syntax der Funktion hat zwei Versionen:

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
   );

Die Parameter der Funktion WebRequest sind für ihr ordnungsgemäßes Funktionieren von entscheidender Bedeutung, und ein detailliertes Verständnis dieser Parameter ist für jeden Entwickler, der sie effektiv nutzen möchte, unerlässlich. Sehen wir uns jeden dieser Parameter an:

Parameter Name	Typ	Eingabe/Ausgabe	Beschreibung
method	string	in	Dieser Parameter definiert die Art der HTTP-Anfrage, die Sie stellen möchten. Die gebräuchlichsten Typen sind GET und POST. Der Typ GET wird verwendet, um Daten von einem Server anzufordern, während der Typ POST verwendet wird, um Daten an den Server zu senden.
url	string	in	Dies ist die Adresse des Servers, an den die Anfrage gesendet werden soll. Die URL muss vollständig sein, einschließlich des Protokolls (http oder https).
headers	string	in	Zusätzliche HTTP-Header können als Array von Zeichenketten übergeben werden. Jede Zeichenkette muss das Format „Key:Value“ haben. Diese Kopfzeilen werden verwendet, um zusätzliche Informationen wie Authentifizierungstoken oder Inhaltstyp zu übermitteln, die durch einen Zeilenumbruch „\r\n“ getrennt sind.
cookie	string	in	Cookie-Wert.
referer	string	in	Wert des Referer-Headers der HTTP-Anfrage.
timeout	int	in	Legt die maximale Wartezeit auf eine Antwort des Servers in Millisekunden fest. Eine angemessene Zeitüberschreitung ist wichtig, um sicherzustellen, dass der EA nicht auf eine Antwort warten muss, die möglicherweise nie eintrifft.
data	char[]	in	Bei POST-Anfragen wird dieser Parameter verwendet, um die Daten an den Server zu senden. Diese Daten müssen in Form eines Byte-Arrays vorliegen, was für Entwickler, die mit dem Umgang mit binären Daten nicht vertraut sind, eine Herausforderung darstellen kann.
data_size	int	in	Dies ist die Größe der zu sendenden Daten. Sie muss mit der Größe des Datenfeldes übereinstimmen, damit die Anfrage korrekt funktioniert.
result	char[]	out	Dieser Parameter empfängt die Antwort des Servers, ebenfalls in Form eines Arrays von Bytes. Nach dem Aufruf der Funktion muss das Array dekodiert werden, um die nützlichen Informationen zu extrahieren.
result_headers	string	out	Dieses Array von Zeichenketten empfängt die Antwort-Header des Servers, die wichtige Informationen wie den Inhaltstyp und den Authentifizierungsstatus enthalten können.

Jede dieser Einstellungen muss sorgfältig konfiguriert werden, um sicherzustellen, dass die Anfrage korrekt gestellt wird. Ein Fehler in einem dieser Parameter kann zu einer fehlerhaften Anfrage oder zu einem kompletten Ausfall der Kommunikation mit dem Server führen.

Die Funktion gibt einen HTTP-Statuscode zurück, der den Erfolg oder Misserfolg des Vorgangs angibt. WebRequest deckt zwar die grundlegenden Konzepte ab, seine Implementierung lässt jedoch zu wünschen übrig. Der Entwickler muss die Erstellung von Kopfzeilen, den Umgang mit verschiedenen Datentypen und die Fehlerprüfung manuell verwalten, was den Prozess mühsam und fehleranfällig macht. Eine gute Eigenschaft von WebRequest ist, dass es sowohl GET- als auch POST-Anfragen unterstützt, wodurch es mit einer Vielzahl von APIs interagieren kann.

Praktisches Beispiel für die WebRequest-Funktion

Um die Verwendung der WebRequest-Funktion zu veranschaulichen, wollen wir ein einfaches Beispiel erstellen. Dazu verwenden wir httpbin.org, einen kostenlosen Online-Dienst, mit dem Sie HTTP-Anfragen stellen und testen können. Es wurde von kennethreitz als OpenSource-Projekt (Link) erstellt. Dieser Dienst funktioniert auf sehr einfache und unkomplizierte Weise. Es ist im Grunde ein „Spiegel“. Man stellt sich vor den Spiegel und nimmt eine Pose ein oder stellt eine Frage. Dies ist wie das Senden einer Anfrage an HTTP Bin. Der Spiegel spiegelt genau das wider, was Sie gerade tun. Das ist so, als würde HTTP Bin empfangen und wiedergeben, was Sie gesendet haben. Es ist ein nützliches Werkzeug für Entwickler, die genau prüfen wollen, was in ihren HTTP-Anfragen gesendet wird, oder die verschiedene Arten von Anfragen und Antworten simulieren müssen. Einige gemeinsame Merkmale von httpbin sind:

Senden von Anfragen: Sie können HTTP-Anfragen verschiedener Typen wie GET, POST, PUT, DELETE usw. senden, um zu sehen, wie der Server antwortet.
Test des HTTP-Headers: Sie können nutzerdefinierte Kopfzeilen senden und die Antwort des Servers anzeigen, was für die Fehlersuche bei Kopfzeilenproblemen nützlich ist.
Senden von Daten im Hauptteil, dem Body, der Anfrage: Es ist möglich, das Senden von Daten im Anfragekörper zu testen und zu sehen, wie der Server damit umgeht.
HTTP-Status-Simulation: Sie können den Server auffordern, bestimmte Statuscodes wie 200, 404, 500 usw. zurückzugeben, um zu testen, wie Ihre Anwendung mit verschiedenen Statusantworten umgeht.
Simulation von Verzögerungen und Umleitungen: httpbin.org ermöglicht die Simulation von Antwortverzögerungen oder Umleitungen und hilft so, das Systemverhalten in komplexeren Szenarien zu testen.
Cookie-Tests: Sie können Cookies manipulieren und sehen, wie sie vom Server gesetzt und zurückgegeben werden.

Es ist ein praktisches Werkzeug für die Integration von Systemen, die das HTTP-Protokoll verwenden. Lassen Sie uns eine möglichst einfache GET-Anfrage mit WebRequest stellen.

Schritt 1: URL im Terminal hinzufügen

In der Dokumentation heißt es dazu: Um die Funktion WebRequest() zu verwenden, fügen Sie die erforderlichen Serveradressen der Liste der zulässigen URLs auf der Registerkarte „Extras“ des Fensters „Optionen“ hinzu. Der Port des Servers wird automatisch auf der Grundlage des angegebenen Protokolls ausgewählt - 80 für „http://“ und 443 für „https://“.

Schritt 2: Schreiben des Codes

Im Verzeichnis <data_folder>/MQL5/Experts erstellen wir einen Ordner namens Connexus. Wir werden unsere Testdateien in diesem Ordner ablegen. Um den Datenordner zu finden, wählen Sie im Hauptmenü von MetaTrader oder MetaEditor Datei > Dateiordner öffnen. In diesem Ordner erstellen wir eine Datei mit dem Namen „WebRequest.mq5“, und erhalten etwa folgendes Ergebnis:

//+------------------------------------------------------------------+
//|                                                   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()
  {
//---
   
  }
//+------------------------------------------------------------------+

Wir werden vorerst nur das OnInit()-Ereignis zum Testen verwenden. Definieren wir einige Variablen für die Durchführung der Anfrage und übergeben sie an die Funktion 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);
  }

Wenn wir den Roboter in das Chart einfügen, gibt das Terminal die folgende Antwort aus:

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)

Beachten Sie, dass der erhaltene Statuscode 200 war, was bedeutet, dass die Anfrage erfolgreich war, und in der Antwort haben wir ein JSON mit einigen Daten erhalten. Im nächsten Artikel werden wir genauer untersuchen, wie die Kommunikation über das HTTP-Protokoll funktioniert. Jetzt ändern wir den HTTP-Auftrag in POST und senden Daten im Textkörper der Anfrage.

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);
  }

Okay, jetzt funktioniert alles, wenn man bedenkt, dass httpbin alles zurückgibt, was wir senden, sollte es den Hauptteil (body) zurückgeben, den wir gesendet haben, richtig? Die Ausführung des POST-Codes sendet Folgendes zurück:

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)

Beachten Sie, dass wir einige zusätzliche Felder haben, wie „json“ und „data“. Lassen Sie uns jedes einzelne von ihnen verstehen. Das Feld „data“ sollte den Text enthalten, den wir im String-Format gesendet haben, während das Feld „json“ den Text enthalten sollte, den wir im Json-Format gesendet haben. Aber warum sind beide leer, wenn wir den Körper in der Anfrage gesendet haben? Denn wir müssen dem Server mitteilen, dass der Inhaltstyp json sein wird. Zu diesem Zweck konfigurieren wir den Request-Header wie folgt:

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)

Beachten Sie, dass sich die gesendeten Daten jetzt im Feld „data“ befinden, was darauf hindeutet, dass wir auf dem richtigen Weg sind. Beachten Sie aber auch, dass das Zeichen „\u0000“ erscheint, weil die Methode StringToCharArray bei der Umwandlung der Zeichenfolge in ein Byte-Array den Null-Terminator einschließt. Um dies zu vermeiden, können wir die Größe des Arrays anpassen. Drucken wir den Text aus, den wir senden, um zu sehen, woher das Zeichen „\u0000“ kommt.

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)

Beachten Sie, dass die Body-Zeichenfolge gültiges JSON ist, d. h. sie öffnet und schließt eckige Klammern, die Werte sind durch Kommas getrennt und folgen der Regel „key:value“ (Schlüssel:Wert). Schauen wir uns das Byte-Array an, das von der Funktion StringToCharArray erzeugt wird. Beachten Sie, dass die Größe der Zeichenkette und des Arrays ausgegeben wird, aber sie sind unterschiedlich. Das Byte-Array ist um eine Position größer als die Zeichenkette. Beachten Sie auch, dass in der Liste der Werte der letzte Wert „0“ ist, anstelle von eigentlich 125, nämlich das Zeichen „}“. Um dieses Problem zu lösen, werden wir die letzte Position des Arrays mit ArrayRemove() entfernen.

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)

Jetzt sind die Größe der Zeichenkette und des Arrays angeglichen, und der Server hat den Inhalt korrekt als gültiges JSON erkannt. Dies kann in der Rückantwort angegeben werden, in der der Server den in den Feldern „json“ und „data“ gesendeten JSON zurückgibt. Nach einiger Konfiguration konnten wir eine einfache HTTP-POST-Anfrage durchführen und die Daten korrekt senden. Die Verwendung der Funktion WebRequest ist jedoch nicht trivial; sie erfordert ein gutes Verständnis der Funktionsweise des Protokolls und der Strukturen, die wir manipulieren. Oft können selbst kleine Nachteile kompliziert werden, wie wir bei der Anpassung des Codes gesehen haben, um eine gültige Antwort zu erhalten. Das Ziel der Connexus-Bibliothek besteht genau darin, diesen Prozess zu vereinfachen und es dem Endnutzer zu ermöglichen, sich nicht mit diesen niedrigeren und abstrakteren Programmierungsschichten befassen zu müssen, komplexe Probleme wie das, mit dem wir jetzt konfrontiert sind, zu vermeiden und die Verwendung von WebRequest zugänglicher und effizienter zu machen.

Schlussfolgerung

In diesem Artikel haben wir uns eingehend mit der Verwendung der WebRequest-Funktion in MetaTrader 5 befasst, einem unverzichtbaren Werkzeug für Entwickler, die die Möglichkeiten ihrer Expert Advisors (EAs) durch die Kommunikation mit externen Servern und APIs erweitern möchten. Wir haben den Dienst httpbin.org als praktisches Beispiel verwendet, um GET- und POST-Anfragen durchzuführen, Daten im JSON-Format zu senden und zu empfangen und die Serverantworten zu verstehen. Diese Einführung ist nur der Anfang einer Reise der Systemintegration über HTTP, die die Grundlage für viel komplexere Projekte in der Zukunft bildet.

Die Reise hat gerade erst begonnen. Gemeinsam verwandeln wir die WebRequest-Funktion in ein vereinfachtes, leistungsstarkes und zugängliches Tool, das die Entwicklung von Expert Advisors vereinfacht und neue Möglichkeiten für die Automatisierung und Integration in MetaTrader 5 eröffnet.

Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/15795

Beigefügte Dateien |

ZIP herunterladen

WebRequest.mq5 (5.14 KB)

Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.

Andere Artikel von diesem Autor

Zur Diskussion im Händlerforum

Erstellen eines integrierten MQL5-Telegram-Expertenberaters (Teil 6): Responsive Inline-Schaltflächen hinzufügen

In diesem Artikel integrieren wir interaktive Inline-Buttons in einen MQL5 Expert Advisor, die eine Echtzeitsteuerung über Telegram ermöglichen. Jeder Tastendruck löst bestimmte Aktionen aus und sendet Antworten an den Nutzer zurück. Außerdem modularisieren wir Funktionen zur effizienten Handhabung von Telegram-Nachrichten und Callback-Abfragen.

Selbstoptimierender Expert Advisor mit MQL5 und Python (Teil III): Den Boom-1000-Algorithmus knacken

In dieser Artikelserie erörtern wir, wie wir Expert Advisors entwickeln können, die sich selbständig an dynamische Marktbedingungen anpassen. Im heutigen Artikel werden wir versuchen, ein tiefes neuronales Netz auf die synthetischen Märkte von Derivativen abzustimmen.

MQL5-Assistent-Techniken, die Sie kennen sollten (Teil 38): Bollinger Bands

Bollinger Bänder sind ein sehr gebräuchlicher Hüllkurven-Indikator, der von vielen Händlern verwendet wird, um Trades manuell zu platzieren und zu schließen. Wir untersuchen diesen Indikator, indem wir möglichst viele der verschiedenen möglichen Signale betrachten, die er erzeugt, und sehen, wie sie in einem von einem Assistenten zusammengestellten Expert Advisor verwendet werden können.

Neuinterpretation klassischer Strategien in MQL5 (Teil II): FTSE100 und britische Staatsanleihen

In dieser Artikelserie untersuchen wir beliebte Handelsstrategien und versuchen, sie mithilfe von KI zu verbessern. Im heutigen Artikel greifen wir die klassische Handelsstrategie wieder auf, die auf der Beziehung zwischen dem Aktien- und dem Anleihemarkt basiert.