Modello oggetto JavaScript

Questa pagina si applica ad Apigee e Apigee hybrid.

Visualizza la documentazione di Apigee Edge.

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

Informazioni sul modello a oggetti JavaScript

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

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

• contesto: un oggetto che fornisce accesso al contesto del messaggio
• request:una forma abbreviata che consente l'accesso all'oggetto della richiesta.
• response: una forma abbreviata che consente l'accesso all'oggetto risposta
• crypto: fornisce varie funzioni hash
• print: una funzione per emettere output
• proprietà: consente l'accesso in lettura alle proprietà di configurazione sul criterio

L'oggetto di contesto

L'oggetto context ha un ambito globale. È disponibile ovunque all'interno del flusso proxy API. Ha quattro oggetti secondari: proxyRequest, proxyResponse, targetRequest, targetResponse. Questi oggetti secondari hanno come ambito la richiesta e la risposta dell'ambiente, la richiesta e la risposta proxy o la richiesta e la risposta di destinazione. Ad esempio, se il criterio JavaScript viene eseguito nella parte del flusso dell'endpoint proxy, gli oggetti context.proxyRequest e context.proxyResponse rientrano nell'ambito. Se JavaScript viene eseguito in un flusso di destinazione, gli oggetti context.targetRequest e context.targetResponse rientrano nell'ambito.

L'oggetto context contiene anche proprietà e metodi, descritti dettagliatamente 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 con le variabili di flusso. Il valore della proprietà context.flow è l'ambito del flusso attuale. Nel flusso di richiesta proxy, è impostato sulla costante PROXY_REQ_FLOW. Se nel flusso di risposta di destinazione, è impostato su TARGET_RESP_FLOW. Questa costante è utile per l'esecuzione di codice specifico per l'ambito. Il getter consente di ottenere le variabili di flusso, mentre il setter ti consente di impostarle. Queste variabili sono generalmente disponibili nel flusso proxy e possono essere utilizzate da altri criteri.

Per ulteriori dettagli ed esempi, consulta la sezione Riferimento agli oggetti di contesto.

L'oggetto crypto

L'oggetto crypto aggiunge un supporto crittografico di base e ad alte prestazioni al modello di oggetti JavaScript. Consulta la sezione Riferimento a oggetti crypto per ulteriori dettagli ed esempi.

Gli oggetti richiesta e risposta

Gli oggetti request e response sono riferimenti abbreviati alla richiesta e alla risposta dell'ambiente, ovvero la richiesta e la risposta proxy o la richiesta e la risposta di destinazione. Gli oggetti a cui fanno riferimento queste variabili dipendono dal contesto in cui viene eseguito il criterio JavaScript. Se JavaScript viene eseguito nel flusso di un endpoint proxy, le variabili di richiesta e risposta fanno riferimento a context.proxyRequest e context.proxyResponse. Se JavaScript viene eseguito in un flusso di destinazione, le variabili fanno riferimento a context.targetRequest e context.targetResponse.

La funzione print()

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

L'oggetto delle proprietà

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

Ad esempio, se la configurazione di 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>

Poi in my-code.js puoi:

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

Più in pratica, 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 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>

Allora in emit-results.js, il codice potrebbe:

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 a oggetto crypto

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

Nota: le funzioni di crittografia supportano solo l'hashing, ma non la crittografia bidirezionale.

L'oggetto crittografico ha un ambito globale. È disponibile ovunque nel flusso proxy API. La crittografia ti consente di lavorare con questi oggetti hash:

• SHA-1
• SHA256
• SHA512
• MD5

Suggerimento: Apigee consiglia di utilizzare l'oggetto crittografico 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();

Aggiorna 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();

Restituisci l'oggetto SHA-1 come stringa base64

var _hashed_token = _sha1.digest64();

Utilizzo di oggetti SHA-256

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

Crea un nuovo oggetto SHA-256

var _sha256 = crypto.getSHA256();

Aggiorna 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();

Restituisci l'oggetto SHA-256 come stringa base64

var _hashed_token = _sha256.digest64();

Utilizzo di 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();

Aggiorna 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();

Restituisci l'oggetto SHA-512 come stringa base64

var _hashed_token = _sha512.digest64();

Utilizzo di oggetti MD5

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

Crea un nuovo oggetto MD5

var _md5 = crypto.getMD5();

Aggiorna 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();

Restituisci l'oggetto MD5 come stringa base64

var _hashed_token = _md5.digest64();

Supporto per data/ora di crittografia

L'oggetto crittografico supporta modelli 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 di questo parametro è java.text.SimpleDateFormat. Ad esempio: 'AAAA-MM-GG HH:mm:ss.SSS'
• timezone - (Stringa, facoltativa) L'implementazione sottostante per questo parametro è java.util.TimeZone. Questo parametro è lo stessoDefault: UTC
• time - (Numero, facoltativo) un valore di timestamp Unix da formattare. Valore predefinito: ora corrente

Esempi

Nota: la documentazione di java.text.SimpleDateFormat fornisce un elenco completo di tutte le combinazioni di caratteri e di caratteri di formattazione per data/ora, oltre a esempi dettagliati.

Ottieni il tempo attuale, fino a millisecondi:

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

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

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

Ottieni il valore di dieci secondi da adesso:

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

Utilizza getHash() per recuperare uno 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');

Campione con criptovalute

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 dell'oggetto di contesto
• metodi degli oggetti contesto
• proprietà degli oggetti contesto
• oggetto contesto secondario

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

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

Consulta la pagina Riferimento alle variabili di flusso e il criterio ExtractVariables.

riepilogo dell'oggetto di contesto

Questa tabella descrive brevemente l'oggetto di contesto e i relativi figli, quindi elenca le proprietà associate a ciascuno.

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

metodi degli oggetti contesto

context.getVariable()

Recupera il valore di una variabile predefinita o personalizzata.

Sintassi

context.getVariable("variable-name");

Esempio

Per ottenere il valore per l'anno in corso:

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

context.setVariable()

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

Sintassi

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

Esempio

Uno scenario comune per l'impostazione di una variabile si verifica quando un proxy API deve scrivere in modo dinamico l'URL di destinazione. Il codice JavaScript seguente ottiene il valore di una variabile denominata USER.name, lo aggiunge come parametro di query all'URL http://mocktarget.apigee.net?user=, quindi imposta il valore target.url predefinito su questo valore.

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

Suggerimento:qualsiasi variabile predefinita scrivibile e variabile personalizzata possono essere impostate 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 contesto

context.flow

La proprietà flow è una stringa che identifica l'attuale flusso proxy API. Questa proprietà viene utilizzata per indicare il flusso a cui è collegato 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 nei ProxyEndpoint o negli endpoint Target.

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

Esempio

Imposta un'intestazione HTTP solo nel flusso di richiesta target:

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

Imposta il contenuto solo nel flusso proxyResponse:

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

context.session

Una mappa di coppie nome/valore che può essere utilizzata per trasferire 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 rispetto all'utilizzo di context.getVariable() e context.setVariable(). Per ulteriori dettagli, consulta questa discussione della community di Apigee.

Esempio

Imposta un valore nella sessione:

context.session['key']  = 123;

Ottieni il valore dalla sessione:

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

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

oggetto contesto secondario

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

• context.proxyRequest: il messaggio di richiesta in entrata ricevuto dal client richiedente.
• 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 servizio di backend.

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

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

context.*Richiedi oggetti secondari

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

L'oggetto context contiene oggetti secondari che rappresentano questi messaggi di richiesta: context.proxyRequest e context.targetRequest. Questi oggetti consentono di accedere alle proprietà all'interno del flusso di richiesta compreso nell'ambito dell'esecuzione del codice JavaScript.

Nota: puoi anche utilizzare l'oggetto shorthand request per accedere a queste proprietà in un flusso di richiesta. L'oggetto request fa riferimento a context.proxyRequest o context.targetRequest, a seconda di dove viene eseguito il codice JavaScript nel flusso.

contesto.*Richiedi le proprietà dell'oggetto figlio

Nome proprietà	Descrizione
url	La proprietà url è una proprietà di comodità di lettura/scrittura che combina schema, host, porta, percorso e parametri di ricerca per targetRequest. L'URL completo della richiesta è composto dalle seguenti proprietà: protocollo: il protocollo dell'URL (ad esempio HTTP, HTTPS) port: la porta (ad esempio :80, :443) host: l'host dell'URL (ad es. 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" è accessibile 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) associati 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 contiene 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 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];

context.*Response oggetti secondari

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

L'oggetto di contesto ha oggetti figlio che rappresentano questi messaggi di risposta: context.proxyResponse e context.targetResponse. Questi oggetti consentono di accedere alle proprietà all'interno del flusso di risposta nell'ambito dell'esecuzione del codice JavaScript.

Nota: puoi anche utilizzare l'oggetto shorthand 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.

context.*Proprietà dell'oggetto della risposta

Nome proprietà	Descrizione
headers	Le intestazioni HTTP del messaggio di risposta come 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 che il messaggio di stato sono disponibili come proprietà.
	Esempio: var status = context.targetResponse.status.code; // 200 var msg = context.targetResponse.status.message; // "OK"
content	Corpo HTTP (payload) del messaggio di risposta. Il contenuto della risposta include 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 che modo differisce da request.content e context.proxyRequest.content.

Ad esempio:

request.content.asXML

o

context.proxyRequest.content.asXML

Entrambi i moduli *.content e *.content.asXML possono essere utilizzati in un contesto stringa e JavaScript li costringerà a diventare stringhe. Nel primo caso (*.content), la stringa include tutte le dichiarazioni e i commenti XML. Nel secondo caso (*.content.asXML), il valore di stringa del risultato viene rimosso da 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 degli elementi e degli attributi. Non è possibile attraversare la gerarchia utilizzando l'altra sintassi.

Eseguire il debug con le istruzioni print() di JavaScript

Se utilizzi il criterio JavaScript per eseguire codice JavaScript personalizzato, tieni presente che puoi utilizzare la funzione print() per inviare informazioni di debug allo strumento di debug. Questa funzione è disponibile direttamente tramite 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 nella parte inferiore della finestra Debug. Puoi trovare l'output anche nella proprietà Debug chiamata stepExecution-stdout.

Creazione di callout JavaScript con httpClient

Utilizza httpClient per effettuare più richieste HTTP parallele e asincrone verso qualsiasi URL dal codice JavaScript personalizzato eseguito in un flusso proxy API. L'oggetto httpClient è esposto dal modello a oggetti JavaScript Apigee.

Informazioni su httpClient

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

L'oggetto httpClient è utile per lo sviluppo di 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 i criteri JavaScript è il logging. Il criterio MessageLogging è molto più adatto per il logging su piattaforme di logging di terze parti come Splunk, Sumo e Loggly. Inoltre, consente di migliorare le prestazioni del proxy API eseguendo la norma MessageLogging in PostClientFlow, che viene eseguita dopo che la risposta è stata inviata al client.

Ecco un modello di utilizzo di base. Crea un'istanza di un oggetto Request, assegnagli un URL (ad esempio, a un servizio di backend che vuoi chiamare) e chiama httpClient.send con questo oggetto richiesta.

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

Riferimento httpClient

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

httpClient.get()

Un metodo pratico per richieste GET HTTP semplici, che non supporta le intestazioni HTTP.

Utilizzo

var exchangeObj = httpClient.get(url);

Restituisce

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

• isError(): (booleano) restituisce true se httpClient non è riuscito a connettersi al server. I codici di stato HTTP 4xx e 5xx restituiscono false isError(), poiché la connessione è stata completata ed è stato restituito un codice di risposta valido. Se isError() restituisce true, una chiamata a getResponse() restituisce undefined JavaScript.
• isSuccess(): (booleano) restituisce true se l'invio è stato completato e riuscito.
• isComplete(): (booleano) restituisce true se la richiesta è completata.
• waitForComplete(): mette in pausa il thread fino al completamento della richiesta (se l'esito è positivo o negativo).
  Anti-pattern: l'uso 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 riuscito. L'oggetto restituito ha metodi e proprietà identici all'oggetto context.proxyResponse. Consulta il riepilogo dell'oggetto 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 Richiesta completamente configurato contenente le proprietà della richiesta HTTP. Utilizza un callback non bloccante per elaborare la risposta.

Nota: l'utilizzo dei 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: utilizza 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);

Utilizzare il criterio JavaScript

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

Argomenti correlati

• Norme relative a JavaScript
• Modello a oggetti JavaScript
• Introduzione agli anti-pattern