Requête HTTP du serveur Multiplay

16min
Vous pouvez effectuer des requêtes HTTP depuis le serveur Multiplay de ZEPETO en utilisant le module ZEPETO.Multiplay.HttpService. Intégrez des services web externes dans vos opérations de logique métier, stockage de données, analyse statistique, suivi des erreurs, et plus encore.
﻿
Veuillez vous assurer que seul le protocole HTTPS est utilisé, tandis que HTTP n'est pris en charge que dans l'environnement de développement.
Les requêtes ne sont autorisées que sur les ports 80 et 443.
La taille maximale des corps de requête et de réponse est limitée à 16 Ko.
Gardez le nombre de requêtes par minute en dessous de 500 pour éviter d'éventuelles limitations sur le service mondial en cas de requêtes excessives.
Les requêtes échoueront si les services web externes ne répondent pas dans les 5 secondes.
Assurez-vous que le type de contenu dans les en-têtes de réponse correspond aux valeurs définies dans le HttpContentType enum ; sinon, les requêtes échoueront.
Étant donné la possibilité que les requêtes web échouent pour diverses raisons, il est recommandé de coder de manière défensive.
﻿
ZEPETO.Multiplay.HttpService
📘 Veuillez vous référer au guide suivant. [API ZEPETO.Multiplay.HttpService]
﻿
Méthodes
Méthode
Description
HttpService.getAsync(url: string, headers?: HttpHeader): Promise
Effectuer des requêtes HTTP GET de manière asynchrone.
.[Paramètres]
- url : L'adresse web à laquelle envoyer la requête.
- headers : En-têtes de requête HTTP. (Optionnel)

[Valeur de retour]
- Promise<HttpResponse> : Renvoie un objet HttpResponse contenant des informations sur la réponse sous forme de Promise
HttpService.postAsync(url: string, body: HttpBodyType, headers?: HttpHeader): Promise
Effectuer des requêtes HTTP POST de manière asynchrone.
.[Paramètres]
- url : L'adresse web à laquelle envoyer la requête.
- body : Le contenu du corps de la requête.
- headers : En-têtes de requête HTTP. (Optionnel)

[Valeur de retour]
- Promise<HttpResponse> : Renvoie un objet HttpResponse contenant des informations sur la réponse sous forme de Promise
HttpService.postAsync(url: string, body: HttpBodyType, httpContentType: HttpContentType, headers?: HttpHeader): Promise
Effectuer des requêtes HTTP POST de manière asynchrone.
.[Paramètres]
- url : L'adresse web à laquelle envoyer la requête.
- body : Le contenu du corps de la requête.
- httpContentType : Spécifie l'en-tête Content-Type de la requête.
- headers : En-têtes de requête HTTP. (Optionnel)

[Valeur de retour]
- Promise<HttpResponse> : Renvoie un objet HttpResponse contenant des informations sur la réponse sous forme de Promise.

Lorsque vous utilisez cette signature, si vous ajoutez 'Content-Type' aux en-têtes, il sera écrasé par ce qui est spécifié dans httpContentType
Autres Déclarations
Déclaration
Description
HttpContentType
Énumération de constantes qui spécifient le Content-Type pour les en-têtes HTTP.

- ApplicationJson : 'application/json'
- ApplicationXml : 'application/xml'
- ApplicationUrlEncoded : 'application/x-www-form-urlencoded'
- TextPlain : 'text/plain'
- TextXml : 'text/xml'
HttpBodyType
Type pour le contenu du corps de la requête HTTP, qui peut être soit une chaîne, soit un objet avec des clés de chaîne et des valeurs quelconques.
HttpHeader
Type pour définir les en-têtes de requête HTTP, où les valeurs des propriétés peuvent être soit des chaînes, soit des nombres dans l'objet.
HttpResponse
Interface qui inclut des informations sur le résultat de la requête HTTP et les données de réponse.

- statusCodeHTTP : Un nombre représentant le code d'état de la réponse. En général, 200 indique une requête réussie.
- statusTextHTTP : Une chaîne représentant le message d'état de la réponse. En général, "OK" indique une requête réussie.
- response : Une chaîne contenant les données du corps de la réponse HTTP.
📘 Statut HTTP
https://developer.mozilla.org/en-US/docs/Web/HTTP/Status﻿
﻿
Exemples de code
Requête GET de base
Créons un exemple simple de requête GET en utilisant HttpService.getAsync. Lorsqu'un nouveau client se connecte à la salle Multiplay, nous enverrons une requête HTTP à un service web externe et enregistrerons le résultat.
﻿restcountries.com est une API ouverte qui fournit des informations sur divers pays. Nous utiliserons ce service pour découvrir la capitale du Japon.
Configurez Multiplay, puis ouvrez World.multiplay/index.ts et écrivez le script du serveur comme suit.
📘 Veuillez vous référer au guide suivant. [Multiplay﻿]
﻿
TypeScript
import { Sandbox, SandboxOptions, SandboxPlayer } from "ZEPETO.Multiplay";
import { HttpService } from "ZEPETO.Multiplay.HttpService";

export default class extends Sandbox {

    onCreate(options: SandboxOptions) { }
    onJoin(client: SandboxPlayer) { this.findCapitalCity() }
    onLeave(client: SandboxPlayer, consented?: boolean) { }

    findCapitalCity() {
        // Faire la requête à l'API restcountries
        HttpService.getAsync("https://restcountries.com/v3.1/name/japan?fields=capital")
            // Gestionnaire pour la réponse HTTP   
            .then((httpResponse) => {
                // Analyser les données de réponse JSON de l'API (qui sont imbriquées dans la réponse HTTP)
                let countries = JSON.parse(httpResponse.response);
                console.log("La capitale du Japon est :");
                console.log(`${countries[0].capital}`);
            });
    }
}
import { Sandbox, SandboxOptions, SandboxPlayer } from "ZEPETO.Multiplay";
import { HttpService } from "ZEPETO.Multiplay.HttpService";

export default class extends Sandbox {

    onCreate(options: SandboxOptions) { }
    onJoin(client: SandboxPlayer) { this.findCapitalCity() }
    onLeave(client: SandboxPlayer, consented?: boolean) { }

    findCapitalCity() {
        // Faire la requête à l'API restcountries
        HttpService.getAsync("https://restcountries.com/v3.1/name/japan?fields=capital")
            // Gestionnaire pour la réponse HTTP   
            .then((httpResponse) => {
                // Analyser les données de réponse JSON de l'API (qui sont imbriquées dans la réponse HTTP)
                let countries = JSON.parse(httpResponse.response);
                console.log("La capitale du Japon est :");
                console.log(`${countries[0].capital}`);
            });
    }
}
﻿
Description du code :
Lorsqu'un client se connecte à la salle Multiplay, la onJoin fonction est déclenchée, et elle appelle findCapitalCity.
Si l'getAsync appel à l'API restcountries est réussi, vous pouvez accéder à l'httpResponse objet dans le then rappel.
Analyser httpResponse.response pour convertir la réponse de l'API, qui est au format JSON, en un objet.
En vous référant à la structure de la réponse de l'API, vous accédez aux propriétés souhaitées et imprimez ensuite leurs valeurs.
Lorsque vous exécutez le serveur Multiplay dans l'éditeur Unity et jouez la scène, les éléments suivants seront affichés dans la console.
Text
La ville capitale du Japon est : 
Tokyo
La ville capitale du Japon est : 
Tokyo
﻿
Pratiques de codage défensif
En attendant, comme mentionné dans les précautions introductives, les requêtes web peuvent échouer pour diverses raisons, y compris des changements d'adresses web ou de formats de réponse API.
Le fait de ne pas gérer correctement ces requêtes peut avoir divers effets néfastes sur le jeu mondial, il est donc recommandé de coder de manière défensive, surtout lors de la gestion des requêtes HTTP.
Voici un exemple d'application de plusieurs techniques de codage défensif au code ci-dessus.
TypeScript
   findCapitalCity() {
    // Faire la requête à l'API restcountries
    HttpService.getAsync(
        "https://restcountries.com/v3.1/name/japan?fields=capital",
        { 'Accept': HttpContentType.ApplicationJson })
        // Gestionnaire pour la réponse HTTP
        .then((httpResponse) => {
            // Vérifier si l'appel API a retourné 200(OK) ou non
            if (httpResponse.statusCode != 200) {
                // Si ce n'était pas 200(OK), ne pas continuer et lever une erreur personnalisée
                throw (`Erreur API : ${httpResponse.statusCode} ${httpResponse.statusText}`);
            }
            // Retourner les données de réponse JSON de l'API
            return httpResponse.response;
        })
        // Gestionnaire pour les données de réponse JSON de l'API
        .then((response) => {
            // Analyser les données de réponse JSON
            let countries = JSON.parse(response);
            // Vérifier si les données de réponse API sont valides
            if (!Array.isArray(countries) || !countries.length) {
                // Si ce n'est pas un tableau, ou est vide
                // ne pas continuer et lever une erreur personnalisée
                throw (`Erreur API : Les données de réponse ne sont pas valides`);
            }
            let country = countries[0];
            // Vérifier si le champ 'capital' est valide
            if (!country.capital) {
                // Si le champ 'capital' n'existe pas, ou est vide
                // ne pas continuer et lever une erreur personnalisée
                throw (`Erreur API : champ 'capital' non valide`);
            }
            console.log("La ville capitale du Japon est :")
            console.log(`${country.capital}`);
        })
        // Gestionnaire pour les erreurs survenant dans l'appel getAsync et les clauses 'then'.
        .catch((reason) => {
            console.log("Erreur de requête API");
            console.log(reason);
        });
}
   findCapitalCity() {
    // Faire la requête à l'API restcountries
    HttpService.getAsync(
        "https://restcountries.com/v3.1/name/japan?fields=capital",
        { 'Accept': HttpContentType.ApplicationJson })
        // Gestionnaire pour la réponse HTTP
        .then((httpResponse) => {
            // Vérifier si l'appel API a retourné 200(OK) ou non
            if (httpResponse.statusCode != 200) {
                // Si ce n'était pas 200(OK), ne pas continuer et lever une erreur personnalisée
                throw (`Erreur API : ${httpResponse.statusCode} ${httpResponse.statusText}`);
            }
            // Retourner les données de réponse JSON de l'API
            return httpResponse.response;
        })
        // Gestionnaire pour les données de réponse JSON de l'API
        .then((response) => {
            // Analyser les données de réponse JSON
            let countries = JSON.parse(response);
            // Vérifier si les données de réponse API sont valides
            if (!Array.isArray(countries) || !countries.length) {
                // Si ce n'est pas un tableau, ou est vide
                // ne pas continuer et lever une erreur personnalisée
                throw (`Erreur API : Les données de réponse ne sont pas valides`);
            }
            let country = countries[0];
            // Vérifier si le champ 'capital' est valide
            if (!country.capital) {
                // Si le champ 'capital' n'existe pas, ou est vide
                // ne pas continuer et lever une erreur personnalisée
                throw (`Erreur API : champ 'capital' non valide`);
            }
            console.log("La ville capitale du Japon est :")
            console.log(`${country.capital}`);
        })
        // Gestionnaire pour les erreurs survenant dans l'appel getAsync et les clauses 'then'.
        .catch((reason) => {
            console.log("Erreur de requête API");
            console.log(reason);
        });
}
﻿
Les techniques de codage défensif appliquées ici incluent les suivantes :
Utiliser l'Accept en-tête : L'Accept en-tête est utilisé pour spécifier le Content-Type attendu pour le corps de la réponse. Selon le serveur, le Content-Type de la réponse peut être ajusté en fonction de l'Accept en-tête.
Vérification de HttpResponse.statusCode: La HttpResponse.statusCode propriété est utilisée pour vérifier le succès de la requête.
Validation de la structure des données JSON : Vous confirmez si la structure des données de l'objet analysé avec JSON.parse correspond à la structure attendue.
Vérification de l'existence des propriétés : Vous vous assurez que les propriétés que vous avez l'intention d'utiliser existent réellement dans l'objet.
Utilisation de la méthode catch de la promesse : La catch méthode de la promesse est utilisée pour gérer les erreurs qui peuvent survenir lors des requêtes API et du traitement des réponses.
Ces techniques protègent le code pour fonctionner de manière fiable face à des erreurs inattendues, renforçant ainsi sa robustesse.
﻿
Intégration avec les clients via les messages de salle
Les requêtes HTTP ne sont possibles que depuis le serveur Multiplay.
Cependant, en utilisant les messages de salle Multiplay, vous pouvez déclencher le serveur pour envoyer des requêtes HTTP à des services web externes depuis le client et utiliser les réponses au sein du client.
L'exemple suivant démontre l'intégration client-serveur. Dans cette démonstration, lorsque un bouton de l'interface utilisateur du client est pressé, la capitale du pays correspondant au bouton est affichée.
📘 Veuillez vous référer au guide suivant. [Message de la salle multiplay﻿]
﻿
﻿
﻿
Code Client
TypeScript
import { ZepetoScriptBehaviour } from 'ZEPETO.Script'
import { Room } from 'ZEPETO.Multiplay'
import { ZepetoWorldMultiplay } from 'ZEPETO.World';
import { Button, Text } from 'UnityEngine.UI'

export default class SampleScript extends ZepetoScriptBehaviour {

    public multiplay: ZepetoWorldMultiplay;
    public room: Room;
    public countryButtons: Button[];
    public capitalText: Text;


    Start() {
        interface Response {
            capitals: string[]
        }

        for (const countryButton of this.countryButtons) {
            countryButton.onClick.AddListener(() => {
                if (this.room !== null) {
                    // Envoyer le nom du pays en tant que message de type 'client-à-serveur' au serveur
                    this.room.Send("client-to-server", countryButton.GetComponentInChildren<Text>().text);
                }
            });
        };

        this.multiplay.RoomCreated += (room: Room) => {
            this.room = room;
            // Gérer les messages reçus avec un type 'serveur-à-client'
            this.room.AddMessageHandler("server-to-client", (message: Response) => {
                // Pour les pays avec plusieurs capitales,
                // joindre les éléments de chaîne avec ', ' et afficher sur la scène
                this.capitalText.text = message.capitals.join(", ");
            });
        };
    }
}
import { ZepetoScriptBehaviour } from 'ZEPETO.Script'
import { Room } from 'ZEPETO.Multiplay'
import { ZepetoWorldMultiplay } from 'ZEPETO.World';
import { Button, Text } from 'UnityEngine.UI'

export default class SampleScript extends ZepetoScriptBehaviour {

    public multiplay: ZepetoWorldMultiplay;
    public room: Room;
    public countryButtons: Button[];
    public capitalText: Text;


    Start() {
        interface Response {
            capitals: string[]
        }

        for (const countryButton of this.countryButtons) {
            countryButton.onClick.AddListener(() => {
                if (this.room !== null) {
                    // Envoyer le nom du pays en tant que message de type 'client-à-serveur' au serveur
                    this.room.Send("client-to-server", countryButton.GetComponentInChildren<Text>().text);
                }
            });
        };

        this.multiplay.RoomCreated += (room: Room) => {
            this.room = room;
            // Gérer les messages reçus avec un type 'serveur-à-client'
            this.room.AddMessageHandler("server-to-client", (message: Response) => {
                // Pour les pays avec plusieurs capitales,
                // joindre les éléments de chaîne avec ', ' et afficher sur la scène
                this.capitalText.text = message.capitals.join(", ");
            });
        };
    }
}
﻿
Description du code :
Nous définissons un écouteur qui itère à travers les boutons affichant les noms des pays. Lorsqu'il est cliqué, cet écouteur envoie un message de salle au serveur Multiplay.
Cet écouteur envoie le nom du pays affiché sur le bouton en tant que message de type 'client-à-serveur'.
Pour gérer les réponses, nous définissons également un écouteur pour traiter les messages de salle reçus en tant que type 'serveur-à-client'.
Cet écouteur affiche le nom de la capitale reçu du serveur à l'écran. S'il y a plusieurs capitales, elles sont affichées à l'écran, séparées par des virgules.
﻿
Code Serveur
TypeScript
import { Sandbox, SandboxOptions, SandboxPlayer } from "ZEPETO.Multiplay";
import { HttpService } from "ZEPETO.Multiplay.HttpService";

export default class extends Sandbox {

    onCreate(options: SandboxOptions) {
        // Gérer les messages reçus avec un type 'client-to-server'
        this.onMessage("client-to-server", (client, message) => {
            console.log(`Client ${client.userId} a envoyé une demande. Message: ${message}`);
            this.findCapitalCity(message, client);
        });
    }

    onJoin(client: SandboxPlayer) { }
    onLeave(client: SandboxPlayer, consented?: boolean) { }

    findCapitalCity(countryName: string, client: SandboxPlayer) {
        // Demander à l'API avec le countryName comme paramètre de chemin
        // Le countryName est envoyé par le client comme message de salle
        HttpService.getAsync(`https://restcountries.com/v3.1/name/${countryName}?fields=capital`)
            .then((httpResponse) => {
                if (httpResponse.statusCode != 200) {
                    throw (`Erreur API: ${httpResponse.statusCode} ${httpResponse.statusText}`);
                }
                return httpResponse.response;
            })
            .then((response) => {
                let countries = JSON.parse(response);
                if (!Array.isArray(countries) || !countries.length) {
                    throw (`Erreur API: Les données de réponse ne sont pas valides`);
                }
                let country = countries[0];
                if (!country.capital) {
                    throw (`Erreur API: Le champ 'capital' n'est pas valide`);
                }
                // Envoyer un message de type 'server-to-client' au client
                // Le message est un objet contenant les noms des capitales
                client.send("server-to-client", {
                    "capitals": country.capital
                });
            })
            .catch((reason) => {
                console.log("Erreur de demande API");
                console.log(reason);
            });
    }
}
import { Sandbox, SandboxOptions, SandboxPlayer } from "ZEPETO.Multiplay";
import { HttpService } from "ZEPETO.Multiplay.HttpService";

export default class extends Sandbox {

    onCreate(options: SandboxOptions) {
        // Gérer les messages reçus avec un type 'client-to-server'
        this.onMessage("client-to-server", (client, message) => {
            console.log(`Client ${client.userId} a envoyé une demande. Message: ${message}`);
            this.findCapitalCity(message, client);
        });
    }

    onJoin(client: SandboxPlayer) { }
    onLeave(client: SandboxPlayer, consented?: boolean) { }

    findCapitalCity(countryName: string, client: SandboxPlayer) {
        // Demander à l'API avec le countryName comme paramètre de chemin
        // Le countryName est envoyé par le client comme message de salle
        HttpService.getAsync(`https://restcountries.com/v3.1/name/${countryName}?fields=capital`)
            .then((httpResponse) => {
                if (httpResponse.statusCode != 200) {
                    throw (`Erreur API: ${httpResponse.statusCode} ${httpResponse.statusText}`);
                }
                return httpResponse.response;
            })
            .then((response) => {
                let countries = JSON.parse(response);
                if (!Array.isArray(countries) || !countries.length) {
                    throw (`Erreur API: Les données de réponse ne sont pas valides`);
                }
                let country = countries[0];
                if (!country.capital) {
                    throw (`Erreur API: Le champ 'capital' n'est pas valide`);
                }
                // Envoyer un message de type 'server-to-client' au client
                // Le message est un objet contenant les noms des capitales
                client.send("server-to-client", {
                    "capitals": country.capital
                });
            })
            .catch((reason) => {
                console.log("Erreur de demande API");
                console.log(reason);
            });
    }
}
﻿
Description du code:
Nous définissons un écouteur qui, lors de la réception d'un message de salle Multiplay de type 'client-à-serveur', appelle findCapitalCity.
Nous construisons une adresse pour le message de salle Multiplay en utilisant le nom du pays et faisons un getAsync appel.
Si l'getAsync appel est réussi, la réponse est traitée comme dans les exemples précédents.
Le nom de la ville capitale obtenu à partir de la réponse de l'API restcountries est envoyé au client sous forme de message de salle de type 'serveur-à-client'.
﻿
Requête POST
Enfin, créons un exemple de requête POST en utilisant HttpService.postAsync.
﻿postman-echo est un service qui fournit des réponses structurées montrant quel contenu a été reçu des requêtes web, ce qui le rend efficace pour vérifier si le client a correctement configuré la requête.
À travers cet exemple, nous allons configurer une requête POST avec des paramètres de requête, un corps de requête et des en-têtes et nous assurer que la requête est correctement configurée.
Configurez Multiplay, puis ouvrez World.multiplay/index.ts et écrivez le script du serveur comme suit.
TypeScript
import { Sandbox, SandboxOptions, SandboxPlayer } from "ZEPETO.Multiplay";
import { HttpContentType, HttpService } from "ZEPETO.Multiplay.HttpService";

export default class extends Sandbox {

    onCreate(options: SandboxOptions) { }
    onJoin(client: SandboxPlayer) { this.echoPost() }
    onLeave(client: SandboxPlayer, consented?: boolean) { }

    echoPost() {
        HttpService.postAsync(
            // Point de terminaison API avec un paramètre de requête
            "https://postman-echo.com/post?argKey=argValue",
            // Corps de la requête JSON
            { "dataKey": "dataValue" },
            // Type de contenu de la requête
            HttpContentType.ApplicationJson,
            // En-tête HTTP
            { "header-key": "header-value" })
            .then((httpResponse) => {
                if (httpResponse.statusCode != 200) {
                    throw (`Erreur API: ${httpResponse.statusCode} ${httpResponse.statusText}`);
                }
                return httpResponse.response;
            })
            .then((response) => {
                let parsed = JSON.parse(response);
                console.log(`Paramètre de requête: argKey:${parsed.args.argKey}`);
                console.log(`Corps de la requête: dataKey:${parsed.data.dataKey}`);
                console.log(`En-tête de la requête: header-key:${parsed.headers["header-key"]}`)
            })
            .catch((reason) => {
                console.log("Erreur de requête API");
                console.log(reason);
            });
    }
}
import { Sandbox, SandboxOptions, SandboxPlayer } from "ZEPETO.Multiplay";
import { HttpContentType, HttpService } from "ZEPETO.Multiplay.HttpService";

export default class extends Sandbox {

    onCreate(options: SandboxOptions) { }
    onJoin(client: SandboxPlayer) { this.echoPost() }
    onLeave(client: SandboxPlayer, consented?: boolean) { }

    echoPost() {
        HttpService.postAsync(
            // Point de terminaison API avec un paramètre de requête
            "https://postman-echo.com/post?argKey=argValue",
            // Corps de la requête JSON
            { "dataKey": "dataValue" },
            // Type de contenu de la requête
            HttpContentType.ApplicationJson,
            // En-tête HTTP
            { "header-key": "header-value" })
            .then((httpResponse) => {
                if (httpResponse.statusCode != 200) {
                    throw (`Erreur API: ${httpResponse.statusCode} ${httpResponse.statusText}`);
                }
                return httpResponse.response;
            })
            .then((response) => {
                let parsed = JSON.parse(response);
                console.log(`Paramètre de requête: argKey:${parsed.args.argKey}`);
                console.log(`Corps de la requête: dataKey:${parsed.data.dataKey}`);
                console.log(`En-tête de la requête: header-key:${parsed.headers["header-key"]}`)
            })
            .catch((reason) => {
                console.log("Erreur de requête API");
                console.log(reason);
            });
    }
}
﻿
Description du code :
Lorsqu'un client se connecte à la salle Multiplay, la echoPost fonction est appelée depuis le onJoin déclencheur.
Lors de la création de la postAsync demande :
Dans le premier paramètre, nous construisons la chaîne d'URL avec des paramètres de requête.
Dans le deuxième paramètre, nous définissons le contenu du corps de la requête.
Dans le quatrième paramètre, nous configurons l'en-tête de la requête.
Pour spécifier que le corps de la requête est au format JSON, nous définissons le 'application/json' Content-Type dans le troisième paramètre.
Si l'appel postAsync est réussi, nous pouvons accéder à l'httpResponse objet dans le then callback.
Nous analysons httpResponse.response pour convertir la réponse de l'API au format JSON en un objet.
En nous référant à la structure de la réponse de l'API, nous utilisons la sortie Console pour vérifier si les paramètres de requête, le corps de la requête et l'en-tête de la requête de notre requête HTTP sont correctement configurés.
Lorsque vous exécutez le serveur Multiplay dans l'éditeur Unity et que vous jouez la scène, ce qui suit sera affiché dans la console.
Text
Paramètre de requête : argKey:argValue
Corps de la requête : dataKey:dataValue
En-tête de la requête : header-key:header-value
Paramètre de requête : argKey:argValue
Corps de la requête : dataKey:dataValue
En-tête de la requête : header-key:header-value
﻿
﻿
Méthode	Description
HttpService.getAsync(url: string, headers?: HttpHeader): Promise	Effectuer des requêtes HTTP GET de manière asynchrone. .[Paramètres] - url : L'adresse web à laquelle envoyer la requête. - headers : En-têtes de requête HTTP. (Optionnel) [Valeur de retour] - Promise<HttpResponse> : Renvoie un objet HttpResponse contenant des informations sur la réponse sous forme de Promise
HttpService.postAsync(url: string, body: HttpBodyType, headers?: HttpHeader): Promise	Effectuer des requêtes HTTP POST de manière asynchrone. .[Paramètres] - url : L'adresse web à laquelle envoyer la requête. - body : Le contenu du corps de la requête. - headers : En-têtes de requête HTTP. (Optionnel) [Valeur de retour] - Promise<HttpResponse> : Renvoie un objet HttpResponse contenant des informations sur la réponse sous forme de Promise
HttpService.postAsync(url: string, body: HttpBodyType, httpContentType: HttpContentType, headers?: HttpHeader): Promise	Effectuer des requêtes HTTP POST de manière asynchrone. .[Paramètres] - url : L'adresse web à laquelle envoyer la requête. - body : Le contenu du corps de la requête. - httpContentType : Spécifie l'en-tête Content-Type de la requête. - headers : En-têtes de requête HTTP. (Optionnel) [Valeur de retour] - Promise<HttpResponse> : Renvoie un objet HttpResponse contenant des informations sur la réponse sous forme de Promise. Lorsque vous utilisez cette signature, si vous ajoutez 'Content-Type' aux en-têtes, il sera écrasé par ce qui est spécifié dans httpContentType
Déclaration	Description
HttpContentType	Énumération de constantes qui spécifient le Content-Type pour les en-têtes HTTP. - ApplicationJson : 'application/json' - ApplicationXml : 'application/xml' - ApplicationUrlEncoded : 'application/x-www-form-urlencoded' - TextPlain : 'text/plain' - TextXml : 'text/xml'
HttpBodyType	Type pour le contenu du corps de la requête HTTP, qui peut être soit une chaîne, soit un objet avec des clés de chaîne et des valeurs quelconques.
HttpHeader	Type pour définir les en-têtes de requête HTTP, où les valeurs des propriétés peuvent être soit des chaînes, soit des nombres dans l'objet.
HttpResponse	Interface qui inclut des informations sur le résultat de la requête HTTP et les données de réponse. - statusCodeHTTP : Un nombre représentant le code d'état de la réponse. En général, 200 indique une requête réussie. - statusTextHTTP : Une chaîne représentant le message d'état de la réponse. En général, "OK" indique une requête réussie. - response : Une chaîne contenant les données du corps de la réponse HTTP.
Mis à jour 27 Nov 2024
Cette page vous a-t-elle aidée?
Restreindre temporairement l'accès à la salle dans le mode multijoueur
Stockage de Données Mondial