Modèle d'objet JavaScript

Cette page s'applique à Apigee et à Apigee hybrid.

Consultez la documentation d'Apigee Edge.

Cet article présente le modèle d'objet JavaScript Apigee. Il est important de comprendre ce modèle si vous comptez utiliser la règle JavaScript pour ajouter du code JavaScript personnalisé à un proxy d'API.

À propos du modèle d'objet JavaScript

Le modèle d'objet JavaScript définit des objets avec des propriétés associées qui sont disponibles pour le code JavaScript s'exécutant dans un flux de proxy Apigee. Utilisez la règle JavaScript pour associer ce code personnalisé à un flux de proxy d'API.

Les objets définis par ce modèle ont un champ d'application dans le flux de proxy d'API, ce qui signifie que certains objets et certaines propriétés ne sont disponibles qu'à des points précis du flux. Lorsque votre code JavaScript est exécuté, un champ d'application est créé pour l'exécution. Dans ce champ d'application, ces références d'objet sont créées :

  • context : objet permettant d'accéder au contexte du message
  • request : raccourci permettant d'accéder à l'objet de la requête
  • response : forme abrégée autorisant l'accès à l'objet de la réponse
  • crypto : fournit diverses fonctions de hachage
  • print : fonction permettant d'émettre des résultats
  • properties : permet l'accès en lecture aux propriétés de configuration de la règle.

Objet de contexte

L'objet context possède un champ d'application global. Il est disponible partout dans le flux de proxy d'API. Il comporte quatre objets enfants : proxyRequest, proxyResponse, targetRequest, targetResponse. Ces objets enfants sont limités à la requête et à la réponse ambiantes (soit la requête et la réponse du proxy, soit la requête et la réponse cibles). Par exemple, si la règle JavaScript s'exécute dans la partie du flux dédiée au point de terminaison du proxy, les objets context.proxyRequest et context.proxyResponse sont dans le champ d'application. Si le code JavaScript s'exécute dans un flux cible, les objets context.targetRequest et context.targetResponse sont dans le champ d'application.

L'objet context possède également des propriétés et des méthodes décrites en détail sur cette page. Par exemple, l'exemple de code JavaScript suivant utilise la propriété context.flow et appelle les méthodes get/setVariable() sur context.

if (context.flow=="PROXY_REQ_FLOW") {
     var username = context.getVariable("request.formparam.user");
     context.setVariable("USER.name", username);
}

Ces méthodes interagissent directement avec les variables de flux. La valeur de la propriété context.flow correspond au champ d'application du flux actuel. Dans le flux de requête du proxy, cette valeur est définie sur la constante PROXY_REQ_FLOW. Dans le flux de réponse cible, elle est définie sur TARGET_RESP_FLOW. Cette constante est pratique pour exécuter du code spécifique au champ d'application. La méthode "getter" vous permet d'obtenir des variables de flux, tandis que la méthode "setter" vous permet de définir des variables de flux. Ces variables sont généralement disponibles dans le flux de proxy et peuvent être consommées par d'autres règles.

Pour obtenir plus de détails et d'exemples, consultez la documentation de référence sur les objets de contexte.

Objet de cryptographie

L'objet de cryptographie ajoute une compatibilité cryptographique de base et hautes performances au modèle d'objet JavaScript. Pour en savoir plus et obtenir des exemples, consultez la documentation de référence sur les objets de cryptographie.

Objets de requête et de réponse

Les objets request et response sont des références courtes à la requête et à la réponse ambiantes (soit la requête et la réponse du proxy, soit la requête et la réponse cibles). Les objets auxquels ces variables font référence dépendent du contexte dans lequel la règle JavaScript s'exécute. Si le code JavaScript s'exécute dans le flux d'un point de terminaison de proxy, les variables de requête et de réponse font référence à context.proxyRequest et context.proxyResponse. Si le code JavaScript s'exécute dans un flux cible, les variables font référence à context.targetRequest et context.targetResponse.

Le modèle d'objet JavaScript inclut une fonction print() que vous pouvez utiliser pour envoyer des informations de débogage à l'outil Debug Apigee. Consultez la section Déboguer avec les instructions JavaScript print().

Objet de propriétés

Lorsque vous utilisez un élément Properties dans la configuration de la règle, le code JavaScript peut accéder aux valeurs de ces propriétés à l'aide de la variable properties.

Par exemple, si votre configuration JavaScript contient les éléments suivants :

<Javascript name='JS-1' >
  <Properties>
    <Property name="number">8675309</Property>
    <Property name="firstname">Jenny</Property>
  </Properties>
  <ResourceURL>jsc://my-code.js</ResourceURL>
</Javascript>

Ensuite, dans my-code.js, vous pouvez :

  print(properties.firstname);  // prints Jenny
  print(properties.number);  // 8675309

Plus précisément, la configuration peut permettre au code de se comporter différemment lorsqu'il est exécuté dans différents environnements, à différents moments et pour une raison quelconque.

Par exemple, ce qui suit spécifie le "nom de variable" et le style de sortie dans lesquels le code JavaScript doit émettre des informations :

<Javascript name='JS-2' >
  <Properties>
    <Property name="output">my_output_variable</Property>
    <Property name="prettyPrint">true</Property>
  </Properties>
  <ResourceURL>jsc://emit-results.js</ResourceURL>
</Javascript>
Ensuite, dans emit-results.js, le code peut effectuer cette opération :
var result = { prop1: "something", prop2 : "something else" } ;
if (properties.prettyPrint == "true") {
  context.setVariable(properties.output, JSON.stringify(result, null, 2));
}
else {
  context.setVariable(properties.output, JSON.stringify(result));
}

Référence de l'objet de cryptographie

L'objet de cryptographie vous permet d'effectuer des fonctions de hachage de base en JavaScript.

L'objet de cryptographie a un champ d'application global. Il est disponible partout dans le flux de proxy d'API. L'objet de cryptographie vous permet de travailler avec les objets de hachage suivants :

  • SHA-1
  • SHA256
  • SHA512
  • MD5

Utiliser des objets SHA-1

Vous pouvez créer des objets SHA-1, les mettre à jour et les convertir en valeurs hexadécimales et base64.

Créer un objet SHA-1

var _sha1 = crypto.getSHA1();

Mettre à jour un objet SHA-1

Syntaxe

_sha1.update(value);

Paramètres

  • value : (chaîne) toute valeur de chaîne.

Exemple

Mettre à jour un objet SHA-1 :

_sha1.update("salt_value");

_sha1.update("some text");

Renvoyer l'objet SHA-1 sous forme de chaîne hexadécimale

var _hashed_token = _sha1.digest();

Renvoyer l'objet SHA-1 sous forme de chaîne base64

var _hashed_token = _sha1.digest64();

Utiliser des objets SHA-256

Vous pouvez créer des objets SHA-256, les mettre à jour et les convertir en valeurs hexadécimales et base64.

Créer un objet SHA-256

var _sha256 = crypto.getSHA256();

Mettre à jour un objet SHA-256

Syntaxe

_sha256.update(value);

Paramètres

  • value : (chaîne) toute valeur de chaîne.

Exemple

Mettre à jour un objet SHA-256 :

_sha256.update("salt_value");

_sha256.update("some text");

Renvoyer l'objet SHA-256 sous forme de chaîne hexadécimale

var _hashed_token = _sha256.digest();

Renvoyer l'objet SHA-256 sous forme de chaîne base64

var _hashed_token = _sha256.digest64();

Utiliser des objets SHA-512

Vous pouvez créer des objets SHA-512, les mettre à jour et les convertir en valeurs hexadécimales et base64.

Créer un objet SHA-512

var _sha512 = crypto.getSHA512();

Mettre à jour un objet SHA-512

Syntaxe

_sha512.update(value);

Paramètres

  • value : (chaîne) toute valeur de chaîne.

Exemple

Mettre à jour un objet SHA-512 :

_sha512.update("salt_value");

_sha512.update("some text");

Renvoyer l'objet SHA-512 sous forme de chaîne hexadécimale

var _hashed_token = _sha512.digest();

Renvoyer l'objet SHA-512 sous forme de chaîne base64

var _hashed_token = _sha512.digest64();

Utiliser des objets MD5

Vous pouvez créer des objets MD5, les mettre à jour et les convertir en valeurs hexadécimales et base64.

Créer un objet MD5

var _md5 = crypto.getMD5();

Mettre à jour un objet MD5

Syntaxe

_md5.update(value);

Paramètres

  • value : (chaîne) toute valeur de chaîne.

Exemple

Mettre à jour un objet MD5 :

_md5.update("salt_value");

_md5.update("some text");

Renvoyer l'objet MD5 sous forme de chaîne hexadécimale

var _hashed_token = _md5.digest();

Renvoyer l'objet MD5 sous forme de chaîne base64

var _hashed_token = _md5.digest64();

Compatibilité date et heure de cryptographie

L'objet de cryptographie accepte les formats de date et heure.

crypto.dateFormat()

Renvoie une date au format de chaîne.

Syntaxe

crypto.dateFormat(format, [timezone], [time])

Paramètres

  • format : (chaîne) l'implémentation sous-jacente pour ce paramètre est java.text.SimpleDateFormat. Exemple : AAAA-MM-JJ HH:mm:ss.SSS.
  • timezone : (chaîne, facultatif) l'implémentation sous-jacente pour ce paramètre est java.util.TimeZone. Ce paramètre est le même paramètre par défaut : UTC.
  • time : (nombre, facultatif) valeur de code temporel UNIX à formater. Valeur par défaut : heure actuelle

Exemples

Obtenir la durée actuelle, en millisecondes :

var _now = crypto.dateFormat('YYYY-MM-DD HH:mm:ss.SSS');

Obtenir l'heure actuelle dans le fuseau horaire du Pacifique :

var _pst = crypto.dateFormat('YYYY-MM-DD HH:mm:ss.SSS','PST');

Obtenir la valeur de dix secondes à partir de maintenant :

var _timeNow = Number(context.getVariable('system.timestamp'));
var tenSeconds = crypto.dateFormat('YYYY-MM-DD HH:mm:ss.SSS','PST', _timeNow + 10 * 1000);

Exemples supplémentaires. Consultez également la documentation java.text.SimpleDateFormat.

var _pst = crypto.dateFormat('M');
var _pst = crypto.dateFormat('EEE, d MMM yyyy HH:mm:ss Z');
var _pst = crypto.dateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");

Utiliser getHash() pour obtenir l'un des objets de hachage compatibles

Exemples

var _hash1 = crypto.getHash('MD5');

var _hash2 = crypto.getHash('SHA-1');

var _hash3 = crypto.getHash('SHA-256');

var _hash4 = crypto.getHash('SHA-512');

Exemple avec l'objet de cryptographie

try {
    // get values to use with hash functions
    var salt = context.getVariable("salt") || 'SomeHardCodedSalt';
    var host = context.getVariable("request.header.Host");
    var unhashedToken = "";

    var _timeNow = Number(context.getVariable('system.timestamp'));
    var now = crypto.dateFormat('YYYY-MM-DD HH:mm:ss.SSS','PST', _timeNow);
    unhashed_token = "|" + now + "|" + host

    // generate a hash with the unhashedToken:
    var sha512 = crypto.getSHA512();
    sha512.update(salt);
    sha512.update(unhashedToken);

    // convert to base64
    var base64Token = sha512.digest64();

    // set headers
    context.setVariable("request.header.now", now);
    context.setVariable("request.header.token", base64Token);

} catch(e) {
    throw 'Error in Javascript';
}

Référence de l'objet de contexte

Un objet context est créé pour chaque transaction de requête/réponse exécutée par un proxy d'API. L'objet context expose des méthodes permettant d'obtenir, de définir et de supprimer des variables associées à chaque transaction.

Les variables définissent des propriétés spécifiques à une transaction. L'heure de la journée, les paramètres régionaux du client demandeur, le user-agent du client demandeur et l'URL du service cible sont autant d'exemples de variables disponibles dans context. Par conséquent, context est utile pour créer une logique qui s'appuie sur ces propriétés afin d'exécuter un comportement personnalisé.

Consultez les articles Documentation de référence sur les variables de flux et Règle ExtractVariables.

résumé de l'objet de contexte

Ce tableau décrit brièvement l'objet de contexte et ses enfants, et répertorie les propriétés qui leur sont liées.

Nom Description Propriétés
context Wrapper pour le contexte du pipeline de traitement des messages et les flux de requêtes et de réponses exécutés par les points de terminaison ProxyEndpoint et TargetEndpoint flux, session
context.proxyRequest Objet représentant le message de requête entrante à ProxyEndpoint (depuis l'application à l'origine de la requête vers le proxy d'API) en-têtes, paramètres de requête, méthode, corps, url
context.targetRequest Objet représentant le message de requête sortant du TargetEndpoint (depuis le proxy d'API vers le service de backend) en-têtes, paramètres de requête, méthode, corps, url
context.targetResponse Objet représentant le message de réponse cible entrant (du service de backend au proxy d'API) en-têtes, contenu, état
context.proxyResponse Objet représentant le message de réponse du proxy sortant (du proxy de l'API à l'application l'origine de la demande) en-têtes, contenu, état
context.flow Nom du flux actuel Voir context.flow.
context.session Correspondance des paires nom/valeur que vous pouvez utiliser pour transmettre des objets entre deux étapes différentes exécutées dans le même contexte. Exemple : context.session['key'] = 123. Pour savoir quand et où ne pas utiliser cet objet, consultez les sections Quelle est la différence entre context.session['hello'] = {} et context.setVariable("hello", {}).

méthodes de l'objet de contexte

context.getVariable()

Récupère la valeur d'une variable prédéfinie ou personnalisée.

Syntaxe

context.getVariable("variable-name");

Exemple

Pour obtenir la valeur de l'année en cours, procédez comme suit :

var year = context.getVariable('system.time.year');

context.setVariable()

Définit la valeur d'une variable personnalisée ou de toutes les variables prédéfinies accessibles en écriture.

Syntaxe

context.setVariable("variable-name", value);

Exemple

Il est par exemple courant de définir une variable lorsqu'un proxy d'API doit écrire l'URL cible de manière dynamique. Le code JavaScript suivant obtient la valeur d'une variable appelée USER.name, ajoute cette valeur en tant que paramètre de requête à l'URL http://mocktarget.apigee.net?user=, puis définit la target.url prédéfinie sur cette valeur.

context.setVariable("target.url", "http://mocktarget.apigee.net/user?user="+context.getVariable("USER.name"));

context.removeVariable()

Supprime une variable du contexte.

Syntaxe

context.removeVariable('variable-name');

propriétés de l'objet de contexte

context.flow

La propriété flow est une chaîne qui identifie le flux de proxy d'API actuel. Cette propriété est utilisée pour indiquer le flux auquel le code JavaScript est associé. Les valeurs compatibles sont les suivantes :

  • PROXY_REQ_FLOW
  • PROXY_RESP_FLOW
  • TARGET_REQ_FLOW
  • TARGET_RESP_FLOW

Chaque nom de flux englobe les flux PreFlow, PostFlow et les flux conditionnels définis dans les objets ProxyEndpoint ou TargetEndpoint.

Cette propriété facultative est utile lorsque du code JavaScript courant est exécuté dans plusieurs flux, mais peut varier son comportement en fonction du flux dans lequel il s'exécute. Utilisez la propriété "Flow" pour les modules JavaScript destinés à être réutilisés dans plusieurs proxys d'API, dans lesquels le code est requis pour vérifier le flux en cours avant d'exécuter la logique.

Exemple

Définissez un en-tête HTTP uniquement sur le flux targetRequest :

if (context.flow=="TARGET_REQ_FLOW") {
     context.targetRequest.headers['TARGET-HEADER-X']='foo';
}

Définissez le contenu uniquement sur le flux proxyResponse :

if (context.flow=="PROXY_RESP_FLOW") {
     context.proxyResponse.content='bar';
}

context.session

Correspondance des paires nom/valeur qui peuvent être utilisées pour transmettre des objets entre deux règles s'exécutant dans le même contexte de message.

Exemple

Définissez une valeur dans la session :

context.session['key']  = 123;

Obtenez la valeur de la session :

var value = context.session['key']; // 123

enfants de l'objet de contexte

Comme indiqué ci-dessous, un flux de proxy d'API complet comprend quatre phases distinctes, chacune associée à un objet de message qui est un enfant de l'objet de contexte :

  • context.proxyRequest : message de requête entrant provenant du client demandeur
  • context.targetRequest : message de requête sortant envoyé au service de backend
  • context.proxyResponse : message de réponse sortant renvoyé au client demandeur
  • context.targetResponse : message de requête entrant reçu par le service de backend

Schéma d&#39;une requête et d&#39;une réponse passant par un point de terminaison de proxy et un point de terminaison cible

Les sections suivantes décrivent les méthodes et propriétés de ces objets :

objets enfants context.*Request

Pour chaque transaction HTTP exécutée par un proxy d'API, deux objets de message de requête sont créés : un entrant (requête du client) et un sortant (requête générée par le proxy d'API, puis envoyée à la cible de backend).

L'objet context contient des objets enfants qui représentent ces messages de requête : context.proxyRequest et context.targetRequest. Ces objets vous permettent d'accéder aux propriétés du flux de requêtes incluses dans le champ d'application lors de l'exécution de votre code JavaScript.

propriétés de l'enfant de l'objet context.*Demander

Nom de propriété Description
url

La propriété url est une propriété de facilité de lecture/écriture combinant le schéma, l'hôte, le port, le chemin d'accès et les paramètres de requête pour targetRequest.

L'URL complète de la requête est composée des propriétés suivantes :

  • protocole : protocole de l'URL (HTTP ou HTTPS, par exemple)
  • port : port (par exemple, :80, :443)
  • host : hôte de l'URL (par exemple, www.example.com)
  • path : le chemin de l'URI (par exemple, /v1/mocktarget)

Lorsque vous obtenez url, une URL est renvoyée au format suivant :

protocol://host:port/path?queryParams

Exemples :

context.targetRequest.url = 'http://www.example.com/path?q1=1'
context.targetRequest.protocol ='https';
headers

En-têtes de requêtes HTTP sous forme de mappage de String => List

Exemples :

Pour cette requête HTTP :

POST /v1/blogs HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z
Le code JavaScript suivant :
context.proxyRequest.headers['Content-Type'];
context.proxyRequest.headers['Authorization'];

renvoie les valeurs suivantes :

application/json
Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z
queryParams

Paramètres de requête du message de requête sous forme de mappage de String => List.

Exemples :

"?city=PaloAlto&city=NewYork"

est accessible comme suit :

context.proxyRequest.queryParams['city'];  // == 'PaloAlto'
context.proxyRequest.queryParams['city'][0]     // == 'PaloAlto'
context.proxyRequest.queryParams['city'][1];    // == 'NewYork'
context.proxyRequest.queryParams['city'].length(); // == 2
method

Verbe HTTP (GET, POST, PUT, DELETE, PATCH, etc.) associé à la requête

Exemples :

Pour cette requête :

POST /v1/blogs HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z

Le code JavaScript suivant :

context.proxyRequest.method;

renvoie la valeur suivante :

POST
body

Corps du message (charge utile) de la requête HTTP.

Le corps de la requête comprend les membres suivants :

  • context.targetRequest.body.asXML;
  • context.targetRequest.body.asJSON;
  • context.targetRequest.body.asForm;

Exemples :

Pour un corps XML :

<customer number='1'>
<name>Fred<name/>
<customer/>

Pour accéder aux éléments de l'objet XML, procédez comme suit :

var name = context.targetRequest.body.asXML.name;

Pour accéder aux attributs XML, utilisez la notation @.

var number = context.targetRequest.body.asXML.@number;

Pour un corps de requête JSON :

{
"a":  1 ,
"b" : "2"
}
var a = context.proxyRequest.body.asJSON.a;    // == 1
var b = context.proxyRequest.body.asJSON.b;    // == 2

Pour lire les paramètres de format :

"vehicle=Car&vehicle=Truck"
v0 = context.proxyRequest.body.asForm['vehicle'][0];
v1 = context.proxyRequest.body.asForm['vehicle'][1];

objets enfants context.*Response

Pour chaque transaction HTTP exécutée par un proxy d'API, deux objets de message de réponse sont créés : un entrant (réponse du service de backend) et un sortant (la valeur la réponse est renvoyée au client).

L'objet de contexte contient des objets enfants qui représentent ces messages de réponse : context.proxyResponse et context.targetResponse. Ces objets vous permettent d'accéder aux propriétés du flux de réponses incluses dans le champ d'application lors de l'exécution de votre code JavaScript.

Propriété de l'objet context.*Response

Nom de propriété Description
headers

En-têtes HTTP du message de réponse sous forme de mappage de String => List.

Exemple :

var cookie = context.targetResponse.headers['Set-Cookie'];
status

Code d'état avec le message d'état en tant que propriété. Le code d'état et le message d'état sont tous deux disponibles en tant que propriétés.

Exemple :

var status = context.targetResponse.status.code;   // 200
var msg = context.targetResponse.status.message;   // "OK"
content

Corps HTTP (contenu de la charge utile) du message de réponse.

Le contenu de la réponse contient les membres suivants :

context.targetResponse.content.asXML;
context.targetResponse.content.asJSON;

Utiliser la notation .asXML

Il existe un moyen pratique de parcourir un document XML avec la notation .asXML. Cette section explique comment utiliser cette notation, et comment elle se distingue de request.content et context.proxyRequest.content.

Exemple :

request.content.asXML

ou

context.proxyRequest.content.asXML

Les formes *.content et *.content.asXML peuvent toutes deux être utilisées dans un contexte de chaîne, et JavaScript les convertira par coercition pour former des chaînes. Dans le premier cas (*.content), la chaîne inclut toutes les déclarations ainsi que les commentaires XML. Dans ce dernier cas (*.content.asXML), la valeur de chaîne du résultat est nettoyée des déclarations et des commentaires.

Exemple

msg.content:

<?xml version="1.0" encoding="UTF-8"?>
<yahoo:error xmlns:yahoo="http://yahooapis.com/v1/base.rng" xml:lang="en-US">
   <yahoo:description>Please provide valid credentials. OAuth oauth_problem="unable_to_determine_oauth_type", realm="yahooapis.com"
   </yahoo:description>
</yahoo:error>
<!-- mg023.mail.gq1.yahoo.com uncompressed/chunked Sat Dec 14 01:23:35 UTC 2013 -->

msg.content.asXML:

<?xml version="1.0" encoding="UTF-8"?>
<yahoo:error xmlns:yahoo="http://yahooapis.com/v1/base.rng" xml:lang="en-US">
   <yahoo:description>Please provide valid credentials. OAuth oauth_problem="unable_to_determine_oauth_type", realm="yahooapis.com"
   </yahoo:description>
</yahoo:error>

De plus, vous pouvez utiliser le format .asXML pour parcourir la hiérarchie XML en spécifiant le nom des éléments et des attributs. Il n'est pas possible de parcourir la hiérarchie avec l'autre syntaxe.

Déboguer avec des instructions print() JavaScript

Si vous utilisez la règle JavaScript pour exécuter du code JavaScript personnalisé, notez que vous pouvez utiliser la fonction print() pour générer des informations de débogage dans l'outil Debug. Cette fonction est disponible directement via le modèle d'objet JavaScript. Exemple :

if (context.flow=="PROXY_REQ_FLOW") {
     print("In proxy request flow");
     var username = context.getVariable("request.queryparam.user");
     print("Got query param: " + username);
     context.setVariable("USER.name", username);
     print("Set query param: " + context.getVariable("USER.name"));
}


if (context.flow=="TARGET_REQ_FLOW") {
     print("In target request flow");
     var username = context.getVariable("USER.name");
     var url = "http://mocktarget.apigee.net/user?"
     context.setVariable("target.url", url + "user=" + username);
     print("Callout to URL: ", context.getVariable("target.url"));
}

Pour afficher la sortie, sélectionnez Sortie de toutes les transactions en bas de la fenêtre Debug. Vous pouvez également trouver des résultats dans la propriété Debug appelée stepExecution-stdout.

Effectuer des appels JavaScript avec httpClient

Utilisez httpClient pour effectuer plusieurs requêtes HTTP asynchrones parallèles vers n'importe quelle URL à partir d'un code JavaScript personnalisé s'exécutant dans un flux de proxy d'API. L'objet httpClient est exposé par le modèle d'objet JavaScript Apigee.

À propos de httpClient

L'objet httpClient est exposé à un code JavaScript personnalisé s'exécutant sur Apigee par le biais du modèle d'objet JavaScript. Pour associer un code JavaScript personnalisé à un proxy d'API, utilisez la règle JavaScript. Lorsque la règle s'applique, le code JavaScript personnalisé s'exécute.

L'objet httpClient est utile pour développer des services ou des applications composites. Par exemple, vous pouvez regrouper plusieurs appels backend en une seule méthode API.

Voici un modèle d'utilisation de base. Instanciez un objet Request, attribuez-lui une URL (par exemple vers un service de backend que vous souhaitez appeler) et appelez httpClient.send avec cet objet de requête.

var myRequest = new Request();
myRequest.url = "http://www.example.com";
var exchangeObj = httpClient.send(myRequest);

Référence httpClient

Le client HTTP présente deux méthodes : get() et send().

httpClient.get()

Méthode pratique pour les requêtes HTTP GET simples qui n'accepte pas les en-têtes HTTP.

Utilisation

var exchangeObj = httpClient.get(url);

Renvoie

La méthode renvoie un objet exchange. Cet objet n'a pas de propriétés et expose les méthodes suivantes :

  • isError() : (valeur booléene) renvoie true si httpClient n'a pas pu se connecter au serveur. Les codes d'état HTTP 4xx et 5xx entraînent isError() false, car la connexion est terminée et un code de réponse valide a été renvoyé. Si isError() renvoie true, un appel à getResponse() renvoie le code JavaScript undefined.
  • isSuccess() : (valeur booléenne) renvoie true si l'envoi est terminé et a abouti.
  • isComplete() : (valeur booléenne) renvoie true si la requête est terminée.
  • waitForComplete() : met le thread en pause jusqu'à la fin de la requête (par succès ou erreur).
  • getResponse() : (objet) renvoie l'objet de réponse si httpClient.send() est terminé et réussi. L'objet renvoyé présente les mêmes méthodes et propriétés que l'objet context.proxyResponse. Consultez la section Résumé de l'objet de contexte.
  • getError() : (chaîne) renvoie le message d'erreur sous forme de chaîne si l'appel de httpClient.send() a généré une erreur.

Exemple

Envoyez un objet Request entièrement configuré contenant les propriétés de la requête HTTP. Utilisez un rappel non bloquant pour traiter la réponse.

// Add the required the headers for making a specific API request
var headers = {'X-SOME-HEADER' : 'some value' };
// Make a GET API request along with headers
var myRequest = new Request("http://www.example.com","GET",headers);

// Define the callback function and process the response from the GET API request
function onComplete(response,error) {
 // Check if the HTTP request was successful
    if (response) {
      context.setVariable('example.status', response.status);
     } else {
      context.setVariable('example.error', 'Woops: ' + error);
     }
}

// Specify the callback Function as an argument
httpClient.get(myRequest, onComplete);

Utiliser la règle JavaScript

Utilisez la règle JavaScript pour associer un code JavaScript personnalisé à un flux de proxy. Consultez la section règle JavaScript.

Articles associés