Questa pagina è stata tradotta dall'API Cloud Translation.

Norme di XMLtoJSON

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) a JSON (JavaScript Object Notation), offrendoti 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 verrà allegato a un flusso di risposta (ad esempio Response / ProxyEndpoint /PostFlow).

Questa policy è una policy standard e può essere implementata in qualsiasi tipo di ambiente. Per informazioni sui tipi di criteri e sulla disponibilità per 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 viene spesso abbinato a un criterio da XML a JSON nel flusso di risposte 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 gli 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 di conversione da JSON a XML e da XML a JSON da eseguire in modo condizionale. Per un'implementazione di questo scenario, consulta la sezione Variabili e condizioni del flusso.

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, ovvero la configurazione minima richiesta per convertire XML in JSON, prende un messaggio di risposta in formato XML come origine e poi crea un messaggio in formato JSON che viene inserito in response OutputVariable. Apigee utilizza automaticamente il contenuto 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 queste norme.

<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	Presence
`name`	Il nome interno del criterio. Il valore dell'attributo `name` può contenere lettere, numeri, spazi, trattini, trattini bassi e punti. Questo valore non può superare i 255 caratteri. Se vuoi, utilizza l'elemento `<DisplayName>` per etichettare il criterio nell'editor proxy dell'interfaccia utente di gestione con un nome diverso in linguaggio naturale.	N/D	Obbligatorio
`continueOnError`	Imposta su `false` per restituire un errore quando un criterio non va a buon fine. Questo è un comportamento previsto per la maggior parte dei criteri. Imposta su `true` per continuare l'esecuzione del flusso anche dopo un fallimento del criterio. Vedi anche: Le regole di errore vengono attivate SOLO in uno stato di errore (informazioni su continueOnError) Gestione degli errori all'interno del flusso corrente	falso	Facoltativo
`enabled`	Imposta su `true` per applicare il criterio. Imposta su `false` per disattivare il criterio. Il criterio non verrà applicato anche se rimane collegato a un flusso.	true	Facoltativo
`async`	Questo attributo è stato ritirato.	falso	Deprecato

Elemento <DisplayName>

Da utilizzare insieme 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

Predefinito	N/D Se ometti questo elemento, viene utilizzato il valore dell'attributo `name` del criterio.
Presence	Facoltativo
Tipo	Stringa

N/D

Se ometti questo elemento, viene utilizzato il valore dell'attributo name del criterio.

Presence Facoltativo

Tipo Stringa

Elemento <Source>

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

L'intestazione del tipo di contenuto HTTP del messaggio di origine deve essere impostata su application/xml, altrimenti la policy non viene applicata.

Se <Source> non è definito, viene considerato come message, che viene risolto in request quando la policy è collegata a un flusso di richieste oppure in response quando la policy è collegata a un flusso di risposte.

Se la variabile di origine non può essere risolta o viene risolta 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 dal formato XML a JSON. In genere, questo elemento non è incluso nella configurazione delle norme.

Apigee analizza il payload del messaggio XML specificato in Source, lo converte in JSON, memorizza 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, OutputVariable ha come valore predefinito 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 ti consente di aggiungere impostazioni di conversione specifiche, o l'elemento <Format>, che ti consente di fare riferimento a un modello di opzioni predefinite. Non puoi utilizzare sia <Options> che <Format>.

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

Elemento <RecognizeNumber>

Se è vero, 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, le norme lo convertono in:

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

Se RecognizeNumber è false, le norme lo convertono in:

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

Predefinito	falso
Presenza	Facoltativo
Tipo	Booleano

Elemento <RecognizeBoolean>

Consente alla conversione di mantenere i valori booleani true/false anziché trasformarli in stringhe.

<RecognizeBoolean>true</RecognizeBoolean>

Per il seguente esempio XML:

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

Se RecognizeBoolean è true, le norme lo convertono in:

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

Se RecognizeBoolean è false, le norme lo convertono in:

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

Predefinito	falso
Presenza	Facoltativo
Tipo	Booleano

Elemento <RecognizeNull>

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 non è presente l'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	falso
Presenza	Facoltativo
Tipo	Booleano

Elemento <NullValue>

Indica il valore a 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 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, questa policy omette gli spazi dei nomi XML nel JSON generato. Per specificare che gli spazi dei nomi nel documento XML devono essere convertiti 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 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 è specificato, il criterio genererà un output JSON che non fa riferimento a spazi dei nomi XML, indipendentemente dal fatto che il messaggio di origine facesse riferimento a spazi dei nomi.
Presenza	Facoltativo Tuttavia, se specifichi `<NamespaceBlockName>`, devi specificare anche gli altri due elementi.
Tipo	Stringhe

Opzioni di 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 secondario, il criterio traduce il contenuto di testo di quell'elemento XML in una proprietà nell'hash JSON.

Quando il criterio rileva un elemento XML che contiene più elementi secondari di contenuto misto, queste opzioni ti consentono di controllare l'output JSON di tutti i nodi di testo secondari.

Ad esempio, considera questa configurazione delle norme:

<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
Input XML	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>`: 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) sono 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 non viene specificato nessuno dei due, 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 OutputPrefix e/o OutputSuffix.

Utilizzando questi elementi, è possibile generare un file JSON non valido. Ad esempio, utilizzando questa configurazione delle norme:

<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	Vedi gli esempi riportati sopra.
Presenza	Facoltativo
Tipo	Stringa

Elemento <StripLevels>

<Options>
    <StripLevels>4</StripLevels>
</Options>

A volte i payload XML, come SOAP, hanno molti livelli principali 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 arrivare al livello Stato, Città, Descrizione e Temperatura. 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 rimuovere i primi quattro livelli nella risposta JSON, imposta <StripLevels>4</StripLevels>, che ti darà 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 figlio. Quindi, se utilizzi <StripLevels>3</StripLevels> (rimuovi i primi tre livelli), il JSON avrà il seguente aspetto:

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

Tieni presente che GetCityForecastByZIPResult ha più figli. Poiché è il primo elemento contenente più elementi secondari, puoi rimuovere questo ultimo livello utilizzando <StripLevels>4</StripLevels>, che ti darà il seguente JSON:

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

Poiché il livello 4 è il primo livello contenente più figli, non puoi rimuovere livelli inferiori. Se imposti il livello della striscia su 5, 6, 7 e così via, continuerai a ricevere la risposta riportata 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 ti consente di assicurarti che i valori di un documento XML vengano sempre convertiti in un array JSON. Può essere utile quando il numero di elementi secondari varia per diversi payload. Il comportamento predefinito di Apigee è convertire 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à il valore del nome in modo coerente, indipendentemente dal fatto che l'XML originale contenga uno o più elementi name.

Facciamo un passo indietro ed esaminiamo il comportamento predefinito di XML in JSON, quindi scopriamo come controllare l'output utilizzando <TreatAsArray>/<Path>.

Quando un documento XML contiene un elemento con più occorrenze (il che può accadere quando lo schema XML specifica maxOccurs='unbounded' per l'elemento), la policy XML to 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 una configurazione speciale dei 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 è presente un solo studente, il criterio XML in JSON considera automaticamente il valore come una singola stringa, non come un array di stringhe, come mostrato nel seguente esempio:

{
  "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 volta 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 configurare questa opzione, identifica il percorso dell'elemento di cui vuoi convertire i valori in un array, come segue:

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

La configurazione precedente genererebbe il seguente JSON:

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

Nota che student1 ora si trova 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.

Predefinito	N/D
Presenza	Facoltativo
Tipo	Stringa

Attributi

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

Attributo Descrizione Presenza Tipo

unwrap

Attributo	Descrizione	Presenza	Tipo
unwrap	Valore predefinito: false Rimuove l'elemento dall'output JSON. Utilizza questa opzione per semplificare o appiattire ("spacchettare") il JSON, il che abbrevia anche il JSONPath necessario per recuperare i valori. Ad esempio, anziché `$.teachers.teacher.studentnames.name[]`, potresti appiattire il JSON e utilizzare `$.teachers.studentnames[]`. Ecco un esempio in formato JSON: { "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ]}... In questo esempio, potresti sostenere che l'elemento `teacher` e l'elemento studentnames `name` non sono necessari. Quindi puoi rimuoverli o scartarli. 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 spacchettare. L'output JSON ora avrà il seguente aspetto: { "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

Valore predefinito: false

Rimuove l'elemento dall'output JSON. Utilizza questa opzione per semplificare o appiattire ("spacchettare") il JSON, il che abbrevia anche il JSONPath necessario per recuperare i valori. Ad esempio, anziché $.teachers.teacher.studentnames.name[*], potresti appiattire il JSON e utilizzare $.teachers.studentnames[*].

Ecco un esempio in formato JSON:

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

In questo esempio, potresti sostenere che l'elemento teacher e l'elemento studentnames name non sono necessari. Quindi puoi rimuoverli o scartarli. 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 spacchettare. L'output JSON ora avrà il seguente aspetto:

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

<Format>

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 sia <Format> che <Options>.

Di seguito sono riportate le definizioni del formato di ogni 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>

Predefinito	(nessuno)
Valori validi	Uno dei seguenti valori: `xml.com`, `yahoo`, `google`, `badgerFish`
Presenza	Facoltativo, ma obbligatorio se non viene utilizzato `<Options>`.
Tipo	Stringa

Schemi

Messaggi di errore

Questa sezione descrive i codici di errore e i messaggi di errore restituiti e le variabili di errore impostate da Apigee quando questo criterio attiva un errore. Queste informazioni sono importanti se stai sviluppando regole di errore per gestire gli errori. Per scoprire di più, consulta Informazioni importanti sugli errori relativi alle norme e Gestione degli errori.

Errori di runtime

Questi errori possono verificarsi durante l'esecuzione del criterio.

Codice guasto	Stato HTTP	Causa
`steps.xmltojson.ExecutionFailed`	`ExecutionFailed`	Questo errore si verifica quando il payload (XML) di input è vuoto o il codice XML di input non è valido o non ha un formato corretto.
`steps.xmltojson.InCompatibleTypes`	`ExecutionFailed`	Questo errore si verifica se il tipo di variabile definito nell'elemento `<Source>` e nell'elemento `<OutputVariable>` non è lo stesso. È obbligatorio che il tipo di variabili contenuto 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 variabili validi sono messaggio e stringa.
`steps.xmltojson.OutputVariableIsNotAvailable`	`ExecutionFailed`	Questo errore si verifica se la variabile specificata nell'elemento `<Source>` del criterio XML to 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 XML to JSON è: Al di fuori dell'ambito (non disponibile nel flusso specifico in cui viene eseguito il criterio) o Non può essere risolto (non è definito)

Errori di deployment

Questi errori possono verificarsi quando esegui il deployment di un proxy contenente questo criterio.

Nome dell'errore	Causa	Correggi
`EitherOptionOrFormat`	Se uno degli elementi `<Options>` o `<Format>` non è dichiarato nel criterio XML to JSON, il deployment del proxy API non va a buon fine.
`UnknownFormat`	Se l'elemento `<Format>` all'interno del criterio XML to JSON ha un formato sconosciuto definito, il deployment del proxy API non va a buon fine. 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 ulteriori informazioni, consulta Informazioni importanti sugli errori relativi alle norme.

Variabili	Dove	Esempio
`fault.name="fault_name"`	`fault_name` è il nome dell'errore, come indicato nella tabella Errori di runtime sopra. Il nome dell'errore è l'ultima parte del codice dell'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

Nota: per la gestione degli errori, la best practice è intercettare la parte errorcode della risposta all'errore. Non fare affidamento sul testo in faultstring, perché potrebbe cambiare.

{
  "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: policy JSONtoXML

Norme di XMLtoJSON Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Cosa

Informazioni

Esempi

Conversione di una risposta

Riferimento elemento

Attributi <XMLtoJSON>

Elemento <DisplayName>

Elemento <Source>

Elemento <OutputVariable>

<Opzioni>

Elemento <RecognizeNumber>

Elemento <RecognizeBoolean>

Elemento <RecognizeNull>

Elemento <NullValue>

Opzioni dello spazio dei nomi

Opzioni di testo

Opzioni degli attributi

Elementi <OutputPrefix> e <OutputSuffix>

Elemento <StripLevels>

Elemento <TreatAsArray>/<Path>

Attributi

<Format>

xml.com

yahoo

google

badgerFish

Schemi

Messaggi di errore

Errori di runtime

Errori di deployment

Variabili di errore

Esempio di risposta di errore

Esempio di regola di errore

Argomenti correlati

Norme di XMLtoJSON