Modello oggetto JavaScript

Questa pagina si applica a Apigee e Apigee ibridi.

Visualizza documentazione di Apigee Edge.

Questo argomento illustra il modello a oggetti JavaScript di Apigee. È importante comprendere questo modello se intendi utilizzare il criterio JavaScript per aggiungere JavaScript personalizzato a un'API proxy.

Informazioni sul modello a oggetti JavaScript

Il modello oggetto JavaScript definisce oggetti con proprietà associate disponibili per il codice JavaScript in esecuzione all'interno di un flusso di proxy Apigee. Utilizza il criterio JavaScript per collegare questo codice personalizzato a un flusso di proxy API.

Gli oggetti definiti da questo modello hanno un ambito all'interno del flusso del proxy API, il che significa che determinati oggetti e proprietà sono disponibili solo in punti specifici del flusso. Quando JavaScript viene eseguito, viene creato un ambito per l'esecuzione. In questo ambito, vengono creati i riferimenti agli oggetti:

• context: un oggetto che fornisce l'accesso al contesto del messaggio
• request: una scorciatoia che consente di accedere all'oggetto request
• response: una scorciatoia che consente di accedere all'oggetto di risposta
• crypto: fornisce varie funzioni hash
• print: una funzione per emettere l'output
• properties: consente l'accesso in lettura alle proprietà di configurazione nel criterio.

L'oggetto di contesto

L'oggetto context ha ambito globale. È disponibile ovunque all'interno del flusso proxy API. Ha quattro oggetti secondari: proxyRequest, proxyResponse, targetRequest, targetResponse. Questi oggetti figlio hanno come ambito richiesta e risposta Ambiente, ovvero la richiesta e la risposta proxy o la richiesta e la risposta corretta. Ad esempio, se il criterio JavaScript viene eseguito nella parte dell'endpoint proxy del flusso, allora gli oggetti context.proxyRequest e context.proxyResponse si trovano l'ambito di attività. Se il codice JavaScript viene eseguito in un flusso target, gli oggetti context.targetRequest e context.targetResponse sono nell'ambito.

L'oggetto context ha anche proprietà e metodi, descritti in dettaglio in questo argomento. Ad esempio, il seguente esempio di codice JavaScript utilizza la proprietà context.flow e chiama i metodi get/setVariable() su context.

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

Questi metodi interagiscono direttamente variabili di flusso. Il valore della proprietà context.flow è l'ambito corrente del flusso. Nel flusso di richiesta del proxy, è impostato sulla costante PROXY_REQ_FLOW. Se nel flusso di risposta di destinazione è impostato su TARGET_RESP_FLOW. Questa costante è utile per eseguire codice specifico per ambito. Il getter ti consente di ottenere variabili di flusso e il setter ti consente di impostare variabili di flusso. Queste variabili sono generalmente disponibili nel flusso proxy e possono essere utilizzate altri criteri.

Consulta la pagina Riferimento all'oggetto di contesto per ulteriori dettagli e esempi.

L'oggetto crypto

L'oggetto crypto aggiunge al Modello oggetto JavaScript un supporto di crittografia di base ad alte prestazioni. Consulta la documentazione di riferimento degli oggetti crypto per ulteriori dettagli ed esempi.

Gli oggetti di richiesta e risposta

Gli oggetti request e response sono riferimenti abbreviati alla richiesta e risposta Ambiente, ovvero la richiesta e la risposta proxy o la richiesta e la risposta corretta. Gli oggetti a cui fanno riferimento queste variabili dipendono dal contesto in cui il codice JavaScript viene eseguito. Se JavaScript viene eseguito nel flusso di un endpoint proxy, allora la richiesta e le variabili di risposta fanno riferimento a context.proxyRequest e context.proxyResponse. Se JavaScript viene eseguito in un flusso target, le variabili consulta i context.targetRequest e le context.targetResponse.

La funzione print()

Il modello a oggetti JavaScript include una funzione stampa() che puoi utilizzare per eseguire il debug le informazioni necessarie allo strumento di debug Apigee. Consulta Eseguire il debug con le istruzioni JavaScript print().

L'oggetto delle proprietà

Quando utilizzi un elemento Properties nella configurazione del criterio, il codice JavaScript può accedere ai valori di queste proprietà utilizzando la variabile properties.

Ad esempio, se la configurazione JavaScript contiene:

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

In my-code.js puoi:

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

In termini più pratici, la configurazione può consentire al codice di comportarsi in modo diverso quando viene eseguito in ambienti diversi, in momenti diversi o per qualsiasi motivo.

Ad esempio, quanto segue specifica il "nome della variabile" e lo stile di output in cui JavaScript deve emettere le informazioni:

<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>

In emit-results.js, il codice potrebbe eseguire le seguenti operazioni:

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));
}

Riferimento agli oggetti crypto

L'oggetto crypto ti consente di eseguire funzioni di hashing crittografico di base in JavaScript.

Nota: le funzioni crittografiche supportano solo l'hashing, ma non è supportato per la crittografia bidirezionale.

L'oggetto crypto ha ambito globale. È disponibile ovunque all'interno del flusso del proxy API. La crittografia consente di lavorare con i seguenti oggetti hash:

• SHA-1
• SHA256
• SHA512
• MD5

Suggerimento: Apigee consiglia di utilizzare l'oggetto crypto per eseguire funzioni crittografiche di base nei programmi JavaScript in esecuzione su Apigee.

Utilizzo degli oggetti SHA-1

Puoi creare oggetti SHA-1, aggiornarli e convertirli in valori esadecimali e base64.

Crea un nuovo oggetto SHA-1

var _sha1 = crypto.getSHA1();

Aggiornare un oggetto SHA-1

Sintassi

_sha1.update(value);

Parametri

• value - (Stringa) qualsiasi valore stringa.

Esempio

Aggiorna un oggetto SHA-1:

_sha1.update("salt_value");

_sha1.update("some text");

Restituisci l'oggetto SHA-1 come stringa esadecimale

var _hashed_token = _sha1.digest();

Restituisce l'oggetto SHA-1 come stringa base64

var _hashed_token = _sha1.digest64();

Utilizzo degli oggetti SHA-256

Puoi creare oggetti SHA-256, aggiornarli e convertirli in valori esadecimali e base64.

Creare un nuovo oggetto SHA-256

var _sha256 = crypto.getSHA256();

Aggiornare un oggetto SHA-256

Sintassi

_sha256.update(value);

Parametri

• value - (Stringa) qualsiasi valore stringa.

Esempio

Aggiorna un oggetto SHA-256:

_sha256.update("salt_value");

_sha256.update("some text");

Restituisci l'oggetto SHA-256 come stringa esadecimale

var _hashed_token = _sha256.digest();

Restituisce l'oggetto SHA-256 come stringa base64

var _hashed_token = _sha256.digest64();

Utilizzo degli oggetti SHA-512

Puoi creare oggetti SHA-512, aggiornarli e convertirli in valori esadecimali e base64.

Crea un nuovo oggetto SHA-512

var _sha512 = crypto.getSHA512();

Aggiornare un oggetto SHA-512

Sintassi

_sha512.update(value);

Parametri

• value - (Stringa) qualsiasi valore stringa.

Esempio

Aggiorna un oggetto SHA-512:

_sha512.update("salt_value");

_sha512.update("some text");

Restituisci l'oggetto SHA-512 come stringa esadecimale

var _hashed_token = _sha512.digest();

Restituisce l'oggetto SHA-512 come stringa base64

var _hashed_token = _sha512.digest64();

Utilizzo degli oggetti MD5

Puoi creare oggetti MD5, aggiornarli e convertirli in valori esadecimali e base64.

Crea un nuovo oggetto MD5

var _md5 = crypto.getMD5();

Aggiornare un oggetto MD5

Sintassi

_md5.update(value);

Parametri

• value - (Stringa) qualsiasi valore stringa.

Esempio

Aggiorna un oggetto MD5:

_md5.update("salt_value");

_md5.update("some text");

Restituisci l'oggetto MD5 come stringa esadecimale

var _hashed_token = _md5.digest();

Restituisce l'oggetto MD5 come stringa base64

var _hashed_token = _md5.digest64();

Supporto di data/ora per la crittografia

L'oggetto crypto supporta i pattern di formattazione di data/ora.

crypto.dateFormat()

Restituisce una data in formato stringa.

Sintassi

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

Parametri

• format: (stringa) l'implementazione sottostante per questo parametro è java.text.SimpleDateFormat. Ad esempio: "AAAA-MM-GG HH:mm:ss.SSS"
• timezone: (stringa, facoltativo) l'implementazione di base per è java.util.TimeZone. Questo parametro è uguale a impostazione predefinita: UTC
• time: (Numero, facoltativo) un valore timestamp Unix da formattare. Valore predefinito: ora attuale

Esempi

Nota: la documentazione di java.text.SimpleDateFormat fornisce un elenco completo di tutti i caratteri e le combinazioni di caratteri per la formattazione della data/dell'ora, nonché esempi dettagliati.

Ottieni l'ora corrente, fino ai millisecondi:

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

Vedere l'ora attuale per il fuso orario del Pacifico:

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

Ottieni il valore dei dieci secondi a partire da ora:

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

Altri esempi. Vedi anche la documentazione 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");

Usa getHash() per ottenere uno qualsiasi degli oggetti hash supportati

Esempi

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

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

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

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

Sample con criptovaluta

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';
}

Riferimento all'oggetto di contesto

• riepilogo degli oggetti di contesto
• metodi dell'oggetto di contesto
• Proprietà dell'oggetto context
• oggetti di contesto secondari

Viene creato un oggetto context per ogni transazione di richiesta/risposta eseguita da un proxy API. L'oggetto context espone metodi per recuperare, impostare e rimuovere le variabili relative a ogni transazione.

Le variabili definiscono proprietà specifiche per una transazione. L'ora del giorno, le impostazioni internazionali il client richiedente, lo user agent del client richiedente e l'URL del servizio di destinazione sono tutti gli esempi di variabili disponibili in context. Pertanto, context è utile per creare una logica basata su queste proprietà per l'esecuzione un comportamento personalizzato.

Consulta le sezioni Riferimento alle variabili di flusso e Criterio Takeout.

Riepilogo dell'oggetto context

Questa tabella descrive brevemente l'oggetto di contesto e i suoi oggetti secondari ed elenca le proprietà associate a ciascuno.

Nome	Descrizione	Proprietà
context	Un wrapper per il contesto della pipeline di elaborazione dei messaggi e la richiesta e la risposta Flussi eseguiti da ProxyEndpoint e TargetEndpoint.	flusso, sessione
context.proxyRequest	Un oggetto che rappresenta il messaggio di richiesta in arrivo a ProxyEndpoint (dall'app richiedente al proxy API)	headers, query parameters, method, body, url
context.targetRequest	Un oggetto che rappresenta il messaggio di richiesta in uscita da TargetEndpoint (dal proxy API al servizio di backend).	headers, query parameters, method, body, url
context.targetResponse	Un oggetto che rappresenta il messaggio di risposta di destinazione in entrata (dal servizio di backend al proxy API)	intestazioni, contenuti, stato
context.proxyResponse	Un oggetto che rappresenta il messaggio di risposta del proxy in uscita (dal proxy API all'app richiedente)	intestazioni, contenuti, stato
context.flow	Il nome del flusso corrente.	Vedi context.flow.
context.session	Una mappa di coppie nome/valore che puoi utilizzare per trasferire oggetti tra due diversi passaggi in esecuzione nello stesso contesto. Ad esempio: context.session['key'] = 123.	Per ulteriori informazioni su quando utilizzare e quando non utilizzare questo oggetto, vedi Qual è la differenza tra context.session['hello'] = {} e context.setVariable("hello", {}).

Metodi dell'oggetto context

context.getVariable()

Recupera il valore di una variabile predefinita o personalizzata.

Sintassi

context.getVariable("variable-name");

Esempio

Per ottenere il valore dell'anno corrente:

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

context.setVariable()

Imposta il valore di una variabile personalizzata o di qualsiasi variabile predefinita scrivibile.

Sintassi

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

Esempio

Uno scenario comune per impostare una variabile è quando un proxy API deve scrivere dinamicamente la variabile URL di destinazione. Il codice JavaScript riportato di seguito ottiene il valore di una variabile denominata USER.name e lo aggiunge come parametro di query all'URL. http://mocktarget.apigee.net?user=, quindi imposta il valore predefinito target.url a quel valore.

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

Suggerimento: qualsiasi variabile predefinita scrivibile e qualsiasi variabile personalizzata può essere impostato dinamicamente da JavaScript. Per un elenco completo delle variabili predefinite, consulta Riferimento per le variabili di flusso.

context.removeVariable()

Rimuove una variabile dal contesto.

Sintassi

context.removeVariable('variable-name');

proprietà degli oggetti di contesto

context.flow

La proprietà flow è una stringa che identifica l'attuale flusso del proxy API. Questo viene utilizzata per indicare il flusso a cui è collegato il codice JavaScript. I valori supportati sono:

• PROXY_REQ_FLOW
• PROXY_RESP_FLOW
• TARGET_REQ_FLOW
• TARGET_RESP_FLOW

Ogni nome di flusso comprende PreFlow, PostFlow ed eventuali flussi condizionali definiti negli endpoint Proxy o Target.

Questa proprietà facoltativa è utile quando il codice JavaScript comune viene eseguito in più di un flusso, ma il suo comportamento potrebbe variare a seconda del flusso in cui viene eseguito. Utilizzare la proprietà Flow per i moduli JavaScript destinati a essere riutilizzati in più proxy API, in cui il codice viene necessaria per controllare il flusso attuale prima di eseguire la logica.

Esempio

Imposta un'intestazione HTTP solo sul flusso targetRequest:

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

Imposta i contenuti solo nel flusso proxyResponse:

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

context.session

Una mappa di coppie di nomi/valori che può essere utilizzata per passare oggetti tra due criteri in esecuzione nello stesso contesto del messaggio.

Nota: è importante comprendere la differenza tra l'utilizzo di context.session per ottenere/impostare le variabili e l'utilizzo di context.getVariable() e context.setVariable(). Per ulteriori dettagli, consulta questa discussione della community Apigee.

Esempio

Imposta un valore nella sessione:

context.session['key']  = 123;

Recupera il valore dalla sessione:

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

Esempio: per un esempio pratico che utilizza l'oggetto context.session, consulta il proxy API di esempio per il callout asincrono.

Elementi secondari dell'oggetto contesto

Come mostrato di seguito, un flusso proxy API completo comprende quattro fasi distinte, ognuna delle quali ha un oggetto messaggio associato che è un elemento secondario dell'oggetto contesto:

• context.proxyRequest: il messaggio di richiesta in entrata ricevuto dalla richiesta di alto profilo.
• context.targetRequest: il messaggio di richiesta in uscita inviato al servizio di backend.
• context.proxyResponse: il messaggio di risposta in uscita restituito al client richiedente.
• context.targetResponse: il messaggio di richiesta in entrata ricevuto dal backend completamente gestito di Google Cloud.

Le seguenti sezioni descrivono i metodi e le proprietà di questi oggetti:

• context.*Richiedi oggetti secondari
• Oggetti secondari context.*Response

contesto.*Richiedi oggetti secondari

Per ogni transazione HTTP eseguita in un proxy API vengono creati due oggetti messaggio di richiesta: uno in entrata (la richiesta del client) e uno in uscita (la richiesta generata dal proxy API e inviata al backend di destinazione).

L'oggetto context include oggetti secondari che rappresentano i seguenti messaggi di richiesta: context.proxyRequest e context.targetRequest. Questi oggetti ti consentono di accedere alle proprietà all'interno del flusso di richieste che rientrano nell'ambito durante l'esecuzione del codice JavaScript.

Nota: puoi anche utilizzare l'oggetto abbreviato request per accedere a queste proprietà in un flusso di richieste. L'oggetto request si riferisce context.proxyRequest o context.targetRequest, a seconda della regione il flusso eseguito dal codice JavaScript.

contesto.*Richiedi proprietà degli oggetti secondari

Nome proprietà	Descrizione
url	La proprietà url è una proprietà di comodità di lettura/scrittura che combina schema, host, porta, percorso e parametri di query per la richiesta target. L'URL completo della richiesta è composto dalle seguenti proprietà: protocol: il protocollo dell'URL (ad esempio HTTP, HTTPS) porta: la porta (ad esempio :80, :443) host: l'host dell'URL (ad esempio, www.example.com) path: il percorso dell'URI, ad esempio /v1/mocktarget Quando ricevi url, viene restituito un URL nel seguente formato: protocol://host:port/path?queryParams
	Esempi: context.targetRequest.url = 'http://www.example.com/path?q1=1' context.targetRequest.protocol ='https';
headers	Intestazioni delle richieste HTTP come mappatura di String => List
	Esempi: Per questa richiesta HTTP: POST /v1/blogs HTTP/1.1 Host: api.example.com Content-Type: application/json Authorization: Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z Il seguente codice JavaScript: context.proxyRequest.headers['Content-Type']; context.proxyRequest.headers['Authorization']; restituirà i seguenti valori application/json Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z
queryParams	I parametri di ricerca del messaggio di richiesta come mappatura di String => List.
	Esempi: "?city=PaloAlto&city=NewYork" può essere visualizzato come: context.proxyRequest.queryParams['city']; // == 'PaloAlto' context.proxyRequest.queryParams['city'][0] // == 'PaloAlto' context.proxyRequest.queryParams['city'][1]; // == 'NewYork' context.proxyRequest.queryParams['city'].length(); // == 2
method	Il verbo HTTP (GET, POST, PUT, DELETE). PATCH e così via) associata alla richiesta
	Esempi: Per questa richiesta: POST /v1/blogs HTTP/1.1 Host: api.example.com Content-Type: application/json Authorization: Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z Il seguente codice JavaScript: context.proxyRequest.method; restituirà il seguente valore POST
body	Il corpo del messaggio (payload) della richiesta HTTP. Il corpo della richiesta include i seguenti membri: context.targetRequest.body.asXML; context.targetRequest.body.asJSON; context.targetRequest.body.asForm;
	Esempi: Per un corpo XML: <customer number='1'> <name>Fred<name/> <customer/> Per accedere agli elementi dell'oggetto XML, procedi nel seguente modo: var name = context.targetRequest.body.asXML.name; Per accedere agli attributi XML, utilizza la notazione @. var number = context.targetRequest.body.asXML.@number; Per il corpo di una richiesta JSON: { "a": 1 , "b" : "2" } var a = context.proxyRequest.body.asJSON.a; // == 1 var b = context.proxyRequest.body.asJSON.b; // == 2 Per leggere i parametri del modulo: "vehicle=Car&vehicle=Truck" v0 = context.proxyRequest.body.asForm['vehicle'][0]; v1 = context.proxyRequest.body.asForm['vehicle'][1];

contesto.*Risposta agli oggetti secondari

Per ogni transazione HTTP eseguita in un proxy API, vengono creati due oggetti messaggio di risposta: uno in entrata (la risposta del servizio di backend) e uno in uscita (la risposta inviata al client).

L'oggetto contesto ha oggetti secondari che rappresentano i seguenti messaggi di risposta: context.proxyResponse e context.targetResponse. Questi oggetti ti consentono accedere alle proprietà all'interno del flusso di risposta che rientra nell'ambito quando il codice JavaScript .

Nota: puoi anche utilizzare l'oggetto abbreviato response per accedere a queste proprietà da un flusso di risposta. L'oggetto response fa riferimento a context.proxyResponse o context.targetResponse, a seconda di dove viene eseguito il codice JavaScript nel flusso.

Proprietà dell'oggetto context.*Response

Nome proprietà	Descrizione
headers	Le intestazioni HTTP del messaggio di risposta come una mappatura di String => List.
	Esempio: var cookie = context.targetResponse.headers['Set-Cookie'];
status	Il codice di stato con messaggio di stato come proprietà. Sia il codice di stato sia il messaggio di stato sono disponibili come proprietà.
	Esempio: var status = context.targetResponse.status.code; // 200 var msg = context.targetResponse.status.message; // "OK"
content	Il corpo HTTP (contenuto del payload) del messaggio di risposta. I contenuti della risposta hanno i seguenti membri: context.targetResponse.content.asXML; context.targetResponse.content.asJSON;

Utilizzo della notazione .asXML

Esiste un modo pratico per esaminare un documento XML utilizzando la notazione .asXML. Questa sezione descrive come utilizzare questa notazione e in cosa differisce da request.content e context.proxyRequest.content.

Ad esempio:

request.content.asXML

o

context.proxyRequest.content.asXML

Sia le forme *.content che *.content.asXML possono essere utilizzate in un contesto di stringa e JavaScript le convertirà in stringhe. Nel caso precedente (*.content), la stringa include tutte le dichiarazioni e i commenti XML. Nella nel secondo caso (*.content.asXML), il valore della stringa del risultato viene cancellato di dichiarazioni e commenti.

Esempio

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>

Inoltre, puoi utilizzare il modulo .asXML per attraversare la gerarchia XML, specificando i nomi di elementi e attributi. Non è possibile attraversare la gerarchia utilizzando l'altra sintassi.

Eseguire il debug con JavaScript Istruzioni stampa()

Se utilizzi il criterio JavaScript per eseguire codice JavaScript personalizzato, tieni presente che puoi utilizzare La funzione stampa() per inviare le informazioni di debug allo Strumento di debug. Questa funzione è disponibile direttamente attraverso il modello a oggetti JavaScript. Ad esempio:

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"));
}

Per visualizzare l'output, seleziona Output di tutte le transazioni in fondo allo Finestra di debug. Puoi trovare l'output anche nella proprietà Debug chiamata stepExecution-stdout.

Creare callout JavaScript con httpClient

Utilizza httpClient per effettuare più richieste HTTP asincrone parallele a qualsiasi URL dal codice JavaScript personalizzato in esecuzione in un flusso di proxy API. L'oggetto httpClient è esposto dall'oggetto JavaScript Apigee un modello di machine learning.

Informazioni su httpClient

L'oggetto httpClient è esposto al codice JavaScript personalizzato in esecuzione su Apigee tramite il modello oggetto JavaScript. Per collegare JavaScript personalizzato a un proxy API, utilizza il criterio JavaScript. Quando viene eseguito il criterio, viene eseguito il codice JavaScript personalizzato.

L'oggetto httpClient è utile per sviluppare servizi compositi o mashup. Ad esempio, puoi consolidare più chiamate di backend in un singolo metodo API.

Nota: un caso d'uso non consigliato per il criterio JavaScript è log. Il MessageLogging policy è molto più adatto per la registrazione su piattaforme di logging di terze parti come Splunk, Sumo e Loggly e puoi migliorare le prestazioni del proxy API eseguendo il MessageLogging policy in PostClientFlow, che viene eseguito dopo che la risposta è stata inviata al client.

Di seguito è riportato uno schema di utilizzo di base. Crea un oggetto Request, assegnagli un URL (ad es. a un servizio di backend che vuoi chiamare) e chiama httpClient.send con quell'oggetto richiesta.

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

Riferimento a httpClient

Il client HTTP espone due metodi: get() e send().

httpClient.get()

Un metodo pratico per semplici richieste GET HTTP, senza supporto per le intestazioni HTTP.

Utilizzo

var exchangeObj = httpClient.get(url);

Restituisce

Il metodo restituisce un oggetto exchange. Questo oggetto non ha proprietà espone i seguenti metodi:

• isError(): (booleano) restituisce true se httpClient non è riuscito a connettersi al server. I codici di stato HTTP 4xx e 5xx generano isError() false, poiché la connessione è stata completata e è stato restituito un codice di risposta valido. Se isError() restituisce true, una chiamata a getResponse() restituisce il valore JavaScript undefined.
• isSuccess(): (booleano) restituisce true se l'invio è stato completato e corretto.
• isComplete(): (booleano) restituisce true se la richiesta è completata.
• waitForComplete(): mette in pausa il thread fino al completamento della richiesta (se la richiesta è andata a buon fine) o un errore).
  Antipattern : l'utilizzo di waitForComplete non è consigliato ed è considerato un anti-pattern. Ti consigliamo di utilizzare i callback. Per maggiori dettagli, consulta Antipattern: utilizzare waitForComplete() nel codice JavaScript.
• getResponse(): (oggetto) restituisce l'oggetto risposta se httpClient.send() è stato completato e ha avuto esito positivo. L'oggetto restituito ha metodi e proprietà identici all'oggetto context.proxyResponse. Consulta: riepilogo degli oggetti di contesto.
• getError(): (stringa) se la chiamata a httpClient.send() ha generato un errore, restituisce il messaggio di errore come stringa.

Esempio

Invia un oggetto Request completamente configurato contenente le proprietà della richiesta HTTP. Utilizza un callback che non blocca l'elaborazione della risposta.

Nota: l'utilizzo di callback per elaborare le risposte in modo asincrono è una best practice consigliata. L'utilizzo della funzione waitForComplete() è non è consigliato ed è considerato un anti-pattern. Vedi anche Antipattern: usare waitForComplete() nel codice JavaScript.

// 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);

Utilizzo del criterio JavaScript

Utilizza il criterio JavaScript per associare codice JavaScript personalizzato a un flusso proxy. Consulta le norme relative a JavaScript.

Argomenti correlati

• Norme su JavaScript
• Modello oggetto JavaScript
• Introduzione agli antipattern