Questa pagina si applica ad Apigee e Apigee hybrid.
Visualizza la documentazione di Apigee Edge.
Cosa
Questo criterio converte i messaggi dal formato XML (Extensible Markup Language) in JSON (JavaScript Object Notation), che offre diverse opzioni per controllare la modalità di conversione dei messaggi.
Supponendo che l'intento sia quello di convertire una risposta in formato XML in una risposta in formato JSON, il criterio viene associato a un flusso di risposta (ad esempio, Response / ProxyEndpoint/PostFlow).
Questo è un criterio standard e può essere implementato in qualsiasi tipo di ambiente. Non tutti gli utenti devono conoscere i tipi di criteri e di ambiente. Per informazioni sui tipi di criteri e sulla disponibilità con ogni tipo di ambiente, consulta Tipi di criteri.
Informazioni
In uno scenario di mediazione tipico, un criterio da JSON a XML nel flusso di richieste in entrata è spesso abbinato a un criterio da XML a JSON nel flusso di risposta in uscita. Combinando i criteri in questo modo, un'API JSON può essere esposta per i servizi di backend che supportano in modo nativo solo XML.
Per gli scenari in cui le API vengono utilizzate da diverse app client che possono richiedere JSON o XML, il formato della risposta può essere impostato in modo dinamico configurando i criteri da JSON a XML e da XML a JSON per l'esecuzione condizionale. Consulta Variabili e condizioni di flusso per un'implementazione di questo scenario.
Esempi
Per una discussione dettagliata sulla conversione tra JSON e XML, consulta questo articolo.
Conversione di una risposta
<XMLToJSON name="ConvertToJSON"> <Options> </Options> <OutputVariable>response</OutputVariable> <Source>response</Source> </XMLToJSON>
Questa configurazione, che è la configurazione minima necessaria per convertire il file XML in JSON, utilizza un messaggio di risposta in formato XML come origine e crea un messaggio in formato JSON che viene compilato nella variabile di output response
. Apigee
utilizza automaticamente i contenuti di questa variabile come messaggio per il passaggio di elaborazione successivo.
Riferimento elemento
Di seguito sono riportati gli elementi e gli attributi che puoi configurare in questo criterio.
<XMLToJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1"> <DisplayName>XML to JSON 1</DisplayName> <Source>response</Source> <OutputVariable>response</OutputVariable> <Options> <RecognizeNumber>true</RecognizeNumber> <RecognizeBoolean>true</RecognizeBoolean> <RecognizeNull>true</RecognizeNull> <NullValue>NULL</NullValue> <NamespaceBlockName>#namespaces</NamespaceBlockName> <DefaultNamespaceNodeName>&</DefaultNamespaceNodeName> <NamespaceSeparator>***</NamespaceSeparator> <TextAlwaysAsProperty>true</TextAlwaysAsProperty> <TextNodeName>TEXT</TextNodeName> <AttributeBlockName>FOO_BLOCK</AttributeBlockName> <AttributePrefix>BAR_</AttributePrefix> <OutputPrefix>PREFIX_</OutputPrefix> <OutputSuffix>_SUFFIX</OutputSuffix> <StripLevels>2</StripLevels> <TreatAsArray> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> </Options> <!-- Use Options or Format, not both --> <Format>yahoo</Format> </XMLToJSON>
Attributi <XMLtoJSON>
<XMLtoJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1">
La tabella seguente descrive gli attributi comuni a tutti gli elementi principali dei criteri:
Attributo | Descrizione | Predefinito | Presenza |
---|---|---|---|
name |
Il nome interno della norma. Il valore dell'attributo Facoltativamente, utilizza l'elemento |
N/A | Obbligatorio |
continueOnError |
Impostalo su Imposta su |
false | Facoltativo |
enabled |
Imposta il criterio su Impostala su |
true | Facoltativo |
async |
Questo attributo è obsoleto. |
false | Deprecata |
Elemento <DisplayName>
Utilizzalo in aggiunta all'attributo name
per etichettare il criterio nell'editor proxy dell'interfaccia utente di gestione con un nome diverso in linguaggio naturale.
<DisplayName>Policy Display Name</DisplayName>
Predefinito |
N/A Se ometti questo elemento, viene utilizzato il valore dell'attributo |
---|---|
Presenza | Facoltativo |
Tipo | Stringa |
Elemento <Source>
La variabile che specifica il messaggio XML da convertire in JSON.
L'intestazione Content-type HTTP del messaggio di origine deve essere impostata su application/xml
, altrimenti il criterio non viene applicato in modo forzato.
Se <Source>
non viene definito, viene trattato come message
, che si risolve in request
quando il criterio viene associato a un flusso di richiesta, oppure response
quando il criterio viene associato a un flusso di risposta.
Se la variabile di origine non può essere risolta o se si risolve in un tipo non di messaggio, il criterio genera un errore.
<Source>response</Source>
Predefinito | Il valore dell'elemento Source |
---|---|
Presenza | Facoltativo |
Tipo | Messaggio |
Elemento <OutputVariable>
Specifica dove archiviare l'output della conversione da XML a JSON. In genere, questo elemento non è incluso nella configurazione dei criteri.
Apigee analizza il payload del messaggio XML specificato in Source
, lo converte in JSON, archivia il risultato nel payload di OutputVariable
e imposta l'intestazione Content-type HTTP del messaggio OutputVariable
su application/json
.
Se OutputVariable
non è specificato, viene utilizzato il valore di Source
per impostazione predefinita. Ad esempio, se source
è response
,
il valore predefinito di OutputVariable
sarà response
.
<OutputVariable>response</OutputVariable>
Predefinito | il messaggio specificato in Source |
---|---|
Presenza | Facoltativo |
Tipo | Messaggio |
<Opzioni>
Le opzioni ti consentono di controllare la conversione da XML a JSON. Utilizza il gruppo
<Options>
, che consente di aggiungere impostazioni di conversione specifiche, oppure l'elemento
<Format>
, che consente di fare riferimento a un modello di
opzioni predefinite. Non puoi utilizzare contemporaneamente <Options>
e
<Format>
.
<Options>
è obbligatorio se non viene utilizzato <Format>
.
Elemento <RecognizeNumber>
Se il valore è true, i campi numerici nel payload XML mantengono il formato originale.
<RecognizeNumber>true</RecognizeNumber>
Considera il seguente esempio XML:
<a> <b>100</b> <c>value</c> </a>
Se RecognizeNumber
è true
, il criterio converte questo testo in:
{ "a": { "b": 100, "c": "value" } }
Se RecognizeNumber
è false
, il criterio converte questo testo in:
{ "a": { "b": "100", "c": "value" } }
Predefinito | false |
---|---|
Presenza | Facoltativo |
Tipo | Booleano |
Elemento <RecognitionBoolean>
Consente alla conversione di mantenere valori booleani vero/falso anziché trasformare i valori in stringhe.
<RecognizeBoolean>true</RecognizeBoolean>
Per il seguente esempio XML:
<a> <b>true</b> <c>value</c> </a>
Se RecognizeBoolean
è true
, il criterio converte questo testo in:
{ "a": { "b": true, "c": "value" } }
Se RecognizeBoolean
è false
, il criterio converte questo testo in:
{ "a": { "b": "true", "c": "value" } }
Predefinito | false |
---|---|
Presenza | Facoltativo |
Tipo | Booleano |
Elemento <RecognitionNull>
Consente di convertire i valori vuoti in valori nulli.
<RecognizeNull>true</RecognizeNull>
Per il seguente XML:
<a> <b></b> <c>value</c> </a>
Se RecognizeNull
è true
e in assenza di un'opzione NullValue
,
questo XML viene convertito in:
{ "a": { "b": null, "c": "value" } }
Se RecognizeNull
è false
, questo XML viene convertito in:
{ "a": { "b": {}, "c": "value" } }
Predefinito | false |
---|---|
Presenza | Facoltativo |
Tipo | Booleano |
Elemento <NullValue>
Indica il valore in cui convertire i valori null riconosciuti nel messaggio di origine. Per impostazione predefinita, il valore è null
. Questa opzione ha effetto solo se RecognizeNull
è true.
<NullValue>not-present</NullValue>
Per il seguente XML:
<a> <b></b> <c>value</c> </a>
Se RecognizeNull
è true
e NullValue
non è specificato,
questo XML viene convertito in:
{ "a": { "b": null, "c": "value" } }
Se RecognizeNull
è true
e NullValue
è
not-present
, questo XML viene convertito in:
{ "a": { "b": "not-present", "c": "value" } }
Predefinito | null |
---|---|
Presenza | Facoltativo |
Tipo | Stringa |
Opzioni dello spazio dei nomi
Per impostazione predefinita, questo criterio omette gli spazi dei nomi XML nel JSON generato. Per specificare che gli spazi dei nomi nel documento XML devono essere tradotti nel JSON generato, utilizza questi elementi insieme.
<NamespaceBlockName>#namespaces</NamespaceBlockName> <DefaultNamespaceNodeName>&</DefaultNamespaceNodeName> <NamespaceSeparator>***</NamespaceSeparator>
Considera il seguente esempio XML:
<a xmlns="http://ns.com" xmlns:ns1="http://ns1.com"> <ns1:b>value</ns1:b> </a>
Se NamespaceSeparator
non è specificato, viene generata la seguente struttura JSON:
{ "a": { "b": "value" } }
Se gli elementi NamespaceBlockName
, DefaultNamespaceNodeName
e
NamespaceSeparator
vengono specificati rispettivamente come #namespaces
, &
e ***
, viene generata la seguente struttura JSON:
{ "a": { "#namespaces": { "&": "http://ns.com", "ns1": "http://ns1.com" }, "ns1***b": "value" } }
Predefinito | Nessuno. Se <NamespaceBlockName> non è specificato, il criterio genererà un JSON di output che non faccia riferimento a nessuno spazio dei nomi XML, a prescindere dal fatto che il messaggio di origine faccia riferimento a spazi dei nomi. |
---|---|
Presenza | Facoltativo Tuttavia, se specifichi <NamespaceBlockName> , devi specificare anche gli altri due elementi. |
Tipo | Stringhe |
Opzioni testo
Utilizza questi elementi insieme.
<TextAlwaysAsProperty>true|false</TextAlwaysAsProperty> <TextNodeName>TEXT</TextNodeName>
Quando il criterio rileva un elemento XML che contiene un solo nodo di testo come elemento figlio, il criterio traduce i contenuti testuali dell'elemento XML in una proprietà nell'hash JSON.
Quando il criterio rileva un elemento XML che contiene più elementi secondari di contenuti misti, queste opzioni ti consentono di controllare il JSON di output di qualsiasi nodo di testo figlio.
Ad esempio, considera questa configurazione dei criteri:
<XMLToJSON name='XMLToJSON-1'> <Options> <TextAlwaysAsProperty>???</TextAlwaysAsProperty> <TextNodeName>#text</TextNodeName> </Options> </XMLToJSON>
Per gli input XML specificati, il criterio genererà questi output, a seconda che TextAlwaysAsProperty
sia true
o false
:
Input XML | Output JSON | |
---|---|---|
quando TextAlwaysAsProperty è false |
quando TextAlwaysAsProperty è true |
|
<a>value1</a> |
{ "a": "value1" } |
{ "a": { "#text": "value1" } } |
<a>value1 <b>value2</b> </a> |
{ "a": { "#text": "value1\n", "b": "value2" } } |
{ "a": { "#text": "value1\n", "b": { "#text": "value2" } } } |
Predefinito | <TextAlwaysAsProperty> : false<TextNodeName> : (stringa vuota) |
---|---|
Presenza | Facoltativo |
Tipo | <TextAlwaysAsProperty> : valore booleano<TextNodeName> : stringa |
Opzioni degli attributi
Questi elementi, insieme, ti consentono di raggruppare i valori degli attributi in un blocco JSON e aggiungere prefissi ai nomi degli attributi.
<AttributeBlockName>FOO_BLOCK</AttributeBlockName> <AttributePrefix>BAR_</AttributePrefix>
Considera il seguente esempio XML:
<a attrib1="value1" attrib2="value2"/>
Se entrambi gli attributi (AttributeBlockName
e AttributePrefix
) vengono specificati come definito nell'esempio da XML a JSON, viene generata la seguente struttura JSON:
{ "a": { "FOO_BLOCK": { "BAR_attrib1": "value1", "BAR_attrib2": "value2" } } }
Se viene specificato solo AttributeBlockName
, viene generata la seguente struttura JSON:
{ "a": { "FOO_BLOCK": { "attrib1": "value1", "attrib2": "value2" } } }
Se viene specificato solo AttributePrefix
, viene generata la seguente struttura JSON:
{ "a": { "BAR_attrib1": "value1", "BAR_attrib2": "value2" } }
Se nessuno dei due valori è specificato, viene generata la seguente struttura JSON:
{ "a": { "attrib1": "value1", "attrib2": "value2" } }
Predefinito | nessuno. |
---|---|
Presenza | Facoltativo |
Tipo | Stringa |
Elementi <OutputPrefix> e <OutputSuffix>.
Utilizza questi elementi insieme per applicare un prefisso e/o un suffisso al JSON generato.
<OutputPrefix>PREFIX_</OutputPrefix> <OutputSuffix>_SUFFIX</OutputSuffix>
Considera il seguente esempio XML:
<a>value</a>
Supponiamo che la configurazione dei criteri sia la seguente:
<XMLToJSON name='XMLToJSON-4'> <Options> <OutputPrefix>{ "result": </OutputPrefix> <OutputSuffix>}</OutputSuffix> </Options> </XMLToJSON>
Viene generata la seguente struttura JSON:
{ "result": { "a": "value" } }
Puoi omettere una o entrambe le opzioni OutputPrefix
e OutputSuffix
.
Utilizzando questi elementi, è possibile generare un JSON non valido. Ad esempio, utilizzando questa configurazione dei criteri:
<XMLToJSON name='XMLToJSON-4'> <Options> <OutputPrefix>PREFIX_</OutputPrefix> </Options> </XMLToJSON>
Il criterio genera quanto segue, che non è un JSON valido:
PREFIX_{ "a" : "value" }
Se la configurazione non specifica né OutputPrefix
né OutputSuffix
,
il criterio genera la seguente struttura JSON:
{ "a": "value" }
Predefinito | Guarda gli esempi in alto. |
---|---|
Presenza | Facoltativo |
Tipo | Stringa |
Elemento <StripLevels>
<Options> <StripLevels>4</StripLevels> </Options>
A volte i payload XML, come SOAP, hanno molti livelli padre che non vuoi includere nel JSON convertito. Ecco un esempio di risposta SOAP contenente molti livelli:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/Schemata-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <soap:Body> <GetCityWeatherByZIPResponse xmlns="http://ws.cdyne.com/WeatherWS/"> <GetCityWeatherByZIPResult> <State>CO</State> <City>Denver</City> <Description>Sunny</Description> <Temperature>62</Temperature> </GetCityWeatherByZIPResult> </GetCityWeatherByZIPResponse> </soap:Body> </soap:Envelope>
Prima di raggiungere il livello Stato, Città, Descrizione e Temperatura, sono previsti 4 livelli.
Senza utilizzare <StripLevels>
, la risposta JSON convertita sarebbe simile a questa:
{ "Envelope" : { "Body" : { "GetCityWeatherByZIPResponse" : { "GetCityWeatherByZIPResult" : { "State" : "CO", "City" : "Denver", "Description" : "Sunny", "Temperature" : "62" } } } } }
Se vuoi eliminare i primi 4 livelli nella risposta JSON, devi impostare <StripLevels>4</StripLevels>
, che ti fornirà il seguente JSON:
{ "State" : "CO", "City" : "Denver", "Description" : "Sunny", "Temperature" : "62" }
Puoi rimuovere i livelli fino al primo elemento che contiene più elementi secondari. Che cosa significa? Diamo un'occhiata a un esempio JSON più complesso:
{ "Envelope" : { "Body" : { "GetCityForecastByZIPResponse" : { "GetCityForecastByZIPResult" : { "ResponseText" : "City Found", "ForecastResult" : { "Forecast" : [ { "ProbabilityOfPrecipiation" : { "Nighttime" : "00", "Daytime" : 10 } ...
Il livello 3 in questo esempio è GetCityForecastByZIPResponse
, che ha un solo
elemento figlio. Quindi, se dovessi utilizzare <StripLevels>3</StripLevels>
(rimuovi i primi tre livelli), il formato JSON sarebbe simile al seguente:
{ "GetCityForecastByZIPResult" : { "ResponseText" : "City Found", "ForecastResult" : { "Forecast" : [ { "ProbabilityOfPrecipiation" : { "Nighttime" : "00", "Daytime" : 10 } ...
Nota che GetCityForecastByZIPResult
ha più figli. Poiché è il primo elemento contenente più elementi secondari, puoi rimuovere quest'ultimo livello utilizzando <StripLevels>4</StripLevels>
, che ti fornirà il seguente JSON:
{ "ResponseText" : "City Found", "ForecastResult" : { "Forecast" : [ { "ProbabilityOfPrecipiation" : { "Nighttime" : "00", "Daytime" : 10 } ...
Poiché il livello 4 è il primo che contiene più elementi secondari, non puoi rimuovere livelli inferiori a questo. Se imposti il livello della striscia su 5, 6, 7 e così via, continuerai a ricevere la risposta indicata sopra.
Predefinito | 0 (nessuna rimozione del livello) |
---|---|
Presenza | Facoltativo |
Tipo | Numero intero |
Elemento <TreatAsArray>/<Path>
<Options> <TreatAsArray> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> </Options>
Questa combinazione di elementi consente di garantire che i valori di un documento XML vengano sempre tradotti in un array JSON. Questo può essere utile quando il numero di elementi secondari varia a seconda dei payload. Il comportamento predefinito di Apigee prevede la conversione di più elementi secondari con lo stesso nome in un array JSON e di singoli elementi secondari in una primitiva JSON. L'opzione TreatAsArray
consente di assicurare che gli elementi secondari vengano sempre tradotti in un array JSON.
L'utilizzo di TreatAsArray
può migliorare la struttura del codice successivo che gestisce l'output, poiché i dati dell'array vengono restituiti sempre allo stesso modo. Ad esempio, la valutazione di un JSONPath di $.teachers.teacher.studentnames.name[0]
restituirà il valore del nome in modo coerente, indipendentemente dal fatto che il file XML originale conteneva uno o più elementi name
.
Facciamo un passo indietro e osserviamo il comportamento predefinito da XML a JSON, quindi vediamo come controllare l'output utilizzando <TreatAsArray>/<Path>
.
Quando un documento XML contiene un elemento con più occorrenze (cosa che può accadere quando lo schema XML specifica maxOccurs='unbounded'
per l'elemento), il criterio da XML a JSON inserisce automaticamente quei valori in un array. Ad esempio, il seguente blocco XML
<teacher> <name>teacherA</name> <studentnames> <name>student1</name> <name>student2</name> </studentnames> </teacher>
...viene convertito automaticamente nel seguente JSON senza alcuna configurazione di criteri speciale:
{ "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ] } } } }
Nota che i nomi dei due studenti sono contenuti in un array.
Tuttavia, se nel documento XML compare un solo studente, il criterio da XML a JSON tratta automaticamente il valore come una singola stringa, non come un array di stringhe, come mostrato nell'esempio seguente:
{ "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : "student1" } } } }
Negli esempi precedenti, dati simili sono stati convertiti in modo diverso, una volta in un array, un altro in una singola stringa. L'elemento <TreatAsArray>/<Path>
ti consente di controllare l'output per assicurarti che i nomi degli studenti vengano sempre convertiti in un array anche se è presente un solo valore. Per configurarlo, identifica il percorso dell'elemento di cui vuoi convertire i valori in un array, ad esempio:
<Options> <TreatAsArray> <Path>teachers/teacher/studentnames/name</Path> </TreatAsArray> </Options>
La configurazione precedente genererà il codice JSON come segue:
{ "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : ["student1"] } } } }
Nota che studente1 ora è in un array. Ora, indipendentemente dal fatto che ci siano uno o più studenti, puoi recuperarli da un array JSON nel codice utilizzando il seguente JSONPath: $.teachers.teacher.studentnames.name[0]
L'elemento <Path>
ha anche un attributo unwrap
, come spiegato nella
sezione successiva.
Predefinito | N/D |
---|---|
Presenza | Facoltativo |
Tipo | Stringa |
Attributi
<Options> <TreatAsArray> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> </Options>
Attributo | Descrizione | Presenza | Tipo |
---|---|---|---|
unwrapping |
Valore predefinito: false Rimuove l'elemento dall'output JSON. Utilizza questo strumento per semplificare o suddividere ("unwrapare") il JSON, il che accorcia anche il JSONPath necessario per recuperare i valori. Ad esempio,
anziché Ecco un esempio JSON: { "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ]}... In questo esempio, potresti sostenere che l'elemento <TreatAsArray> <Path unwrap="true">teachers/teacher</Path> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> L'attributo { "teachers" : [{ "name" : "teacherA", "studentnames" : ["student1","student2"] }]... Tieni presente che, poiché l'elemento |
Facoltativo | Booleano |
Per altri esempi e per la procedura dettagliata sulle funzionalità, consulta questo articolo della community Google Cloud.
<Formato>
Il formato ti consente di controllare la conversione da XML a JSON. Inserisci il nome di un modello predefinito che contiene una combinazione specifica di elementi Opzioni descritti in questo argomento.
I formati predefiniti includono: xml.com
, yahoo
, google
,
badgerFish
.
Utilizza l'elemento <Format>
o il gruppo <Options>
. Non puoi utilizzare
contemporaneamente <Format>
e <Options>
.
Di seguito sono riportate le definizioni dei formati di ciascun modello predefinito.
xml.com
<RecognizeNull>true</RecognizeNull> <TextNodeName>#text</TextNodeName> <AttributePrefix>@</AttributePrefix>
yahoo
<RecognizeNumber>true</RecognizeNumber> <TextNodeName>content</TextNodeName>
<TextNodeName>$t</TextNodeName> <NamespaceSeparator>$</NamespaceSeparator> <TextAlwaysAsProperty>true</TextAlwaysAsProperty>
badgerFish
<TextNodeName>$</TextNodeName> <TextAlwaysAsProperty>true</TextAlwaysAsProperty> <AttributePrefix>@</AttributePrefix> <NamespaceSeparator>:</NamespaceSeparator> <NamespaceBlockName>@xmlns</NamespaceBlockName> <DefaultNamespaceNodeName>$</DefaultNamespaceNodeName>
Sintassi dell'elemento:
<Format>yahoo</Format>
Predefinito | (nessuno) |
---|---|
Valori validi | Uno dei seguenti:xml.com , yahoo , google , badgerFish |
Presenza | Facoltativo, ma obbligatorio se non viene utilizzato <Options> . |
Tipo | Stringa |
Schema
Messaggi di errore
Questa sezione descrive i codici e i messaggi di errore che vengono restituiti e le variabili di errore impostate da Apigee quando questo criterio attiva un errore. Queste informazioni sono importanti per sapere se si stanno sviluppando regole di errore per gestire gli errori. Per scoprire di più, consulta gli articoli Cosa devi sapere sugli errori relativi alle norme e Gestione degli errori.
Errori di runtime
Questi errori possono verificarsi quando il criterio viene eseguito.
Codice di errore | Stato HTTP | Causa | Correggi |
---|---|---|---|
steps.xmltojson.ExecutionFailed |
ExecutionFailed |
Questo errore si verifica quando il payload di input (XML) è vuoto o l'XML di input non è valido o è in un formato non corretto. | build |
steps.xmltojson.InCompatibleTypes |
ExecutionFailed |
Questo errore si verifica se il tipo della variabile definita nell'elemento <Source> e
nell'elemento <OutputVariable> non corrispondono. È obbligatorio che il tipo di variabili
contenute all'interno dell'elemento <Source> e dell'elemento <OutputVariable> corrisponda.
|
build |
steps.xmltojson.InvalidSourceType |
ExecutionFailed |
Questo errore si verifica se il tipo di variabile utilizzata per definire l'elemento <Source> non è valido.I tipi di variabile validi sono messaggio e stringa. |
build |
steps.xmltojson.OutputVariableIsNotAvailable |
ExecutionFailed |
Questo errore si verifica se la variabile specificata nell'elemento <Source> del criterio da XML a
JSON è di tipo stringa e l'elemento <OutputVariable> non è definito.
L'elemento <OutputVariable> è obbligatorio quando la variabile definita nell'elemento <Source> è di tipo stringa. |
build |
steps.xmltojson.SourceUnavailable |
ExecutionFailed |
Questo errore si verifica se la variabile message
specificata nell'elemento <Source> del criterio da XML a JSON è:
|
build |
Errori di deployment
Questi errori possono verificarsi quando esegui il deployment di un proxy contenente questo criterio.
Nome errore | Causa | Correggi |
---|---|---|
EitherOptionOrFormat |
Se uno degli elementi <Options> o <Format> non viene dichiarato nel criterio da XML a JSON, il deployment del proxy API non va a buon fine.
|
build |
UnknownFormat |
Se per l'elemento <Format> all'interno del criterio da XML a JSON è stato definito un formato sconosciuto, il deployment del proxy API non riesce. I formati predefiniti includono:
xml.com , yahoo , google e badgerFish .
|
build |
Variabili di errore
Queste variabili vengono impostate quando si verifica un errore di runtime. Per maggiori informazioni, consulta la sezione Cosa devi sapere sugli errori relativi ai criteri.
Variabili | Dove | Esempio |
---|---|---|
fault.name="fault_name" |
fault_name è il nome dell'errore, come indicato nella tabella Errori di runtime riportata sopra. Il nome del guasto è l'ultima parte del codice di errore. | fault.name = "SourceUnavailable" |
xmltojson.policy_name.failed |
policy_name è il nome specificato dall'utente del criterio che ha generato l'errore. | xmltojson.XMLtoJSON-1.failed = true |
Esempio di risposta di errore
{ "fault": { "faultstring": "XMLToJSON[XMLtoJSON-1]: Source xyz is not available", "detail": { "errorcode": "steps.xml2json.SourceUnavailable" } } }
Esempio di regola di errore
<faultrule name="VariableOfNonMsgType"></faultrule><FaultRule name="XML to JSON Faults"> <Step> <Name>AM-SourceUnavailableMessage</Name> <Condition>(fault.name Matches "SourceUnavailable") </Condition> </Step> <Step> <Name>AM-BadXML</Name> <Condition>(fault.name = "ExecutionFailed")</Condition> </Step> <Condition>(xmltojson.XMLtoJSON-1.failed = true) </Condition> </FaultRule>
Argomenti correlati
Da JSON a XML: norme JSONtoXML