Criterio XMLtoJSON

Stai visualizzando la documentazione di Apigee Edge.
Vai alla documentazione di Apigee X.
informazioni

Cosa

Questo criterio converte i messaggi dal formato XML (Extensible Markup Language) in JSON (JavaScript Object Notation), offrendoti diverse opzioni per controllare il modo in cui i messaggi vengono convertiti.

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 Risposta / ProxyEndpoint/PostFlow.

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, è possibile esporre un'API JSON 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 i criteri da JSON a XML e da XML a JSON da eseguire in modo condizionale. Consulta Variabili e condizioni di flusso per un'implementazione di questo scenario.


Samples

Per una discussione dettagliata sulla conversione tra JSON e XML, consulta http://community.apigee.com/articles/1839/converting-between-xml-and-json-what-you-need-to-k.html.

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 XML in JSON, utilizza come origine un messaggio di risposta in formato XML e crea un messaggio in formato JSON che viene compilato nella variabile di output response. Edge 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 su 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"> 

The following table describes attributes that are common to all policy parent elements:

Attribute Description Default Presence
name

The internal name of the policy. The value of the name attribute can contain letters, numbers, spaces, hyphens, underscores, and periods. This value cannot exceed 255 characters.

Optionally, use the <DisplayName> element to label the policy in the management UI proxy editor with a different, natural-language name.

N/A Required
continueOnError

Set to false to return an error when a policy fails. This is expected behavior for most policies.

Set to true to have flow execution continue even after a policy fails.

false Optional
enabled

Set to true to enforce the policy.

Set to false to turn off the policy. The policy will not be enforced even if it remains attached to a flow.

true Optional
async

This attribute is deprecated.

false Deprecated

<DisplayName> element

Use in addition to the name attribute to label the policy in the management UI proxy editor with a different, natural-language name.

<DisplayName>Policy Display Name</DisplayName>
Default

N/A

If you omit this element, the value of the policy's name attribute is used.

Presence Optional
Type String

Elemento <Source>

La variabile, la richiesta o la risposta, contenente 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 considerato come messaggio (che risolve la richiesta quando il criterio viene associato a un flusso di richiesta o una risposta 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 diverso da messaggio, il criterio genera un errore.

<Source>response</Source>
Predefinita richiesta o risposta, determinata da dove il criterio viene aggiunto al flusso proxy API
Presenza Facoltativo
Digitare messaggio

Elemento <OutputVariable>

Archivia l'output della conversione in formato XML in formato JSON. Di solito si tratta dello stesso valore dell'origine, ovvero di solito la risposta XML viene convertita in una risposta JSON.

Il payload del messaggio XML viene analizzato e convertito in JSON e l'intestazione Content-type HTTP del messaggio in formato XML è impostata su application/json.

Se OutputVariable non è specificato, source viene considerato come OutputVariable. Ad esempio, se source è response, OutputVariable il valore predefinito sarà response.

<OutputVariable>response</OutputVariable>
Predefinita richiesta o risposta, determinata da dove il criterio viene aggiunto al flusso proxy API
Presenza Questo elemento è obbligatorio quando la variabile definita nell'elemento <Source> è di tipo stringa.
Digitare 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 sia <Options> sia <Format>.

<Options> è obbligatorio se <Format> non viene utilizzato.

Elemento <Options>/<RecognizeNumber>

Se il valore è true, i campi numerici nel payload XML manterranno il formato originale.

<RecognizeNumber>true</RecognizeNumber>

Considera il seguente esempio di codice XML:

<a>
  <b>100</b>
  <c>value</c>
</a>

Se true, converte in:

{
    "a": {
        "b": 100,
        "c": "value"
    }
}

Se false, converte in:

{
    "a": {
        "b": "100",
        "c": "value"
    }
}
Predefinita false
Presenza Facoltativo
Digitare Booleano

Elemento <Options>/<RecognizeBoolean>

Consente alla conversione di mantenere valori vero/falso booleani anziché trasformarli in stringhe.

<RecognizeBoolean>true</RecognizeBoolean>

Per il seguente esempio di codice XML:

<a>
  <b>true</b>
  <c>value</c>
</a>

Se true, converte in:

{
    "a": {
        "b": true,
        "c": "value"
    }
}

Se false, converte in:

{
    "a": {
        "b": "true",
        "c": "value"
    }
}
Predefinita false
Presenza Facoltativo
Digitare Booleano

Elemento <Options>/<RecognizeNull>

Consente di convertire i valori vuoti in valori nulli.

<RecognizeNull>true</RecognizeNull>

Per il seguente XML:

<a>
  <b></b>
  <c>value</c>
</a>

Se true, converte in:

{
  "a": {
    "b": null,
    "c": "value"
  }
}

Se false, converte in:

{
  "a": {
    "b": {},
    "c": "value"
  }
}
Predefinita false
Presenza Facoltativo
Digitare Booleano

Elemento <Options>/<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>

Predefinita null
Presenza Facoltativo
Digitare Stringa

<Options>/<NamespaceBlockName>
<Options>/<DefaultNamespaceNodeName>
<Options>/<NamespaceSeparator> elementi

Utilizza questi elementi insieme.

<NamespaceBlockName>#namespaces</NamespaceBlockName>
<DefaultNamespaceNodeName>&</DefaultNamespaceNodeName>
<NamespaceSeparator>***</NamespaceSeparator>

Considera il seguente esempio di codice 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 sono specificati rispettivamente come #namespaces, & e ***, viene generata la seguente struttura JSON:

{
    "a": {
        "#namespaces": {
            "&": "http://ns.com",
            "ns1": "http://ns1.com"
        },
        "ns1***b": "value"
    }
}
Predefinita Vedi gli esempi sopra.
Presenza Facoltativo
Tuttavia, se specifichi <NamespaceBlockName>, devi specificare anche gli altri due elementi.
Digitare Stringa

<Options>/<TextBeforeAsProperty>
Elementi <Options>/<TextNodeName>

Utilizza questi elementi insieme.

Se impostato su true, il contenuto dell'elemento XML viene convertito in una proprietà stringa.

<TextAlwaysAsProperty>true</TextAlwaysAsProperty>
<TextNodeName>TEXT</TextNodeName>

Per il seguente XML:

<a>
  <b>value1</b>
  <c>value2<d>value3</d>value4</c>
</a>

Se TextAlwaysAsProperty è impostato su true e TextNodeName viene specificato come TEXT, viene generata la seguente struttura JSON:

{
  "a": {
    "b": {
      "TEXT": "value1"
    },
    "c": {
      "TEXT": [
        "value2",
        "value4"
        ],
        "d": {
          "TEXT": "value3"
        }
      }
    }
}

Se TextAlwaysAsProperty è impostato su false e TextNodeName specificato come TEXT, viene generata la seguente struttura JSON:

{
  "a": {
    "b": "value1",
    "c": {
      "TEXT": [
        "value2",
        "value4"
      ],
      {
        "d": "value3",
      }
    }
}
Predefinita <TextAlwaysAsProperty>: falso
<TextNodeName>: N/D
Presenza Facoltativo
Digitare <TextAlwaysAsProperty>: valore booleano
<TextNodeName>: stringa

<Options>/<AttributeBlockName>
<Options>/<AttributePrefix> elementi

Utilizza questi elementi insieme.

Consente di raggruppare i valori in un blocco JSON e di aggiungere prefissi ai nomi degli attributi.

<AttributeBlockName>FOO_BLOCK</AttributeBlockName>
<AttributePrefix>BAR_</AttributePrefix>

Considera il seguente esempio di codice XML:

<a attrib1="value1" attrib2="value2"/>

Se entrambi gli attributi (AttributeBlockName e AttributePrefix) vengono specificati come definiti 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 è specificato, viene generata la seguente struttura JSON:

{
    "a": {
        "attrib1": "value1",
        "attrib2": "value2"
    }
}
Predefinita Vedi gli esempi sopra.
Presenza Facoltativo
Digitare Stringa

Elementi <Options>/<OutputPrefisso>
<Options>/<OutputSuffix>

Utilizza questi elementi insieme.

<OutputPrefix>PREFIX_</OutputPrefix>
<OutputSuffix>_SUFFIX</OutputSuffix>

Considera il seguente esempio di codice XML:

<a>value</a>

Se entrambi gli attributi (OutputPrefix e OutputSuffix) vengono specificati come definito nell'esempio da XML a JSON, viene generata la seguente struttura JSON:

PREFIX_{
    "a": "value"
}_SUFFIX

Se viene specificato solo OutputPrefix, viene generata la seguente struttura JSON:

PREFIX_{
  "a" : "value"
}

Se viene specificato solo OutputSuffix, viene generata la seguente struttura JSON:

{
  "a" : "value"
}_SUFFIX

Se non vengono specificati né OutputPrefixOutputSuffix, viene generata la seguente struttura JSON:

{
    "a": "value"
}
Predefinita Guarda gli esempi in alto.
Presenza Facoltativo
Digitare Stringa

Elemento <Options>/<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>

Esistono 4 livelli prima di raggiungere il livello Stato, Città, Descrizione e Temperatura. Senza <StripLevels>, la risposta JSON convertita avrebbe il seguente aspetto:

{
   "Envelope" : {
      "Body" : {
         "GetCityWeatherByZIPResponse" : {
            "GetCityWeatherByZIPResult" : {
               "State" : "CO",
               "City" : "Denver",
               "Description" : "Sunny",
               "Temperature" : "62"
            }
         }
      }
   }
}

Se vuoi eliminare i primi quattro livelli nella risposta JSON, devi impostare <StripLevels>4</StripLevels>, che restituirà 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? 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 ha un solo elemento figlio. Quindi, se dovessi utilizzare <StripLevels>3</StripLevels> (rimuovi i primi tre livelli), il JSON avrebbe questo aspetto:

{
   "GetCityForecastByZIPResult" : {
      "ResponseText" : "City Found",
      "ForecastResult" : {
         "Forecast" : [
            {
               "ProbabilityOfPrecipiation" : {
                  "Nighttime" : "00",
                  "Daytime" : 10
               }  ...

Nota che GetCityForecastByZIPResult ha più elementi secondari. Poiché è il primo elemento contenente più elementi secondari, puoi eliminare 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 livello contenente più bambini, non puoi rimuovere livelli inferiori a questo. Se imposti il livello della Strip su 5, 6, 7 e così via, continuerai a ricevere la risposta riportata sopra.

Predefinita 0 (nessuna rimozione dei livelli)
Presenza Facoltativo
Digitare Numero intero

Elemento <Options>/<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 inseriti in un array JSON. Questo è utile, ad esempio, quando il numero di elementi secondari può variare (da uno a più) e vuoi assicurarti che i valori siano sempre in un array. In questo modo puoi mantenere stabile il codice, perché puoi recuperare i dati dall'array nello stesso modo ogni volta. Ad esempio: $.teachers.teacher.studentnames[0] ottiene il primo valore del nome di studente nell'array, indipendentemente dal numero di valori nell'array.

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ù valori secondari (di solito basati su uno schema in cui maxOccurs='unbounded' dell'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 convertito automaticamente nel seguente JSON senza alcuna configurazione di criteri speciale:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : [
                 "student1",
                 "student2"
              ]}
           }
      }
}

Nota che i due nomi degli studenti vengono inseriti in un array.

Tuttavia, se nel documento XML compare solo uno studente, il criterio da XML a JSON considera 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 come array e un'altra come singola stringa. È qui che l'elemento <TreatAsArray>/<Path> ti consente di controllare l'output. Ad esempio, puoi assicurarti che i nomi degli studenti vengano sempre inseriti in un array anche se è presente un solo valore. Per configurarlo, identifica il percorso dell'elemento di cui vuoi inserire i valori in un array, in questo modo:

<Options>
    <TreatAsArray>
        <Path>teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>

La configurazione precedente scriverebbe il codice JSON nel seguente modo:

{
  "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 tuo codice utilizzando il seguente JSONPath: $.teachers.teacher.studentnames.name[0]

L'elemento <Path> ha anche un attributo unwrap, illustrato nella sezione successiva.

Predefinita NA
Presenza Facoltativo
Digitare 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. Utilizzalo per semplificare o rendere più uniforme ("unwrapping") il JSON, abbreviando anche il valore JSONPath necessario per recuperare i valori. Ad esempio, anziché $.teachers.teacher.studentnames.name[*], puoi suddividere il JSON e utilizzare $.teachers.studentnames[*].

Ecco un esempio JSON:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : [
                 "student1",
                 "student2"
              ]}...

In questo esempio, si potrebbe sostenere che gli elementi teacher e studentnames name non sono necessari. così puoi rimuoverli o annullarne la confezione. Ecco come configurare l'elemento <Path> in questo modo:

<TreatAsArray>
    <Path unwrap="true">teachers/teacher</Path>
    <Path unwrap="true">teachers/teacher/studentnames/name</Path>
</TreatAsArray>

L'attributo unwrap è impostato su true e vengono forniti i percorsi per gli elementi di cui annullare il wrapping. L'output JSON ora sarà simile a questo:

{
  "teachers" : [{
      "name" : "teacherA",
      "studentnames" : ["student1","student2"]
      }]...

Tieni presente che, poiché l'elemento <Path> si trova nell'elemento <TreatAsArray>, entrambi gli elementi nel percorso verranno trattati come array nell'output JSON.

Facoltativo Booleano

Per altri esempi e una procedura dettagliata per le funzionalità, consulta questo articolo della community Apigee: https://community.apigee.com/content/kbentry/33374/new-edge-minifeature-the-treatasarray-option-in-th.html.

<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 descritta in questo argomento. I formati predefiniti includono: xml.com, yahoo, google e badgerFish.

Utilizza l'elemento <Format> o il gruppo <Options>. Non puoi utilizzare sia <Format> sia <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>

google

<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>
Predefinita Inserisci il nome di un formato disponibile:
xml.com, yahoo, google, badgerFish
Presenza Obbligatorio se <Options> non viene utilizzato.
Digitare Stringa

Schemi


Messaggi di errore

Questa sezione descrive i codici e i messaggi di errore restituiti e le variabili di errore impostate da Edge 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 500 Questo errore si verifica quando il payload di input (XML) è vuoto o l'XML di input non è valido o è in un formato non corretto.
steps.xmltojson.InCompatibleType 500 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.
steps.xmltojson.InvalidSourceType 500 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.
steps.xmltojson.OutputVariableIsNotAvailable 500 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.
steps.xmltojson.SourceUnavailable 500 Questo errore si verifica se la variabile message specificata nell'elemento <Source> del criterio da XML a JSON è:
  • fuori ambito (non disponibile nel flusso specifico in cui viene eseguito il criterio) oppure
  • non può essere risolto (non è definito)

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.
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.

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: criteri da JSON a XML