---
title: Requête HTTP du serveur Multiplay
slug: world-sdk-guide-fr/requete-http-du-serveur-multiplay
docTags:
createdAt: 2024-09-02T08:34:13.135Z
---
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.
:::hint{type="danger"}
- 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
:::hint{type="info"}
**📘 **Veuillez vous référer au guide suivant. \[[API ZEPETO.Multiplay.HttpService](https://developer.zepeto.me/docs/multiplay-server/interfaces/ZEPETO_Multiplay_HttpService.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\ : 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\ : 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\ : 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. |
:::hint{type="info"}
**📘 Statut HTTP**
[https://developer.mozilla.org/en-US/docs/Web/HTTP/Status](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](https://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.
:::hint{type="info"}
**📘 **Veuillez vous référer au guide suivant. \[[Multiplay](docId\:qOQCo4ojNwLlL4uM8ZMzD)]
:::
```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}`);
});
}
}
```
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
```
### 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);
});
}
```
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.
:::hint{type="info"}
**📘 **Veuillez vous référer au guide suivant. \[[Message de la salle multiplay](docId\:M0wK142xsx834bmXmUem9)]
:::
**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);
}
});
};
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);
});
}
}
```
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](https://postman-echo.com/) 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);
});
}
}
```
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
```