Introducción a Connexus (Parte 1): ¿Cómo utilizar la función WebRequest?
61
0
Introducción
En el mundo de la programación financiera, especialmente en el contexto de MetaTrader 5, la capacidad de interactuar con servidores remotos a través de HTTP es vital. Ya sea para obtener datos del mercado en tiempo real, enviar órdenes comerciales a una API o incluso consultar servicios de terceros, las solicitudes HTTP juegan un papel crucial. En MQL5, la función WebRequest es la herramienta nativa proporcionada para este tipo de comunicaciones, pero sus limitaciones la hacen poco práctica en muchos escenarios.
HTTP (Hypertext Transfer Protocol) es la base de la comunicación web, y dominar su uso permite a los desarrolladores crear integraciones ricas y dinámicas entre MetaTrader 5 y otros servicios. Por ejemplo, un Asesor Experto (Expert Advisor, EA) puede necesitar acceder a una API de noticias para ajustar sus estrategias de negociación en función de los acontecimientos mundiales. Otra aplicación común es consultar los precios de las criptomonedas en las bolsas que ofrecen API HTTP, lo que permite al EA operar en sincronía con estos mercados.
A pesar de la importancia de las peticiones HTTP, la implementación de la función WebRequest en MQL5 no es exactamente lo que cabría esperar de una herramienta moderna y flexible. Esto pone a los desarrolladores ante un reto: adaptarse a las limitaciones o buscar soluciones. La serie de artículos que iniciamos aquí pretende precisamente eso: explorar los puntos débiles de la función WebRequest y construir una biblioteca, Connexus, que supere estas limitaciones y facilite el trabajo de los desarrolladores de MQL5.
La función WebRequest abre una amplia gama de posibilidades de integración con servicios externos. Desde la recopilación de datos financieros, que pueden ser esenciales para tomar decisiones comerciales automatizadas, hasta la automatización total de procesos, esta función permite a los EA interactuar directamente con la web. Esto permite, por ejemplo, que su robot comercial obtenga información en tiempo real de fuentes externas, como noticias económicas o datos de mercado de otras plataformas. Estos datos se pueden procesar y utilizar para ajustar automáticamente sus estrategias comerciales, aumentando tanto la precisión como la eficiencia de sus operaciones.
Sin embargo, como se demostrará en los ejemplos presentados, el uso de la función WebRequest puede no ser trivial. Enviar una solicitud HTTP puede parecer simple, pero rápidamente encontrará desafíos técnicos, como enviar los encabezados correctos, formatear datos JSON, manejar adecuadamente las respuestas del servidor e incluso lidiar con errores y excepciones que puedan ocurrir durante la comunicación. Estos desafíos ilustrarán que, si bien es poderosa, la función requiere una sólida comprensión de los protocolos y la comunicación entre sistemas, lo que puede presentar una barrera importante para los desarrolladores que recién comienzan a explorar esta área.
Aquí es exactamente donde surge la necesidad de una herramienta más accesible y eficiente. La biblioteca Connexus, que se desarrollará y mejorará en los próximos artículos de esta serie, tiene como objetivo superar estas limitaciones y hacer que el proceso de integración a través de WebRequest sea más fácil de usar e intuitivo. Con Connexus, la idea será que los desarrolladores puedan centrarse en lo que realmente importa: la lógica de sus aplicaciones y EA, sin tener que lidiar directamente con los detalles técnicos de las capas inferiores de la programación de la red. En lugar de perder tiempo depurando errores de formato o de encabezado, podrá concentrarse en integrar sus sistemas de manera eficiente, con una interfaz clara y funcional.
Esta serie de artículos estará dedicada a explorar en profundidad las debilidades de la función WebRequest, sus limitaciones y cómo las solucionaremos al desarrollar una solución sólida. Además de continuar la discusión del protocolo HTTP, cubriremos aspectos como la autenticación en APIs, el manejo de grandes volúmenes de datos y la implementación de características avanzadas como el control del tiempo de respuesta y el manejo de múltiples solicitudes simultáneas.
Entonces, si estás interesado en mejorar tus habilidades de desarrollo MQL5, aprender más sobre integración de sistemas y optimizar los procesos de comunicación HTTP, permanece atento a las próximas publicaciones. Seguiremos ampliando el alcance de este proyecto, guiándole en el desarrollo de la biblioteca Connexus para que se convierta en una herramienta indispensable en su arsenal de desarrollo. Los conocimientos adquiridos aquí serán útiles no sólo para quienes trabajan con MetaTrader, sino también para cualquier desarrollador que necesite integrar API y servicios web en sus aplicaciones.
Conociendo WebRequest
La función WebRequest es la herramienta principal proporcionada por MQL5 para realizar solicitudes HTTP. En términos simples, permite que un programa MQL5 envíe una solicitud a un servidor y reciba una respuesta. Aunque pueda parecer simple, el uso práctico de WebRequest revela una serie de trampas y complejidades que pueden complicar el desarrollo.
La sintaxis básica de la función tiene dos versiones:
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 );
Los parámetros de la función WebRequest son vitales para su correcto funcionamiento, y una comprensión detallada de ellos es esencial para cualquier desarrollador que quiera utilizarla de manera efectiva. Exploremos cada uno de estos parámetros:
| Nombre del parámetro | Tipo | Entrada/Salida | Descripción |
|---|---|---|---|
| method | string | Entrada | Este parámetro define el tipo de solicitud HTTP que desea realizar. Los tipos más comunes son GET y POST. El tipo GET se utiliza para solicitar datos de un servidor, mientras que el tipo POST se utiliza para enviar datos al servidor. |
| url | string | Entrada | Esta es la dirección del servidor al que se enviará la solicitud. La URL debe estar completa, incluido el protocolo (http o https). |
| headers | string | Entrada | Se pueden pasar encabezados HTTP adicionales como una matriz de cadenas. Cada cadena debe tener el formato "Key: Value". Estas cabeceras se utilizan para pasar información adicional, como tokens de autenticación o tipo de contenido, separados por una nueva línea «\r\n». |
| cookie | string | Entrada | Valor de la cookie. |
| referer | string | Entrada | Valor del encabezado Referer de la solicitud HTTP. |
| timeout | int | Entrada | Establece el tiempo máximo de espera para recibir una respuesta del servidor, en milisegundos. Un tiempo de espera adecuado es crucial para garantizar que el EA no se quede atascado esperando una respuesta que puede que nunca llegue. |
| data | char[] | Entrada | Para las solicitudes POST, este parámetro se utiliza para enviar los datos al servidor. Estos datos deben estar en forma de una matriz de bytes, lo que puede resultar un desafío para los desarrolladores que no están familiarizados con el manejo de datos binarios. |
| data_size | int | Entrada | Este es el tamaño de los datos a enviar. Debe coincidir con el tamaño de la matriz de datos para que la solicitud funcione correctamente. |
| result | char[] | Salida | Este parámetro recibe la respuesta del servidor, también como una matriz de bytes. Después de llamar a la función, es necesario decodificar la matriz para extraer la información útil. |
| result_headers | string | Salida | Esta matriz de cadenas recibe los encabezados de respuesta del servidor, que pueden contener información importante como el tipo de contenido y el estado de autenticación. |
Cada uno de estos ajustes debe configurarse cuidadosamente para garantizar que la solicitud se realice correctamente. Un error en cualquiera de estos parámetros puede resultar en una solicitud mal formada o en una falla total en la comunicación con el servidor.
La función devuelve un código de estado HTTP que indica el éxito o el fracaso de la operación. Si bien WebRequest cubre los conceptos básicos, su implementación deja mucho que desear. Requiere que el desarrollador administre manualmente la creación de encabezados, el manejo de diferentes tipos de datos y la verificación de errores, lo que hace que el proceso sea tedioso y propenso a errores. Una de las ventajas de WebRequest es que admite solicitudes GET y POST, lo que le permite interactuar con una amplia gama de API.
Ejemplo práctico de la función WebRequest
Para ilustrar el uso de la función WebRequest, construyamos un ejemplo simple. Para ello utilizaremos httpbin.org, que es un servicio online gratuito que permite realizar y probar peticiones HTTP. Fue creado por kennethreitz, es un proyecto OpenSource (enlace). Este servicio funciona de forma muy sencilla y sin complicaciones. Es básicamente un "espejo". Te pones frente al espejo y adoptas una pose o haces una pregunta. Esto es como enviar una solicitud a HTTP Bin. El espejo refleja exactamente lo que estás haciendo. Esto es como si HTTP Bin recibiera y reflejara lo que enviaste. Es una herramienta útil para los desarrolladores que desean comprobar exactamente qué se envía en sus solicitudes HTTP o que necesitan simular diferentes tipos de solicitudes y respuestas. Algunas características comunes de httpbin incluyen:
- Enviando peticiones: Puedes enviar peticiones HTTP de diferentes tipos, como GET, POST, PUT, DELETE, etc., para ver cómo responde el servidor.
- Pruebas de encabezado HTTP: Puedes enviar cabeceras personalizadas y ver la respuesta del servidor, lo cual es útil para depurar problemas relacionados con las cabeceras.
- Envío de datos en el cuerpo de la petición: Es posible probar el envío de datos en el cuerpo de la petición y ver cómo lo gestiona el servidor.
- Simulación de estado HTTP: Puede solicitar al servidor que devuelva códigos de estado específicos, como 200, 404, 500, etc., para probar cómo maneja su aplicación diferentes respuestas de estado.
- Simulación de retardos y redireccionamientos: httpbin.org permite simular retardos de respuesta o redireccionamientos, ayudando a probar el comportamiento del sistema en escenarios más complejos.
- Pruebas de cookies: Puedes manipular las cookies, viendo cómo son establecidas y devueltas por el servidor.
Es una herramienta práctica para integrar sistemas que utilizan el protocolo HTTP. Hagamos la solicitud GET más simple posible usando WebRequest.
Paso 1: Añadir la URL en el Terminal
Según la documentación: para utilizar la función WebRequest(), agregue las direcciones de servidor requeridas a la lista de URL permitidas en la pestaña "Herramientas" de la ventana "Opciones". El puerto del servidor se selecciona automáticamente en función del protocolo especificado: 80 para «http://» y 443 para «https://».
Paso 2: Manos a la obra con el código
En el directorio <carpeta_de_datos>/MQL5/Experts , cree una carpeta llamada Connexus. Colocaremos nuestros archivos de prueba en esta carpeta. Para encontrar la carpeta de datos, en el menú principal de MetaTrader o MetaEditor, seleccione Archivo > Abrir carpeta de datos. Dentro de esa carpeta, crea un archivo llamado «WebRequest.mq5» y tendrás algo como esto:
//+------------------------------------------------------------------+ //| 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() { //--- } //+------------------------------------------------------------------+
Solo usaremos el evento OnInit() para pruebas por ahora. Definamos algunas variables para realizar la solicitud y pasarlas a la función 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); }
Cuando insertamos el robot en el gráfico, la terminal imprimirá la siguiente respuesta:
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)
Tenga en cuenta que el código de estado recibido fue 200, lo que significa que la solicitud fue exitosa y en la respuesta recibimos un JSON con algunos datos. En el próximo artículo exploraremos con más detalle cómo funciona la comunicación a través del protocolo HTTP. Ahora cambiaremos el verbo HTTP a POST y enviaremos datos en el cuerpo de la solicitud.
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); }
Bien, ahora tenemos todo funcionando, considerando que httpbin devolverá todo lo que enviemos, debería devolver el cuerpo que enviamos, ¿verdad? Al ejecutar el código POST se devolverá:
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)
Tenga en cuenta que tenemos algunos campos adicionales, como “json” y “data”. Entendamos cada uno de ellos. El campo “data” debe mostrar el cuerpo que enviamos en formato de cadena, mientras que el campo “json” debe mostrar el cuerpo que enviamos en formato JSON. Pero ¿por qué ambos están vacíos si enviamos el cuerpo en la solicitud? Porque tenemos que informar al servidor que el tipo de contenido será JSON. Para ello configuramos el encabezado de la solicitud, de la siguiente manera:
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)
Tenga en cuenta que ahora los datos que enviamos están en el campo “data”, lo que indica que estamos en el camino correcto, pero observe que el carácter \u0000 aparece porque el método StringToCharArray incluye el terminador nulo al convertir la cadena en una matriz de bytes. Para evitar esto, podemos ajustar el tamaño de la matriz. Imprimamos el cuerpo que estamos enviando para ver de dónde viene este carácter “\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)
Tenga en cuenta que la cadena del cuerpo es JSON válido, es decir, abre y cierra corchetes, los valores están separados por comas y respeta la regla clave:valor. Veamos la matriz de bytes que genera la función StringToCharArray. Tenga en cuenta que imprime el tamaño de la cadena y la matriz, pero son diferentes. La matriz de bytes es una posición más grande que la cadena. Observe también que en la lista de valores, el último valor es «0» donde debería ser 125, que es el carácter «}». Así que para solucionarlo, eliminaremos la última posición del 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)
Ahora, el tamaño de la cadena y la matriz están alineados, y el servidor encontró correctamente el contenido como JSON válido. Esto se puede proporcionar en la respuesta de retorno, donde el servidor devuelve el JSON enviado en los campos "json" y "data". Después de algunas configuraciones, pudimos realizar una solicitud HTTP POST simple, enviando los datos correctamente. Sin embargo, utilizar la función WebRequest no es trivial; requiere una buena comprensión de cómo funciona el protocolo y las estructuras que estamos manipulando. A menudo, incluso los pequeños inconvenientes pueden volverse complicados, como vimos al ajustar el código para obtener una respuesta válida. El objetivo de la librería Connexus es precisamente simplificar este proceso, permitiendo al usuario final no tener que lidiar con estas capas inferiores y más abstractas de programación, evitando problemas complejos como el que nos enfrentamos ahora, haciendo el uso de WebRequest más accesible y eficiente.
Conclusión
A lo largo de este artículo, hemos explorado en detalle el uso de la función WebRequest en MetaTrader 5, una herramienta esencial para los desarrolladores que buscan ampliar las capacidades de sus Asesores Expertos (EA) comunicándose con servidores externos y API. Hemos utilizado el servicio httpbin.org como ejemplo práctico para realizar solicitudes GET y POST, enviar y recibir datos en formato JSON y comprender las respuestas del servidor. Esta introducción es sólo el comienzo de un viaje de integración de sistemas a través de HTTP, proporcionando la base para proyectos mucho más complejos en el futuro.
El viaje apenas comienza. Juntos, transformemos la función WebRequest en una herramienta simplificada, potente y accesible, simplificando el desarrollo de Asesores Expertos y abriendo puertas a nuevas posibilidades de automatización e integración en MetaTrader 5.
Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/15795
Aprendiendo MQL5 de principiante a profesional (Parte V): Operadores básicos para redirigir el flujo de comandos
Redes neuronales en el trading: Transformer para nubes de puntos (Pointformer)
Aplicación de la selección de características localizadas en Python y MQL5
Redes neuronales en el trading: Aprendizaje jerárquico de características en nubes de puntos
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso