Questa pagina si applica ad Apigee e Apigee hybrid.
Visualizza la documentazione di
Apigee Edge.
Questo argomento descrive il modello oggetto JavaScript di Apigee. È importante comprendere questo modello se intendi utilizzare la norma JavaScript per aggiungere JavaScript personalizzato a un proxy API.
Informazioni sul modello oggetto JavaScript
Il modello oggetto JavaScript definisce oggetti con proprietà associate disponibili per il codice JavaScript eseguito all'interno di un flusso proxy Apigee. Utilizza il criterio JavaScript per collegare questo codice personalizzato a un flusso del 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 il codice JavaScript viene eseguito, 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 notazione abbreviata che consente l'accesso all'oggetto richiesta
- response: una notazione abbreviata che consente l'accesso all'oggetto di risposta
- crypto: fornisce varie funzioni hash
- print: una funzione per generare output
- properties: consente l'accesso in lettura alle proprietà di configurazione del 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 secondari sono limitati alla richiesta e alla risposta ambientali, ovvero alla richiesta e alla risposta del proxy o alla richiesta e alla risposta di destinazione. Ad esempio, se la policy JavaScript viene eseguita nella parte dell'endpoint proxy del flusso,
gli oggetti context.proxyRequest
e context.proxyResponse
sono
nell'ambito. Se JavaScript viene eseguito in un flusso di destinazione, gli oggetti context.targetRequest
e
context.targetResponse
sono inclusi 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 con
le variabili di flusso.
Il valore della proprietà context.flow
è l'ambito attuale del flusso. 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
eseguire codice specifico per l'ambito. Il getter consente di ottenere le variabili di flusso e il setter consente di impostarle. Queste variabili sono generalmente disponibili nel flusso proxy e possono essere utilizzate da
altre norme.
Per maggiori dettagli ed esempi, consulta le Informazioni di riferimento sull'oggetto contesto.
L'oggetto crypto
L'oggetto crypto aggiunge il supporto crittografico di base e ad alte prestazioni al modello oggetto JavaScript. Per maggiori dettagli ed esempi, consulta le informazioni di riferimento sull'oggetto crypto.
Oggetti richiesta e risposta
Gli oggetti request
e response
sono riferimenti abbreviati alla richiesta e alla risposta
ambientali, ovvero alla richiesta e alla risposta del proxy o alla richiesta e alla
risposta di destinazione. Gli oggetti a cui fanno riferimento queste variabili dipendono dal contesto in cui viene eseguita la policy 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 generare output di informazioni di debug nello strumento di debug di Apigee. Consulta Eseguire il debug con le istruzioni print() di JavaScript.
L'oggetto delle proprietà
Quando utilizzi un elemento Properties
nella configurazione della policy, 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>
Poi, 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, il seguente specifica il "nome della variabile" e lo stile di output in cui JavaScript deve inserire 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>
emit-results.js
, il codice potrebbe fare questo:
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 all'oggetto di crittografia
L'oggetto crypto consente di eseguire funzioni di hashing crittografico di base in JavaScript.
L'oggetto crypto ha ambito globale. È disponibile ovunque all'interno del flusso del proxy API. Crypto ti consente di lavorare con questi oggetti hash:
- SHA-1
- SHA256
- SHA512
- MD5
Utilizzo degli oggetti SHA-1
Puoi creare oggetti SHA-1, aggiornarli e convertirli in valori esadecimali e base64.
Creare 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");
Restituisce 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.
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");
Restituisce 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 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");
Restituisce 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");
Restituisce 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 le criptovalute
L'oggetto crypto 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: "AAAA-MM-GG HH:mm:ss.SSS"
- timezone: (stringa, facoltativo) l'implementazione sottostante per questo parametro è java.util.TimeZone. Questo parametro è lo stesso. Valore predefinito: UTC
- time: (numero, facoltativo) un valore timestamp Unix da formattare. Valore predefinito: ora corrente
Esempi
Ottieni l'ora attuale, fino ai millisecondi:
var _now = crypto.dateFormat('YYYY-MM-DD HH:mm:ss.SSS');
Per ottenere 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 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. Consulta anche la documentazione di 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 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');
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 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
- context object summary
- Metodi dell'oggetto contesto
- context object properties
- context object children
Viene creato un oggetto context
per ogni transazione di richiesta/risposta eseguita da un
proxy API. L'oggetto context
espone metodi per ottenere, impostare e rimuovere variabili
relative a ogni transazione.
Le variabili definiscono 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 il riferimento alle variabili di flusso e le norme ExtractVariables.
context object summary
Questa tabella descrive brevemente l'oggetto contesto e i relativi elementi 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. | flow, session |
context. proxyRequest |
Un oggetto che rappresenta il messaggio di richiesta in entrata a ProxyEndpoint (dall'app che effettua la richiesta 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, 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 attuale. | Vedi context.flow. |
context.session |
Una mappa di coppie nome/valore che puoi utilizzare per passare oggetti tra due passaggi diversi
eseguiti nello stesso contesto. Ad esempio: context.session['key'] = 123 . |
Per saperne di più su quando e quando non utilizzare questo oggetto, vedi Qual è la differenza tra context.session["hello"] = {} e context.setVariable("hello", {}). |
context object methods
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 modificabile.
Sintassi
context.setVariable("variable-name", value);
Esempio
Uno scenario comune per l'impostazione di una variabile si verifica quando un proxy API deve scrivere dinamicamente l'URL di destinazione. Il seguente codice JavaScript ottiene il valore di una variabile denominata USER.name, lo aggiunge come parametro di query all'URL
http://mocktarget.apigee.net?user=
e poi imposta il valore predefinito
target.url
su questo 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à dell'oggetto contesto
La proprietà flow
è una stringa che identifica il flusso proxy API corrente. 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 e tutti i flussi condizionali definiti in ProxyEndpoint o TargetEndpoint.
Questa proprietà facoltativa è utile quando il codice JavaScript comune viene eseguito in più di un flusso, ma il suo comportamento può variare a seconda del flusso in cui viene eseguito. Utilizza la proprietà Flow per i moduli JavaScript destinati al riutilizzo in più proxy API, in cui il codice deve controllare il flusso corrente prima di eseguire la logica.
Esempio
Imposta un'intestazione HTTP solo nel 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'; }
Una mappa di coppie nome/valore che può essere utilizzata per passare oggetti tra due criteri eseguiti nello stesso contesto del messaggio.
Esempio
Imposta un valore nella sessione:
context.session['key'] = 123;
Recupera il valore dalla sessione:
var value = context.session['key']; // 123
Elementi secondari dell'oggetto di 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 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.*Request child objects
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 alla destinazione di backend).
L'oggetto context
ha oggetti secondari che rappresentano questi messaggi di richiesta:
context.proxyRequest
e context.targetRequest
. Questi oggetti ti consentono di
accedere alle proprietà all'interno del flusso di richiesta che rientra nell'ambito di esecuzione del codice JavaScript.
context.*Request child object properties
Nome proprietà | Descrizione |
---|---|
url |
La proprietà L'URL completo della richiesta è composto dalle seguenti proprietà:
Quando viene recuperato
|
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 ylSkZIjbdWybfs4fUQe9BqP0LH5Z 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 |
Esempi: "?city=PaloAlto&city=NewYork" può essere 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) associato 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 ha i seguenti membri:
|
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 un corpo della 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 child objects
Per ogni transazione HTTP eseguita in un proxy API, vengono creati due oggetti messaggio di risposta: uno in entrata (la risposta dal servizio di backend) e uno in uscita (la risposta inviata al client).
L'oggetto contesto ha oggetti secondari che rappresentano questi messaggi di risposta:
context.proxyResponse
e context.targetResponse
. Questi oggetti ti consentono di
accedere alle proprietà all'interno del flusso di risposta che rientra nell'ambito di applicazione quando viene eseguito il codice JavaScript.
context.*Response object properties
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 il 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 (contenuto del payload) del messaggio di risposta. Il contenuto della risposta ha 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 di stringa e JavaScript li forzerà a diventare stringhe. Nel primo caso
(*.content
), la stringa include tutte le dichiarazioni e i commenti XML. Nel
secondo caso (*.content.asXML
), il valore stringa del risultato viene pulito 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 di elementi e attributi. Non è possibile attraversare la gerarchia
utilizzando l'altra sintassi.
Eseguire il debug con le istruzioni print() di JavaScript
Se utilizzi la norma JavaScript per eseguire codice JavaScript personalizzato, tieni presente che puoi utilizzare la funzione print() per generare informazioni di debug nello 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 da tutte le transazioni nella parte inferiore della
finestra di debug. Puoi trovare l'output anche nella proprietà di debug denominata stepExecution-stdout
.
Creare callout JavaScript con httpClient
Utilizza httpClient
per effettuare più richieste HTTP asincrone parallele a qualsiasi URL
all'interno del codice JavaScript personalizzato eseguito in un flusso proxy API.
L'oggetto httpClient
è esposto dal modello di oggetto JavaScript di Apigee.
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 unico metodo API.
Ecco un pattern 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 l'oggetto
Request.
var myRequest = new Request(); myRequest.url = "http://www.example.com"; var exchangeObj = httpClient.send(myRequest);
httpClient Reference
Il client HTTP espone due metodi: get()
e send()
.
httpClient.get()
Un metodo pratico per semplici richieste HTTP GET
, 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 andato a buon fine.isComplete()
: (booleano) restituiscetrue
se la richiesta è completa.waitForComplete()
: mette in pausa il thread finché la richiesta non viene completata (con esito positivo o errore).getResponse()
: (oggetto) Restituisce l'oggetto della risposta se ilhttpClient.send()
è stato completato e ha avuto esito positivo. L'oggetto restituito ha gli stessi metodi e proprietà dell'oggetto context.proxyResponse. Vedi Riepilogo dell'oggetto contesto.getError()
: (stringa) se la chiamata ahttpClient.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 non bloccante 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);
Utilizzo delle norme JavaScript
Utilizza il criterio JavaScript per collegare codice JavaScript personalizzato a un flusso proxy. Consulta le norme JavaScript.