MetaTrader 5 / Ejemplos
English Русский 中文 Deutsch 日本語
preview
Solicitudes en Connexus (Parte 6): Creación de una solicitud y respuesta HTTP

Solicitudes en Connexus (Parte 6): Creación de una solicitud y respuesta HTTP

MetaTrader 5 — Ejemplos |
35 1
joaopedrodev
joaopedrodev

Introducción

Este artículo es parte de una serie en curso en la que estamos construyendo una biblioteca llamada Connexus. En el primer artículo, tratamos la funcionalidad básica de la función WebRequest, analizando cada uno de sus parámetros y creando un código de ejemplo que muestra su uso y los retos asociados a él. En el artículo anterior, exploramos qué son los métodos HTTP y los códigos de estado devueltos por el servidor, que indican si la solicitud se procesó con éxito o si hubo un error en el lado del cliente o del servidor.

En este sexto artículo de la serie de la biblioteca Connexus, nos centraremos en una solicitud HTTP completa, cubriendo cada componente que la conforma. Crearemos una clase que represente la solicitud en su conjunto, lo que nos ayudará a reunir las clases creadas anteriormente. Además, desarrollaremos una clase similar para manejar la respuesta del servidor, conteniendo los datos de respuesta, el código de estado e incluso la duración de la solicitud.

En la comunicación HTTP, una solicitud se compone de varios componentes que juntos forman la solicitud completa. Ya hemos explorado todos estos componentes en artículos anteriores y hemos creado clases individuales para cada elemento de la solicitud. Resumamos los elementos a continuación:

  • URL: Define la dirección del servidor en la web y se compone de partes más pequeñas, como el dominio, el puerto, la ruta, etc. Esto se trató con más detalle en la Parte 2 de Connexus, donde creamos una clase para dar el formato adecuado a una URL.
  • Encabezado (Header): Son datos adicionales que se envían con la solicitud y cuyo objetivo es proporcionar detalles sobre la solicitud que no forman parte del cuerpo ni de la URL. Esto se trató con más detalle en la Parte 3 de Connexus, donde también creamos una clase responsable de organizar el encabezado de la solicitud.
  • Cuerpo (Body): Se refiere al contenido real que se envía o se recibe. En pocas palabras, el cuerpo es donde se almacenan los datos que nos interesan y que queremos enviar al servidor. En la Parte 4, tratamos este tema con más detalle y también creamos una clase responsable de almacenar el cuerpo de la solicitud, que admite añadir el cuerpo en diferentes formatos, como texto sin formato (string), JSON o char[] (binario).
  • Método HTTP: Los métodos HTTP son utilizados por el cliente para indicar al servidor qué acción desea realizar. Esto se trató con más detalle en la Parte 5 de Connexus.
  • Tiempo de espera: El tiempo de espera no se ha tratado en artículos anteriores, pero, para explicarlo brevemente, es el tiempo en milisegundos que tiene el servidor para responder. Si la solicitud tarda más tiempo del asignado, se cancela, lo que da lugar a un error de tiempo de espera. Este valor puede ser útil para evitar situaciones en las que el servidor tarda demasiado en responder, ya que la función WebRequest es sincrónica, lo que significa que el Asesor Experto permanece «en pausa» mientras espera la respuesta del servidor. Esto podría ser problemático si la solicitud tarda mucho más de lo esperado. Para evitar este escenario, se recomienda utilizar un tiempo de espera. El valor del tiempo de espera puede variar según sus necesidades, pero para la mayoría de los servidores, 5000 milisegundos (5 segundos) son suficientes para que la solicitud se procese correctamente.

Cada uno de estos componentes juega un papel fundamental en la construcción de una solicitud HTTP adecuada, pero es importante tener en cuenta que no todos son obligatorios. Los únicos elementos necesarios son la URL y el método HTTP (GET, POST, PUT, etc.).

Para orientarnos sobre el progreso de la biblioteca y las clases que ya hemos creado, echemos un vistazo al diagrama actual de la biblioteca:

Diagrama actual

Tenga en cuenta que ya disponemos de clases preparadas para gestionar métodos HTTP, códigos de estado, URL con parámetros de consulta, encabezados y el cuerpo.


Patrón de diseño de Facade (fachada)

Para continuar construyendo la biblioteca, implementaremos un patrón de diseño. Si no estás familiarizado con los patrones de diseño, te recomiendo leer la serie de artículos Patrones de diseño en MQL5 (Parte 2): Patrones estructurales, escrito por Mohamed Abdelmaaboud. En esa serie, el autor describe varios patrones de diseño con código de muestra. Para la biblioteca Connexus, implementaremos el patrón de diseño «Facade» (fachada), que es un patrón muy conocido en programación. Este patrón proporciona una interfaz simplificada para un conjunto más complejo de subsistemas, ocultando la complejidad interna y permitiendo al cliente interactuar con el sistema de una forma mucho más sencilla.

Imaginemos un ejemplo en el contexto de la biblioteca: quieres crear una solicitud. Para ello, tendrías que crear una instancia de cada uno de los elementos de la solicitud y configurarlos, algo así:

CURL m_url;
m_url.Parse("http://example.com/api");

CHttpBody m_body;
m_body.AddString("my text");

CHttpHeader m_headers;
m_headers.Add("content-type","text/plain");

CHttpMethod m_method;
m_method = HTTP_METHOD_GET;

int m_timeout = 5000;

Este enfoque hace que el código sea desordenado, requiriendo la creación de múltiples instancias, consumiendo muchas líneas y haciendo que el código sea menos legible. La situación empeora cuando se trabaja con numerosas solicitudes, ya que administrar múltiples objetos, como encabezados, cuerpo y URL, se vuelve complicado y difícil de mantener. Aquí es donde entra en juego el patrón de diseño Facade. Volviendo al concepto: Este patrón proporciona una interfaz simplificada para un conjunto más complejo de subsistemas, ocultando la complejidad interna y permitiendo al cliente interactuar con el sistema de una forma mucho más sencilla.

En este contexto, los subsistemas son las clases para elementos de solicitud como CHttpBody, CHttpHeaders, etc., y el objetivo es crear una interfaz más intuitiva para ellos. Este patrón resuelve el problema introduciendo una clase o interfaz que actúa como una «fachada» para acceder a los subsistemas. El desarrollador final interactúa únicamente con esta interfaz simplificada.

En resumen, la arquitectura Facade ofrece las siguientes ventajas:

  1. Interacción simplificada: En lugar de lidiar directamente con una serie de clases complejas, el desarrollador puede utilizar una interfaz simplificada que oculta los detalles internos.
  2. Acoplamiento reducido: Dado que el cliente no está directamente acoplado a los subsistemas internos, se pueden realizar cambios en estos subsistemas sin afectar al cliente.
  3. Mejora de la mantenibilidad: La clara separación entre la interfaz Facade y los subsistemas internos facilita el mantenimiento y la ampliación del código, ya que cualquier cambio interno puede ser abstraído por la fachada.

¿Cómo se implementaría este patrón de diseño en la biblioteca? Para lograr esto, crearemos una nueva clase llamada CHttpRequest , que contendrá los subsistemas. Para el usuario de la biblioteca, el uso de esta clase debería verse así:

CHttpRequest request;

request.Method() = HTTP_METHOD_GET;
request.Url().Parse("http://example.com/api");
request.Body().AddString("my text");
request.Header().Add("content-type","text/plain");

Observe cómo el código se ha vuelto mucho más simple y legible, que es exactamente la idea detrás de este patrón de diseño. El patrón Facade proporciona una interfaz simplificada (CHttpRequest) para un conjunto más complejo de subsistemas (administración de instancias de CHttpBody, CHttpHeader, etc.), ocultando la complejidad interna y permitiendo al cliente interactuar con el sistema de una manera mucho más simple.


Creación de la clase CHttpRequest

Ahora que entendemos el concepto de Fachada, podemos aplicar esta arquitectura a la clase CHttpRequest. Creemos esta clase dentro de una nueva carpeta llamada "Core". El archivo se llamará HttpRequest.mqh y la ruta final será Include/Connexus/Core/HttpRequest.mqh. Inicialmente, el archivo se verá así: 
//+------------------------------------------------------------------+
//|                                                  HttpRequest.mqh |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| class : CHttpRequest                                             |
//|                                                                  |
//| [PROPERTY]                                                       |
//| Name        : CHttpRequest                                       |
//| Heritage    : No heritage                                        |
//| Description : Gathers elements of an http request such as url,   |
//|               body, header, method and timeout                   |
//|                                                                  |
//+------------------------------------------------------------------+
class CHttpRequest
  {
public:
                     CHttpRequest(void);
                    ~CHttpRequest(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CHttpRequest::CHttpRequest(void)
  {
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CHttpRequest::~CHttpRequest(void)
  {
  }
//+------------------------------------------------------------------+

Importemos las clases creadas en los últimos archivos: CURL, CHttpBody, CHttpHeader y CHttpMethod. Crearemos una instancia de cada uno, añadiendo el símbolo «*» para informar al compilador de que gestionaremos el puntero manualmente. Además, añadiremos una variable llamada m_timeout de tipo int, que almacenará el valor de tiempo de espera para la solicitud. 

//+------------------------------------------------------------------+
//|                                                  HttpRequest.mqh |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| Include files                                                    |
//+------------------------------------------------------------------+
#include "../URL/URL.mqh"
#include "../Header/HttpBody.mqh"
#include "../Header/HttpHeader.mqh"
#include "../Constants/HttpMethod.mqh"
//+------------------------------------------------------------------+
//| class : CHttpRequest                                             |
//|                                                                  |
//| [PROPERTY]                                                       |
//| Name        : CHttpRequest                                       |
//| Heritage    : No heritage                                        |
//| Description : Gathers elements of an http request such as url,   |
//|               body, header, method and timeout                   |
//|                                                                  |
//+------------------------------------------------------------------+
class CHttpRequest
  {
private:

   CURL              *m_url;
   CHttpBody         *m_body;
   CHttpHeader       *m_headers;
   CHttpMethod       *m_method;
   int               m_timeout;

public:
                     CHttpRequest(void);
                    ~CHttpRequest(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CHttpRequest::CHttpRequest(void)
  {
   m_url = new CURL();
   m_body = new CHttpBody();
   m_headers = new CHttpHeader();
   m_method = new CHttpMethod();
   m_timeout = 5000; // Default timeout (5 seconds)
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CHttpRequest::~CHttpRequest(void)
  {
   delete m_url;
   delete m_body;
   delete m_headers;
   delete m_method;
  }
//+------------------------------------------------------------------+

Ahora, agreguemos algunos métodos para acceder al puntero de cada instancia, así como métodos para establecer y obtener el valor de tiempo de espera:

  • CURL *Url(void) : Devuelve el puntero a la URL.
  • CHttpBody *Body(void) : Devuelve el puntero al cuerpo.
  • CHttpHeader *Header(void) : Devuelve el puntero al encabezado.
  • CHttpMethod *Method(void) : Devuelve el puntero al método.
  • CHttpRequest *Timeout(int timeout) : Establece el tiempo de espera.
  • int Timeout(void) : Obtiene el tiempo de espera.

Además de estos métodos, añadiremos algunos métodos auxiliares:

  • void Clear(void) : Elimina todos los datos de las instancias.

  • string FormatString(void) : Genera una cadena que contiene todos los datos de la solicitud.

    Ejemplo de una solicitud con formato:

    HTTP Request:
---------------
Method: GET
URL: https://api.example.com/resource?id=123&filter=active

Headers:
---------------
Authorization: Bearer token
Content-Type: application/json
User-Agent: MyHttpClient/1.0

Body:
---------------
{
    "key": "value",
    "data": [1, 2, 3]
}
---------------

Aquí está la implementación de los métodos. 

//+------------------------------------------------------------------+
//|                                                  HttpRequest.mqh |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| class : CHttpRequest                                             |
//|                                                                  |
//| [PROPERTY]                                                       |
//| Name        : CHttpRequest                                       |
//| Heritage    : No heritage                                        |
//| Description : Gathers elements of an http request such as url,   |
//|               body, header, method and timeout                   |
//|                                                                  |
//+------------------------------------------------------------------+
class CHttpRequest
  {
public:
   //--- HTTP
   CURL              *Url(void);                         // Get url object
   CHttpBody         *Body(void);                        // Get body object
   CHttpHeader       *Header(void);                      // Get header object
   CHttpMethod       *Method(void);                      // Get method object
   
   //--- Timeout
   CHttpRequest      *Timeout(int timeout);              // Set timeout
   int               Timeout(void);                      // Get timeout
   
   //--- Auxiliary methods
   void              Clear(void);                        // Reset data
   string            FormatString(void);                 // Format data
  };
//+------------------------------------------------------------------+
//| Get url object                                                   |
//+------------------------------------------------------------------+
CURL *CHttpRequest::Url(void)
  {
   return(GetPointer(m_url));
  }
//+------------------------------------------------------------------+
//| Get body object                                                  |
//+------------------------------------------------------------------+
CHttpBody *CHttpRequest::Body(void)
  {
   return(GetPointer(m_body));
  }
//+------------------------------------------------------------------+
//| Get header object                                                |
//+------------------------------------------------------------------+
CHttpHeader *CHttpRequest::Header(void)
  {
   return(GetPointer(m_headers));
  }
//+------------------------------------------------------------------+
//| Get method object                                                |
//+------------------------------------------------------------------+
CHttpMethod *CHttpRequest::Method(void)
  {
   return(GetPointer(m_method));
  }
//+------------------------------------------------------------------+
//| Set timeout                                                      |
//+------------------------------------------------------------------+
CHttpRequest *CHttpRequest::Timeout(int timeout)
  {
   m_timeout = timeout;
   return(GetPointer(this));
  }
//+------------------------------------------------------------------+
//| Get timeout                                                      |
//+------------------------------------------------------------------+
int CHttpRequest::Timeout(void)
  {
   return(m_timeout);
  }
//+------------------------------------------------------------------+
//| Reset data                                                       |
//+------------------------------------------------------------------+
void CHttpRequest::Clear(void)
  {
   m_url.Clear();
   m_body.Clear();
   m_headers.Clear();
   m_timeout = 5000;
  }
//+------------------------------------------------------------------+
//| Format data                                                      |
//+------------------------------------------------------------------+
string CHttpRequest::FormatString(void)
  {
   return(
      "HTTP Request:"+
    "\n---------------"+
    "\nMethod: "+m_method.GetMethodDescription()+
    "\nURL: "+m_url.FullUrl()+
    "\n"+
    "\n---------------"+
    "\nHeaders:"+
    "\n"+m_headers.Serialize()+
    "\n"+
    "\n---------------"+
    "\nBody:"+
    "\n"+m_body.GetAsString()+
    "\n---------------"
   );
  }
//+------------------------------------------------------------------+

De este modo, hemos completado esta clase, que sirve como fachada para acceder a los objetos que forman una solicitud HTTP. Es importante tener en cuenta que solo estoy agregando las partes que han sido modificadas en el código. El archivo completo se puede encontrar al final del artículo adjunto.

Con esta nueva clase CHttpRequest, el diagrama de biblioteca actualizado se ve así:

Diagrama 2

En resumen, CHttpRequest actúa como una fachada, simplificando el proceso de configuración y envío de una solicitud HTTP. Internamente, la clase CHttpHeaders maneja la lógica del encabezado, mientras que CHttpBody se encarga de construir el cuerpo de la solicitud. El desarrollador que utiliza esta biblioteca no necesita preocuparse por los detalles de cómo se manejan los encabezados o el cuerpo: simplemente establece los valores utilizando los métodos de CHttpRequest y la clase de fachada se encarga del resto.


Creación de la clase CHttpResponse

Siguiendo la misma idea, creemos otra clase que se utilizará para representar los datos de respuesta del servidor. Seguirá una estructura similar a CHttpRequest . Estos son los elementos que forman una respuesta:

  • Encabezado (Header): Al igual que la solicitud, la respuesta también incluye un encabezado, que informa al cliente con metadatos sobre la solicitud.
  • Cuerpo (Body): Contendrá el cuerpo de la respuesta del servidor. Aquí es donde el servidor envía los datos que queremos obtener, y este es el núcleo del mensaje.
  • Código de estado (Status Code): Contiene el código de estado, que hemos tratado con más detalle en la parte 5 de la serie. Este código es un número de 3 dígitos que indica si la solicitud se ha procesado correctamente o si se ha producido un error en el cliente o el servidor.
  • Duración (Duration): Almacena el tiempo que tardó en completarse la solicitud, medido en milisegundos.

Crearemos un nuevo archivo dentro de la carpeta core llamado HttpResponse , y la ruta final será Include/Connexus/Core/HttpResponse.mqh. La clase creada debería verse así:

//+------------------------------------------------------------------+
//|                                                 HttpResponse.mqh |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| class : CHttpResponse                                            |
//|                                                                  |
//| [PROPERTY]                                                       |
//| Name        : CHttpResponse                                      |
//| Heritage    : No heritage                                        |
//| Description : gathers elements of an http response such as body, |
//|               header, status code and duration                   |
//|                                                                  |
//+------------------------------------------------------------------+
class CHttpResponse
  {
public:
                     CHttpResponse(void);
                    ~CHttpResponse(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CHttpResponse::CHttpResponse(void)
  {
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CHttpResponse::~CHttpResponse(void)
  {
  }
//+------------------------------------------------------------------+

Importaremos los elementos de una respuesta, que son: CHttpHeader, CHttpBody y CHttpStatusCode. Después de esto, crearemos una instancia de cada una de estas clases y también una variable privada de tipo ulong, que almacenará la duración de la solicitud. El código final se verá así:

//+------------------------------------------------------------------+
//|                                                 HttpResponse.mqh |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| Include files                                                    |
//+------------------------------------------------------------------+
#include "../Constants/HttpStatusCode.mqh"
#include "../Header/HttpBody.mqh"
#include "../Header/HttpHeader.mqh"
//+------------------------------------------------------------------+
//| class : CHttpResponse                                            |
//|                                                                  |
//| [PROPERTY]                                                       |
//| Name        : CHttpResponse                                      |
//| Heritage    : No heritage                                        |
//| Description : gathers elements of an http response such as body, |
//|               header, status code and duration                   |
//|                                                                  |
//+------------------------------------------------------------------+
class CHttpResponse
  {
private:
   
   CHttpHeader       *m_header;
   CHttpBody         *m_body;
   CHttpStatusCodes  *m_status_code;
   ulong              m_duration;

public:
                     CHttpResponse(void);
                    ~CHttpResponse(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CHttpResponse::CHttpResponse(void)
  {
   m_header = new CHttpHeader();
   m_body = new CHttpBody();
   m_status_code = new CHttpStatusCodes();
   m_duration = 0; // Reset duration
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CHttpResponse::~CHttpResponse(void)
  {
   delete m_header;
   delete m_body;
   delete m_status_code;
  }
//+------------------------------------------------------------------+

Ahora pasemos a los métodos que se agregarán a esta clase. Comenzaremos con los más simples, que simplemente devuelven los punteros de cada una de las instancias de las clases, y métodos para establecer y obtener la duración:

  • CHttpHeader *Header(void) : Devuelve el puntero al encabezado.
  • CHttpBody *Body(void) : Devuelve el puntero al cuerpo.
  • CHttpStatusCodes *StatusCode(void) : Devuelve el puntero al código de estado.
  • void Duration(ulong duration) : Establece la duración.
  • ulong Duration(void) : Obtiene la duración..

Crearemos los mismos métodos auxiliares para CHttpRequest para esta clase:

  • void Clear(void) : Elimina todos los datos de las instancias.

  • string FormatString(void) : Genera una cadena que contiene todos los datos de la respuesta.

    Ejemplo de una respuesta formateada

    HTTP Response:
---------------
Status Code: 200 OK
Duration: 120ms

Headers:
---------------
Content-Type: application/json
Content-Length: 256
Server: Apache/2.4.41 (Ubuntu)
Date: Wed, 02 Oct 2024 12:34:56 GMT

Body:
---------------
{
    "message": "Success",
    "data": {
        "id": 123,
        "name": "Sample Item",
        "status": "active"
    }
}
---------------

Aquí está el código con la implementación de estas funciones: 

//+------------------------------------------------------------------+
//|                                                 HttpResponse.mqh |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| class : CHttpResponse                                            |
//|                                                                  |
//| [PROPERTY]                                                       |
//| Name        : CHttpResponse                                      |
//| Heritage    : No heritage                                        |
//| Description : gathers elements of an http response such as body, |
//|               header, status code and duration                   |
//|                                                                  |
//+------------------------------------------------------------------+
class CHttpResponse
  {
public:
   //--- HTTP
   CHttpHeader       *Header(void);                      // Get header object
   CHttpBody         *Body(void);                        // Get body object
   CHttpStatusCodes  *StatusCode(void);                  // Get status code object
   
   //--- Duration
   void              Duration(ulong duration);           // Set duration
   ulong             Duration(void);                     // Get duration
   
   //--- Auxiliary methods
   void              Clear(void);                        // Reset data
   string            FormatString(void);                 // Format data
  };
//+------------------------------------------------------------------+
//| Get header object                                                |
//+------------------------------------------------------------------+
CHttpHeader *CHttpResponse::Header(void)
  {
   return(GetPointer(m_header));
  }
//+------------------------------------------------------------------+
//| Get body object                                                  |
//+------------------------------------------------------------------+
CHttpBody *CHttpResponse::Body(void)
  {
   return(GetPointer(m_body));
  };
//+------------------------------------------------------------------+
//| Get status code object                                           |
//+------------------------------------------------------------------+
CHttpStatusCodes *CHttpResponse::StatusCode(void)
  {
   return(GetPointer(m_status_code));
  };
//+------------------------------------------------------------------+
//| Set duration                                                     |
//+------------------------------------------------------------------+
void CHttpResponse::Duration(ulong duration)
  {
   m_duration = duration;
  }
//+------------------------------------------------------------------+
//| Get duration                                                     |
//+------------------------------------------------------------------+
ulong CHttpResponse::Duration(void)
  {
   return(m_duration);
  }
//+------------------------------------------------------------------+
//| Reset data                                                       |
//+------------------------------------------------------------------+
void CHttpResponse::Clear(void)
  {
   m_header.Clear();
   m_body.Clear();
   m_status_code.SetStatusCode(HTTP_STATUS_URL_NOT_ALLOWED);
  }
//+------------------------------------------------------------------+
//| Format data                                                      |
//+------------------------------------------------------------------+
string CHttpResponse::FormatString(void)
  {
   return(
      "HTTP Response:"+
    "\n---------------"+
    "\nStatus Code: "+m_status_code.GetStatusCodeFormat()+
    "\nDuration: "+IntegerToString(m_duration)+" ms"+
    "\n"+
    "\n---------------"+
    "\nHeaders:"+
    "\n"+m_header.Serialize()+
    "\n---------------"+
    "\nBody:"+
    "\n"+m_body.GetAsString()+
    "\n---------------"
   );
  }
//+------------------------------------------------------------------+

Solo para recordarte, aquí solo incluyo los cambios en la clase para que el artículo no se haga demasiado largo. Todo el código utilizado se adjunta al final del artículo.

Con esto concluye la clase de respuesta. Estas son clases relativamente simples y el objetivo es uno: agrupar los elementos de una solicitud o respuesta. De esta manera, podemos trabajar con una solicitud como un único objeto, simplificando significativamente el uso de solicitudes y respuestas HTTP. Con esta nueva clase CHttpResponse, el diagrama actualizado se ve así:

Diagrama 3


Ejemplos de uso

Brevemente, daré algunos ejemplos de uso de estas clases. Comenzando con CHttpRequest, construiré una solicitud HTTP usando esta clase. 

//--- Example 1 - GET
CHttpRequest request;
request.Method() = HTTP_METHOD_GET;
request.Url().Parse("http://example.com/api/symbols");

//--- Example 2 - POST
CHttpRequest request;
request.Method() = HTTP_METHOD_POST;
request.Url().Parse("http://example.com/api/symbols");
request.Body().AddToString("{\"EURUSD\":1.08312}");
request.Header().Add("content-type","application/json");

//--- Example 3 - DELETE
CHttpRequest request;
request.Method() = HTTP_METHOD_DELETE;
request.Url().Parse("http://example.com/api/symbols?symbol=EURUSD");

La gran ventaja aquí es la simplicidad de crear una solicitud, agregar un encabezado y un cuerpo, o cambiar el método HTTP.

Para las respuestas, lo que necesitamos es lo opuesto, es decir, en lugar de crear un objeto de solicitud fácilmente, queremos leer un objeto de respuesta fácilmente, y ambos funcionan de manera similar, lo que permite una creación y lectura sencillas. Incluiré una imagen que muestra cómo se ve la pantalla del desarrollador usando Connexus:

Ejemplo 1

Esto es lo que le aparecerá a usted, el desarrollador. Marqué con diferentes colores cada uno de los datos de respuesta a los que se puede acceder. Accedamos al cuerpo de la respuesta:

Ejemplo 2

Tenga en cuenta que podemos acceder al cuerpo de la respuesta en diferentes formatos, como cadena, json o binario. Aquí accedemos directamente al puntero de la clase CHttpBody, luego accedemos a todos los métodos que tiene. Cuando creamos una clase para cada uno de estos elementos de una respuesta, estaba pensando en llegar a esta parte de la biblioteca, donde usamos cada una de las clases.


Conclusión

En este artículo, exploramos la importancia de tener un objeto CHttpRequest que agrupe todos los componentes de una solicitud HTTP, garantizando claridad, reutilización y fácil mantenimiento del código. También vimos cómo se puede aplicar el patrón de diseño Facade para simplificar la interacción con componentes complejos, ocultando la complejidad interna y ofreciendo una interfaz limpia y eficiente. En el contexto de Connexus, la aplicación del patrón Facade a la clase ChttpRequest facilita la creación de solicitudes HTTP completas, simplificando el proceso para el desarrollador, y también crea la clase CHttpResponse, que sigue el mismo formato, pero que debería facilitar el acceso a los datos de una respuesta HTTP.

En el próximo artículo, profundizaremos en la capa de transporte, que debe recibir un objeto CHttpRequest y convertir los datos a la función WebRequest, que es la capa final de la biblioteca, debe ser capaz de procesar los datos de respuesta y devolver un objeto de tipo CHttpResponse para que el desarrollador pueda utilizar los datos de respuesta. ¡Nos vemos allí!

Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/16182

Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Otros artículos del autor

Últimos comentarios | Pasar a la discusión en el foro de los operadores (1)
Jedidiah
Jedidiah | 6 nov 2024 en 10:39
Has hecho una enorme contribución a mql5 y a todos nosotros. Haciendo más fácil que nunca trabajar con peticiones web y http en general. Esto es excelente. Gracias. No puedo esperar para el artículo final para sellar el acuerdo con la biblioteca connexus.
Algoritmo de Tribu Artificial (Artificial Tribe Algorithm, ATA) Algoritmo de Tribu Artificial (Artificial Tribe Algorithm, ATA)
Este artículo detalla los componentes clave y las innovaciones del algoritmo de optimización ATA, un método evolutivo con un sistema de comportamiento dual único que se adapta según la situación. Usando el cruce para la exploración en profundidad y la migración para la búsqueda cuando se dan atascos en óptimos locales, el ATA combina el aprendizaje individual y el social.
Redes neuronales en el trading: Framework comercial híbrido con codificación predictiva (StockFormer) Redes neuronales en el trading: Framework comercial híbrido con codificación predictiva (StockFormer)
Hoy le presentamos el StockFormer, un sistema comercial híbrido que combina algoritmos de codificación predictiva y de aprendizaje por refuerzo (RL). El framework utiliza 3 ramas del Transformer con un mecanismo Diversified Multi-Head Attention (DMH-Attn) integrado que mejora el módulo de atención vainilla gracias a un bloque Feed-Forward multicabeza que permite captar diversos patrones de series temporales en diferentes subespacios.
Criterios de tendencia en el trading Criterios de tendencia en el trading
Las tendencias son una parte importante de muchas estrategias comerciales. En este artículo analizaremos algunas de las herramientas utilizadas para identificar tendencias y sus características. Comprender e interpretar correctamente las tendencias puede mejorar sustancialmente los resultados comerciales y minimizar los riesgos.
Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 1): Proyector de gráficos Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 1): Proyector de gráficos
Este proyecto tiene como objetivo aprovechar el lenguaje MQL5 para desarrollar un conjunto integral de herramientas de análisis para MetaTrader 5. Estas herramientas, que van desde scripts e indicadores hasta modelos de IA y asesores expertos, automatizarán el proceso de análisis del mercado. En ocasiones, este desarrollo producirá herramientas capaces de realizar análisis avanzados sin intervención humana y pronosticar resultados para las plataformas adecuadas. Ninguna oportunidad jamás se perderá. Únase a mí mientras exploramos el proceso de creación de un conjunto sólido de herramientas personalizadas para el análisis de mercado. Comenzaremos desarrollando un programa MQL5 simple que he llamado "Proyector de gráficos" (Chart Projector).