Questa pagina si applica a Apigee e Apigee ibridi.
Visualizza
documentazione di Apigee Edge.
Cosa
Questo criterio converte i messaggi dal formato Extensible Markup Language (XML) in JavaScript JSON (Object Notation), che offre diverse opzioni per controllare il modo in cui i messaggi vengono convertito.
Supponendo che lo scopo sia convertire una risposta in formato XML in un la risposta, il criterio viene collegato a un flusso di risposta (ad esempio Response / ProxyEndpoint) / PostFlow).
Questo criterio è un criterio standard e può essere implementato in qualsiasi tipo di ambiente. Non tutte gli utenti devono conoscere i tipi di criteri e di ambiente. Per informazioni sui tipi di criteri e sulla disponibilità per ciascun tipo di ambiente, consulta Tipi di criteri.
Informazioni
In un tipico scenario di mediazione, un criterio da JSON a XML nel flusso di richieste in entrata è spesso abbinate a un criterio da XML a JSON sul 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 scenari in cui le API vengono utilizzate da diverse app client che potrebbero richiedere JSON o XML, il formato della risposta può essere impostato dinamicamente configurando da JSON a XML e da XML a JSON e i criteri da eseguire in modo 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 minima richiesta per convertire il file XML
JSON: prende un messaggio di risposta in formato XML come origine e poi crea un
Messaggio in formato JSON che viene compilato nel campo OutputVariable response
. Apigee
utilizza automaticamente i contenuti di questa variabile come messaggio per la successiva fase di elaborazione.
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>
<XMLtoJSON> attributi
<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 |
<Source> elemento
La variabile che specifica il messaggio XML in cui vuoi convertire 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 collegato a un flusso di richieste oppure
response
quando il criterio è collegato a un flusso di risposta.
Se la variabile di origine non può essere risolta o si risolve in un tipo non messaggio, il criterio genera un errore.
<Source>response</Source>
Predefinito | Il valore dell'elemento Source |
---|---|
Presenza | Facoltativo |
Tipo | Messaggio |
<OutputVariable> elemento
Specifica dove archiviare l'output della conversione in formato XML in formato JSON. In genere, non è incluso nella configurazione del criterio.
Apigee analizza il payload del messaggio XML specificato in Source
, converte
in JSON, archivia il risultato nel payload di OutputVariable
e imposta il protocollo
Intestazione Content-Type del messaggio OutputVariable
a application/json
.
Se OutputVariable
non è specificato, viene utilizzato il valore di Source
per impostazione predefinita. Ad esempio, se source
è response
,
poi il valore predefinito di OutputVariable
è response
.
<OutputVariable>response</OutputVariable>
Predefinito | il messaggio specificato in Source |
---|---|
Presenza | Facoltativo |
Tipo | Messaggio |
<Options>
Le opzioni ti consentono di controllare la conversione da XML a JSON. Utilizza il
gruppo <Options>
, che ti consente di aggiungere impostazioni di conversione specifiche oppure il
<Format>
, che ti consente di fare riferimento a un modello di
predefinite. Non puoi utilizzare sia <Options>
che
<Format>
.
<Options>
è obbligatorio se non viene utilizzato <Format>
.
<RecognizeNumber> elemento
Se impostato su 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 lo converte in:
{ "a": { "b": 100, "c": "value" } }
Se RecognizeNumber
è false
, il criterio lo converte in:
{ "a": { "b": "100", "c": "value" } }
Predefinito | falso |
---|---|
Presenza | Facoltativo |
Tipo | Booleano |
<RecognizeBoolean> elemento
Consente alla conversione di mantenere i valori booleani vero/falso anziché convertire 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 lo converte in:
{ "a": { "b": true, "c": "value" } }
Se RecognizeBoolean
è false
, il criterio lo converte in:
{ "a": { "b": "true", "c": "value" } }
Predefinito | falso |
---|---|
Presenza | Facoltativo |
Tipo | Booleano |
<RecognizeNull> elemento
Consente di convertire i valori vuoti in valori null.
<RecognizeNull>true</RecognizeNull>
Per il seguente XML:
<a> <b></b> <c>value</c> </a>
Se RecognizeNull
è true
e se non è presente NullValue
, questo codice XML viene convertito in:
{ "a": { "b": null, "c": "value" } }
Se RecognizeNull
è false
, questo codice XML viene convertito in:
{ "a": { "b": {}, "c": "value" } }
Predefinito | falso |
---|---|
Presenza | Facoltativo |
Tipo | Booleano |
<NullValue> elemento
Indica il valore a cui devono essere assegnati i valori null riconosciuti nel messaggio di origine
convertito. Per impostazione predefinita, il valore è null
. Questa opzione è valida solo
se RecognizeNull
è vero.
<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 codice 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 file JSON generato. Per specificare degli spazi dei nomi nel documento XML devono essere tradotti nel file 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 applicata la seguente struttura JSON
generato:
{ "a": { "b": "value" } }
Se gli elementi NamespaceBlockName
, DefaultNamespaceNodeName
e
NamespaceSeparator
sono specificati come #namespaces
, &
,
e ***
, rispettivamente, viene generata la seguente struttura JSON:
{ "a": { "#namespaces": { "&": "http://ns.com", "ns1": "http://ns1.com" }, "ns1***b": "value" } }
Predefinito | Nessuno. Se <NamespaceBlockName> non viene specificato, il criterio verrà
generare un file JSON di output che non fa riferimento a spazi dei nomi XML, indipendentemente dal fatto che
il messaggio di origine si riferiva agli spazi dei nomi. |
---|---|
Presenza | Facoltativo Tuttavia, se specifichi <NamespaceBlockName> , devi specificare anche i campi
altri due elementi. |
Tipo | Stringhe |
Opzioni testo
Usa 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 figlio, Il criterio converte 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 consentono di controllare il JSON di output dei nodi di testo figlio.
Ad esempio, considera questa configurazione di 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
se TextAlwaysAsProperty
è 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> : falso<TextNodeName> : (stringa vuota) |
---|---|
Presenza | Facoltativo |
Tipo | <TextAlwaysAsProperty> : valore booleano<TextNodeName> : stringa |
Opzioni attributo
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
) sono
specificata 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 applicata la seguente struttura JSON
generato:
{ "a": { "FOO_BLOCK": { "attrib1": "value1", "attrib2": "value2" } } }
Se viene specificato solo AttributePrefix
, viene applicata la seguente struttura JSON
generato:
{ "a": { "BAR_attrib1": "value1", "BAR_attrib2": "value2" } }
Se nessuna delle due opzioni viene specificata, viene generata la seguente struttura JSON:
{ "a": { "attrib1": "value1", "attrib2": "value2" } }
Predefinito | nessuno. |
---|---|
Presenza | Facoltativo |
Tipo | Stringa |
<OutputPrefix> e <OutputSuffix> elementi
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 uno o entrambi i valori OutputPrefix
e OutputSuffix
.
Utilizzando questi elementi, è possibile generare un file JSON non valido. Ad esempio, utilizzando questo 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 qui sopra. |
---|---|
Presenza | Facoltativo |
Tipo | Stringa |
<StripLevels> elemento
<Options> <StripLevels>4</StripLevels> </Options>
A volte i payload XML, come SOAP, hanno molti livelli padre che non si desidera includere 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>
Ci sono 4 livelli prima di raggiungere i livelli Stato, Città, Descrizione e Temperatura.
Se non utilizzi <StripLevels>
, la risposta JSON convertita sarebbe simile a
questo:
{ "Envelope" : { "Body" : { "GetCityWeatherByZIPResponse" : { "GetCityWeatherByZIPResult" : { "State" : "CO", "City" : "Denver", "Description" : "Sunny", "Temperature" : "62" } } } } }
Se vuoi eliminare i primi quattro livelli dalla risposta JSON, devi impostare
<StripLevels>4</StripLevels>
, che restituisce quanto segue:
JSON:
{ "State" : "CO", "City" : "Denver", "Description" : "Sunny", "Temperature" : "62" }
Puoi eliminare i livelli fino al primo elemento che contiene più elementi secondari. Che cosa questo significa? Vediamo 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 ne ha solo uno
figlio/a. Pertanto, se utilizzi <StripLevels>3</StripLevels>
(rimuovi il
primi tre livelli), il codice JSON sarà simile al seguente:
{ "GetCityForecastByZIPResult" : { "ResponseText" : "City Found", "ForecastResult" : { "Forecast" : [ { "ProbabilityOfPrecipiation" : { "Nighttime" : "00", "Daytime" : 10 } ...
Nota che GetCityForecastByZIPResult
ha più elementi secondari. Poiché si tratta
primo elemento contenente più elementi secondari, puoi rimuovere quest'ultimo livello utilizzando
<StripLevels>4</StripLevels>
, che ti fornirà quanto segue
JSON:
{ "ResponseText" : "City Found", "ForecastResult" : { "Forecast" : [ { "ProbabilityOfPrecipiation" : { "Nighttime" : "00", "Daytime" : 10 } ...
Poiché il livello 4 è il primo livello che contiene più livelli secondari, non puoi rimuovere alcun livello inferiore a questo valore. Se imposti il livello della striscia a 5, 6, 7 e così via, continuerai ad avere risposta precedente.
Predefinito | 0 (nessuna rimozione dei livelli) |
---|---|
Presenza | Facoltativo |
Tipo | Numero intero |
<TreatAsArray>/<Path> elemento
<Options> <TreatAsArray> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> </Options>
Questa combinazione di elementi ti 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
e carichi di lavoro superflui. Il comportamento predefinito di Apigee è la conversione di più elementi secondari con lo stesso nome
un array JSON e singoli elementi figlio in una primitiva JSON. Opzione TreatAsArray
assicura che gli elementi secondari vengano sempre tradotti in un array JSON.
L'uso di TreatAsArray
può migliorare la struttura del codice successivo che gestisce
l'output, perché i dati dell'array vengono restituiti sempre nello stesso modo. Ad esempio:
la valutazione di un JSONPath di $.teachers.teacher.studentnames.name[0]
restituirà
first name in modo coerente, sia che il file XML originale ne contenga uno o più,
Elemento name
.
Facciamo un passo indietro e diamo un’occhiata al comportamento predefinito da XML a JSON, quindi scopriamo come
controlla l'output utilizzando <TreatAsArray>/<Path>
.
Quando un documento XML contiene un elemento con più occorrenze (che può verificarsi quando
Lo schema XML specifica maxOccurs='unbounded'
per l'elemento), il criterio da XML a JSON
inserisce automaticamente questi valori in un array. Ad esempio, il seguente blocco XML
<teacher> <name>teacherA</name> <studentnames> <name>student1</name> <name>student2</name> </studentnames> </teacher>
...viene convertita automaticamente nel seguente JSON senza criteri speciali configurazione:
{ "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ] } } } }
Nota che i due nomi degli studenti sono contenuti in un array.
Tuttavia, se nel documento XML compare solo uno studente, il criterio da XML a JSON automaticamente tratta il valore come una singola stringa, non come un array di stringhe, come mostrato di seguito esempio:
{ "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : "student1" } } } }
Negli esempi precedenti, dati simili sono stati convertiti in modo diverso, una volta in un array, un'altra in
una singola stringa. L'elemento <TreatAsArray>/<Path>
consente
puoi controllare l'output e assicurarti che i nomi degli studenti vengano sempre
anche se è presente un solo valore. La configurazione viene configurata identificando il percorso
elemento di cui desideri convertire i valori in un array, in questo modo:
<Options> <TreatAsArray> <Path>teachers/teacher/studentnames/name</Path> </TreatAsArray> </Options>
La configurazione riportata sopra genererebbe il codice JSON in questo modo:
{ "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : ["student1"] } } } }
Nota che studente1 è ora in un array. Indipendentemente dal fatto che ci siano
studenti, puoi recuperarli da un array JSON del tuo codice utilizzando il seguente JSONPath:
$.teachers.teacher.studentnames.name[0]
L'elemento <Path>
ha anche un attributo unwrap
, spiegato in
nella prossima sezione.
Predefinito | N/D |
---|---|
Presenza | Facoltativo |
Tipo | Stringa |
Attributi
<Options> <TreatAsArray> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> </Options>
Attributo | Descrizione | Presenza | Tipo |
---|---|---|---|
sciogliere |
Valore predefinito: false Rimuove l'elemento dall'output JSON. Utilizzalo per snellire o rendere più appiattito ("unwrap")
JSON, che abbrevia anche il JSONPath necessario per recuperare i valori. Ad esempio:
anziché Ecco un esempio in formato JSON: { "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ]}... In questo esempio, si potrebbe 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 una procedura dettagliata delle funzionalità, consulta in questo articolo della community Google Cloud.
<Format>
Il formato consente di controllare la conversione da XML a JSON. Inserisci il nome di un
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
sia <Format>
che <Options>
.
Di seguito sono riportate le definizioni del formato 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 valori:xml.com , yahoo , google e badgerFish |
Presenza | Facoltativo, ma obbligatorio se non viene utilizzato <Options> . |
Tipo | Stringa |
Schemi
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: criterio JSONtoXML