Modello oggetto JavaScript

Stai visualizzando la documentazione di Apigee Edge.
Consulta la documentazione di Apigee X. info

Questo argomento descrive il modello oggetto JavaScript di Apigee Edge. È importante comprendere questo modello se intendi utilizzare la norma JavaScript per aggiungere JavaScript personalizzato a un proxy API.

Informazioni sul modello oggetto JavaScript Edge

Il modello oggetto JavaScript di Apigee Edge definisce oggetti con proprietà associate che sono disponibili per il codice JavaScript eseguito all'interno di un flusso proxy Apigee Edge. Utilizzi la norma JavaScript per collegare questo codice personalizzato a un flusso 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 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 notazione abbreviata che consente l'accesso all'oggetto richiesta
• response: una notazione abbreviata che consente l'accesso all'oggetto richiesta
• 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 un 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 della 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, vedi Riferimento all'oggetto contesto di seguito.

L'oggetto di crittografia

L'oggetto crypto aggiunge il supporto crittografico di base e ad alte prestazioni al modello oggetto JavaScript. Per maggiori dettagli ed esempi, consulta la riferimento all'oggetto criptovaluta di seguito.

Gli 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 informazioni di debug nello strumento Edge Trace. Consulta Eseguire il debug con le istruzioni JavaScript print().

L'oggetto delle proprietà

Quando utilizzi un elemento 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>

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 un ambito globale. È disponibile ovunque all'interno del flusso 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.

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

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

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

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

Ottieni 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 ten_seconds = 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 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 contesto

• context object summary
• metodi dell'oggetto contesto
• Proprietà dell'oggetto di contesto
• 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 Riferimento alle variabili di flusso e le norme relative all'estrazione delle variabili.

context object summary

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

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, aggiunge questo valore 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 di contesto

context.flow

La proprietà flow è una stringa che identifica il flusso del 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 ProxyEndpoints o TargetEndpoints.

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

context.session

Una mappa di coppie nome/valore che possono essere utilizzate per passare oggetti tra due criteri in esecuzione nello stesso contesto del messaggio.

Esempio

Imposta un valore nella sessione:

context.session['key']  = 123;

Ottieni il valore dalla sessione:

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

context object children

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
• context.*Response child objects

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.

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

context.*Request child object properties

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

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

application/json
Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z

"?city=PaloAlto&city=NewYork"

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

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

context.proxyRequest.method;

POST

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

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

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

{
"a":  1 ,
"b" : "2"
}

var a = context.proxyRequest.body.asJSON.a;    // == 1
var b = context.proxyRequest.body.asJSON.b;    // == 2

"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 inbound (la risposta dal servizio di backend) e uno outbound (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 rientrano nell'ambito di applicazione quando viene eseguito 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.

context.*Proprietà dell'oggetto Response

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

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

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 ripulito 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 il criterio JavaScript per eseguire codice JavaScript personalizzato, tieni presente che puoi utilizzare la funzione print() per generare informazioni di debug nello strumento di tracciamento. 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 in fondo alla finestra Trace. Puoi trovare l'output anche nella proprietà Trace denominata stepExecution-stdout.

Creare callout JavaScript con httpClient

Utilizza httpClient per effettuare più richieste HTTP asincrone e 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 Edge.

Informazioni su httpClient

L'oggetto httpClient è esposto al codice JavaScript personalizzato in esecuzione su Apigee Edge 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. Questo oggetto è di uso comune come alternativa alla policy ServiceCallout.

Ecco un pattern di utilizzo di base. Crea un oggetto Request, assegnagli un URL (ad esempio, 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) 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 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 ha avuto esito positivo.
• isComplete(): (booleano) Restituisce true 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 httpClient.send() è stato completato e ha avuto esito positivo. L'oggetto restituito ha gli stessi metodi e proprietà dell'oggetto context.proxyResponse. Vedi 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 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.

Argomenti correlati

• Norme JavaScript
• Modello oggetto JavaScript
• Per esempi e istruzioni di base, consulta Programmazione di 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:

• Come gestire le intestazioni con più valori in JavaScript?
• The Book of Apigee Edge Antipatterns