Criterio XMLtoJSON

Questa pagina si applica a Apigee e Apigee ibrido.

Visualizza la documentazione di Apigee Edge.

icona norme

Cosa

Questo criterio converte i messaggi dal formato Extensible Markup Language (XML) in JSON (JavaScript Object Notation), offrendo diverse opzioni per controllare le modalità di conversione dei messaggi.

Supponendo che lo scopo sia convertire una risposta in formato XML in una risposta in formato JSON, 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 tutti gli utenti devono conoscere i tipi di criteri e di ambiente. Per informazioni sui tipi di criteri e sulla disponibilità di ciascun 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 associato a un criterio da XML a JSON sul 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 possono 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.

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 richiesta per convertire il file XML in JSON, prende un messaggio di risposta in formato XML come origine, quindi crea un messaggio in formato JSON che viene compilato nell'oggetto 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>

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 name può contenere lettere, numeri, spazi, trattini, trattini bassi e punti. Questo valore non può superare i 255 caratteri.

Facoltativamente, utilizza l'elemento <DisplayName> per etichettare il criterio nell'editor proxy dell'interfaccia utente di gestione con un nome diverso in linguaggio naturale.

 N/A Obbligatorio
continueOnError

Impostalo su false per restituire un errore in caso di errore di un criterio. Questo è il comportamento previsto per la maggior parte dei criteri.

Imposta su true per fare in modo che l'esecuzione del flusso continui anche in caso di errore di un criterio. Vedi anche:

 false Facoltativo
enabled

Imposta il criterio su true per applicare il criterio.

Impostala su false per disattivare il criterio. Il criterio non verrà applicato anche se rimane associato a un flusso.

 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 name del criterio.
Presenza Facoltativo
Tipo Stringa

Elemento <Source>

La variabile che specifica il messaggio XML da convertire in JSON.

L'intestazione del tipo di contenuto 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 o response quando il criterio è collegato a un flusso di risposta.

Se la variabile di origine non può essere risolta o se viene risolta in un tipo diverso dai messaggi, il criterio genera un errore.

<Source>response</Source>
Predefinita Il valore dell'elemento Source
Presenza Facoltativo
Tipo Messaggio

Elemento <OutputVariable>

Specifica dove archiviare l'output della conversione in formato XML in formato 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 è response.

<OutputVariable>response</OutputVariable>
Predefinita 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 sia <Options> sia <Format>.

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

Elemento <RecognitionNumber>

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"
  }
}
Predefinita false
Presenza Facoltativo
Tipo Booleano

Elemento <RecognitionBoolean>

Consente alla conversione di mantenere i 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 lo converte in:

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

Se RecognizeBoolean è false, il criterio lo converte in:

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

Elemento <RecognitionNull>

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 l'opzione 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"
  }
}
Predefinita false
Presenza Facoltativo
Tipo Booleano

Elemento <NullValue>

Indica il valore in cui devono essere convertiti i valori null riconosciuti nel messaggio di origine. Per impostazione predefinita, il valore è null. Questa opzione è efficace 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 codice 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"
  }
}
Predefinita null
Presenza Facoltativo
Tipo String

Opzioni dello spazio dei nomi

Per impostazione predefinita, questo criterio omette gli spazi dei nomi XML nel file JSON generato. Per specificare che gli spazi dei nomi nel documento XML devono essere tradotti nel JSON generato, usa 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 viene 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 Nessuno. Se <NamespaceBlockName> non viene specificato, il criterio genera un file JSON di output che non fa riferimento a spazi 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

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, 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 di qualsiasi nodo 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 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"
    }
  }
}
Predefinita <TextAlwaysAsProperty>: false
<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 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 nessuna delle due opzioni viene specificata, viene generata la seguente struttura JSON:

{
    "a": {
        "attrib1": "value1",
        "attrib2": "value2"
    }
}
Predefinita nessuno.
Presenza Facoltativo
Tipo String

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 uno o entrambi i valori OutputPrefix e OutputSuffix.

Utilizzando questi elementi, è possibile generare un file JSON non valido. Ad esempio, se utilizzi 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"
}
Predefinita Guarda gli esempi qui sopra.
Presenza Facoltativo
Tipo String

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>

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 questa:

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

Se vuoi rimuovere questi primi 4 livelli nella risposta JSON, devi impostare <StripLevels>4</StripLevels>, che restituisce il seguente codice JSON:

{
  "State" : "CO",
  "City" : "Denver",
  "Description" : "Sunny",
  "Temperature" : "62"
}

Puoi eliminare 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
                        }  ...

In questo esempio, il livello 3 è GetCityForecastByZIPResponse, che ha un solo livello secondario. Pertanto, se utilizzi <StripLevels>3</StripLevels> (rimuovi i 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é è 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ù livelli 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 sopra.

Predefinita 0 (nessuna rimozione dei livelli)
Presenza Facoltativo
Tipo Integer

Elemento <TreatAsArray>/<Path>

<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 figlio varia a seconda dei diversi payload. Il comportamento predefinito di Apigee è la conversione di più elementi secondari con lo stesso nome in un array JSON e singoli elementi secondari in una primitiva JSON. L'opzione TreatAsArray ti consente di assicurarti 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, 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à in modo coerente il valore del nome, indipendentemente dal fatto che il file XML originale contenga uno o più elementi name.

Facciamo un passo indietro e diamo un'occhiata al comportamento predefinito da XML a JSON, quindi esploriamo come controllare l'output utilizzando <TreatAsArray>/<Path>.

Quando un documento XML contiene un elemento con più occorrenze (cosa 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 alcuna configurazione speciale di criteri:

{
  "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 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 in un array e un'altra 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. A questo scopo, devi identificare il percorso dell'elemento di cui vuoi 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. 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, spiegato nella prossima sezione.

Predefinita N/A
Presenza Facoltativo
Tipo String

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 semplificare o semplificare ("unwrapping") il file JSON, che abbrevia anche il JSONPath necessario per recuperare i valori. Ad esempio, invece di $.teachers.teacher.studentnames.name[*], puoi rendere basato il codice JSON e utilizzare $.teachers.studentnames[*].

Ecco un esempio in formato JSON:

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

In questo esempio, si potrebbe sostenere che l'elemento teacher e l'elemento studentnames name non sono necessari. Quindi puoi rimuoverli o aprirli. Ecco come configurare l'elemento <Path> per farlo:

<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 degli elementi da annullare il wrapping. L'output JSON sarà ora simile al seguente:

{
  "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 delle funzionalità, consulta questo articolo della community Google Cloud.

<Formato>

Il formato consente di controllare la conversione da XML a JSON. Inserisci il nome di un modello predefinito contenente una combinazione specifica di elementi Opzioni descritti 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 (nessuno)
Valori validi Uno dei seguenti:
xml.com, yahoo, google, badgerFish
Presenza Facoltativo, ma obbligatorio se non viene utilizzato <Options>.
Tipo String

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.
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.
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.
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.
steps.xmltojson.SourceUnavailable ExecutionFailed 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: criterio JSONtoXML