Stai visualizzando la documentazione di Apigee Edge.
Vai alla
documentazione di Apigee X. informazioni
Questo argomento illustra il modello a oggetti JavaScript di Apigee Edge. È importante capire questo modello se intendi utilizzare il criterio JavaScript per aggiungere codice JavaScript personalizzato a un proxy API.
Informazioni sul modello a oggetti JavaScript Edge
Il modello a oggetti JavaScript di Apigee Edge definisce gli oggetti con proprietà associate che sono disponibili per il codice JavaScript eseguito all'interno di un flusso proxy Apigee Edge. Puoi utilizzare il criterio JavaScript per collegare questo codice personalizzato a un flusso proxy API.
Gli oggetti definiti da questo modello hanno un ambito all'interno del flusso proxy API, il che significa che determinati oggetti e proprietà sono disponibili solo in punti specifici del flusso. Quando viene eseguito il codice JavaScript, viene creato un ambito per l'esecuzione. In questo ambito vengono creati i seguenti riferimenti agli oggetti:
- context: un oggetto che fornisce l'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 della richiesta
- crypto:fornisce varie funzioni hash
- print: una funzione per emettere output
- proprietà: consente l'accesso in lettura alle proprietà di configurazione del 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
e targetResponse
. L'ambito di questi oggetti secondari è la richiesta e la risposta ambientali, ovvero 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
rientreranno nell'ambito. Se JavaScript viene eseguito in un flusso di destinazione, gli oggetti context.targetRequest
e
context.targetResponse
rientrano nell'ambito.
L'oggetto context
dispone anche di 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 con le variabili di flusso.
Il valore della proprietà context.flow
è l'ambito del flusso attuale. Nel flusso di richiesta proxy, è impostata sulla costante PROXY_REQ_FLOW
. Se si trova 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 ti consente di ottenere 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.
Consulta la sezione Riferimento oggetto di contesto di seguito per ulteriori dettagli ed esempi.
L'oggetto di crittografia
L'oggetto di crittografia aggiunge un supporto crittografico di base e ad alte prestazioni al modello di oggetti JavaScript. Consulta la sezione Riferimento agli oggetti crypto di seguito per ulteriori dettagli ed esempi.
Gli oggetti richiesta e risposta
Gli oggetti request
e response
sono riferimenti abbreviati alla richiesta e alla risposta ambientale, 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 faranno 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 Edge Trace. Consulta Eseguire il debug con le istruzioni print()
di JavaScript.
L'oggetto delle proprietà
Quando utilizzi un elemento 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>
Poi in my-code.js
potrai:
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>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 oggetti crypto
L'oggetto di crittografia consente di eseguire funzioni di hashing crittografico di base in JavaScript.
L'oggetto di crittografia ha un ambito globale. È disponibile ovunque all'interno del flusso proxy API. Crypto ti consente di lavorare con i seguenti oggetti hash:
- SHA-1
- SHA256
- SHA512
- MD5
Utilizzo di 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();
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();
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();
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 degli oggetti MD5
È possibile creare oggetti MD5, aggiornarli e convertirli in valori esadecimali e base64.
Crea un nuovo oggetto MD5
var _md5 = crypto.getMD5();
Aggiornamento di 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 e ora della crittografia
L'oggetto crittografico supporta i pattern di formattazione di data e 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: 'yyyy-MM-DD HH:mm:ss.SSS'
- timezone: (stringa, facoltativa) L'implementazione sottostante per questo parametro è java.util.TimeZone. Questo parametro è lo sameDefault: UTC
- time - (Numero, facoltativo) un valore di timestamp Unix da formattare. Valore predefinito: ora attuale
Esempi
Ottieni il tempo corrente, fino a millisecondi:
var _now = crypto.dateFormat('yyyy-MM-DD HH:mm:ss.SSS');
Scopri l'ora corrente del 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 ten_seconds = 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');
Esempio con criptovalute
try { // get values to use with hash functions var salt = context.getVariable("salt") || 'SomeHardCodedSalt'; var host = context.getVariable("request.header.Host"); var unhashed_token = ""; 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(unhashed_token); // convert to base64 var base64_token = sha512.digest64(); // set headers context.setVariable("request.header.now", now); context.setVariable("request.header.token", base64_token); } catch(e) { throw 'Error in Javascript'; }
Riferimento all'oggetto di contesto
- riepilogo dell'oggetto di contesto
- metodi oggetto di contesto
- proprietà dell'oggetto contesto
- oggetti secondari di contesto
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 le informazioni di riferimento sulle variabili di flusso e il criterio per l'estrazione delle variabili.
riepilogo dell'oggetto di contesto
Questa tabella descrive brevemente l'oggetto di contesto e i relativi 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 i flussi di richiesta e risposta 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 query, 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 query, 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, contenuti, stato |
context. proxyResponse |
Un oggetto che rappresenta il messaggio di risposta del proxy in uscita (dal proxy API all'app che ha inviato la richiesta) | intestazioni, contenuti, stato |
context.flow |
Il nome del flusso attuale. | Vedi context.flow di seguito. |
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 maggiori informazioni su quando e quando non utilizzare questo oggetto, consulta questa discussione della community di Apigee. |
metodi oggetto di 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 impostare una variabile è quando un proxy API deve scrivere in modo dinamico l'URL di destinazione. Il codice JavaScript riportato di seguito ottiene il valore di una variabile denominata USER.name
,
aggiunge tale valore come parametro di ricerca all'URL
http://mocktarget.apigee.net?user=
, quindi imposta il valore
target.url
predefinito su quel valore.
context.setVariable("target.url", "http://mocktarget.apigee.net/user?user="+context.getVariable("USER.name"));
context.removeVariable()
Rimuove una variabile dal contesto.
Sintassi
context.removeVariable('variable-name');
proprietà degli oggetti di contesto
La proprietà flow
è una stringa che identifica l'attuale flusso proxy API. Questa proprietà 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 i flussi PreFlow, PostFlow ed eventuali flussi condizionali definiti in ProxyEndpoints o TargetEndpoints.
Questa proprietà facoltativa è utile quando il codice JavaScript comune viene eseguito in più flussi, ma può 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'; }
Una mappa di coppie nome/valore che possono essere utilizzate per trasferire oggetti tra due criteri in esecuzione nello stesso contesto di messaggio.
Esempio
Imposta un valore nella sessione:
context.session['key'] = 123;
Ottieni il valore dalla sessione:
var value = context.session['key']; // 123
oggetto di contesto secondari
Come mostrato di seguito, un flusso proxy API completo comprende quattro fasi distinte, a ognuna delle quali è associato un oggetto messaggio figlio 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 che ha inviato la richiesta.context.targetResponse
: il messaggio di richiesta in entrata ricevuto dal servizio di backend.
Le seguenti sezioni descrivono i metodi e le proprietà di questi oggetti:
contesto.*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 in inbound (la richiesta generata dal proxy API e inviata alla destinazione del 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 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à degli oggetti figlio
Nome proprietà | Descrizione |
---|---|
url |
La proprietà L'URL completo della richiesta è composto dalle seguenti proprietà:
Quando ottieni
|
Esempi: context.targetRequest.url = 'http://www.example.com/path?q1=1' context.targetRequest.protocol ='https'; |
|
headers |
Intestazioni delle richieste HTTP come mappatura di |
Esempi: Per questa richiesta HTTP: POST /v1/blogs HTTP/1.1 Host: api.example.com Content-Type: application/json Authorization: Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5ZIl seguente codice JavaScript: context.proxyRequest.headers['Content-Type']; context.proxyRequest.headers['Authorization']; restituirà i seguenti valori application/json Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z |
|
queryParams |
I parametri di query del messaggio di richiesta come mappatura di |
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 ( |
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:
|
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: oggetti secondari
Per ogni transazione HTTP eseguita in un proxy API, vengono creati due oggetti messaggio di risposta: uno in inbound (la risposta dal servizio di backend) e uno in inbound (la risposta inviata al client).
L'oggetto di contesto contiene 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 risposta
Nome proprietà | Descrizione |
---|---|
headers |
Le intestazioni HTTP del messaggio di risposta come mappatura di |
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 |
Il corpo HTTP (contenuti del 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 come si differenzia 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 forza 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 generare informazioni di debug nello strumento Traccia. 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 da tutte le transazioni nella parte inferiore della
finestra Trace. Puoi trovare l'output anche nella proprietà Trace chiamata stepExecution-stdout
.
Creazione di callout JavaScript con httpClient
Utilizza httpClient
per effettuare più richieste HTTP asincrone e parallele a qualsiasi URL dal codice JavaScript personalizzato eseguito in un flusso proxy API.
L'oggetto httpClient
è esposto dal modello a oggetti JavaScript di Apigee Edge.
Informazioni su httpClient
L'oggetto httpClient
è esposto a codice JavaScript personalizzato in esecuzione su Apigee Edge
attraverso il modello a oggetti JavaScript. Per collegare un codice JavaScript personalizzato a un proxy API, devi utilizzare le norme 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.
Questo oggetto viene comunemente utilizzato in alternativa al criterio ServiceCallout.
Ecco uno schema di utilizzo di base. Crea l'istanza di un oggetto Richiesta, 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, senza supporto per le intestazioni HTTP.
Utilizzo
var exchangeObj = httpClient.get(url);
Restituisce
Il metodo restituisce un oggetto exchange
. Questo oggetto non ha proprietà ed espone i seguenti metodi:
isError()
: (booleano) restituiscetrue
se httpClient non è riuscito a connettersi al server. I codici di stato HTTP4xx
e5xx
generanoisError()
false
, poiché la connessione è stata completata ed è stato restituito un codice di risposta valido. SeisError()
restituiscetrue
, una chiamata agetResponse()
restituisceundefined
JavaScript.isSuccess()
: (booleano) restituiscetrue
se l'invio è stato completato e riuscito.isComplete()
: (booleano) restituiscetrue
se la richiesta è completa.waitForComplete()
: mette in pausa il thread fino al completamento della richiesta (con esito positivo o negativo).getResponse()
: (oggetto) restituisce l'oggetto risposta sehttpClient.send()
è stato completato e ha avuto esito positivo. L'oggetto restituito ha metodi e proprietà identici a quelli dell'oggetto context.proxyResponse. Consulta il riepilogo dell'oggetto di contesto.getError()
: (stringa) se la chiamata ahttpClient.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 di blocco per elaborare la risposta.
// 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 JavaScript
- Modello a oggetti JavaScript
- Per esempi e istruzioni di base, consulta Programmazione dei proxy API con JavaScript.
- Per esempi di codice JavaScript funzionanti, consulta gli esempi di Apigee Edge su GitHub.
Articoli della community Apigee
Puoi trovare questi articoli correlati nella community di Apigee: