Règle XMLtoJSON

Vous consultez la documentation d'Apigee X.
Consultez la documentation d'Apigee Edge.

Objet

Cette règle convertit les messages du format XML (Extensible Markup Language) au format JSON (JavaScript Object Notation), vous offrant ainsi plusieurs options pour contrôler la conversion des messages.

En supposant que votre objectif soit de convertir une réponse au format XML en réponse au format JSON, la règle sera associée à un flux de réponses (par exemple, Response/ProxyEndpoint/PostFlow).

À propos

Dans un scénario de médiation type, une règle JSONtoXML sur le flux de requêtes entrantes est souvent associée à une règle XMLtoJSON sur le flux de réponses sortantes. En combinant des règles de cette manière, une API JSON peut être exposée pour les services de backend qui ne sont compatibles nativement qu'avec le format XML.

Pour les scénarios dans lesquels les API sont consommées par diverses applications clientes pouvant nécessiter JSON ou XML, le format de réponse peut être défini de manière dynamique en configurant l'exécution conditionnelle de règles JSONtoXML et XMLtoJSON. Pour voir une mise en œuvre de ce scénario, consultez la page Variables de flux et conditions.

---

Exemples

Pour obtenir des informations détaillées sur la conversion entre JSON et XML, consultez cet article.

Convertir une réponse

<XMLToJSON name="ConvertToJSON">
  <Options>
  </Options>
  <OutputVariable>response</OutputVariable>
  <Source>response</Source>
</XMLToJSON>

Cette configuration, qui est la configuration minimale requise pour la conversion de XML en JSON, prend un message de réponse au format XML en tant que source, puis crée un message au format JSON renseigné dans la OutputVariable response. Apigee utilise automatiquement le contenu de cette variable comme message pour la prochaine étape du traitement.

---

Documentation de référence des éléments

Vous trouverez ci-dessous les éléments et les attributs que vous pouvez configurer sur cette règle.

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

Attributs <XMLtoJSON>

<XMLtoJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1">

Le tableau suivant décrit les attributs communs à tous les éléments parents des règles :

Attribut	Description	Par défaut	Présence
name	Nom interne de la règle. La valeur de l'attribut name peut contenir des lettres, des chiffres, des espaces, des tirets, des traits de soulignement et des points. Cette valeur ne peut pas dépasser 255 caractères. Vous pouvez également utiliser l'élément <DisplayName> pour ajouter un libellé à la règle dans l'éditeur de proxy de l'interface utilisateur de gestion, en utilisant un nom différent, en langage naturel.	N/A	Obligatoire
continueOnError	Définissez sur false pour afficher une erreur en cas d'échec d'une règle. Il s'agit du comportement attendu pour la plupart des règles. Définissez sur true pour que l'exécution du flux se poursuive même après l'échec d'une règle. Voir également : Les règles d'erreur sont déclenchées UNIQUEMENT en état d'erreur (à propos de continueOnError) Gérer les pannes dans le flux actuel	faux	Facultatif
enabled	Définissez sur true pour appliquer la règle. Définissez sur false pour désactiver la règle. La stratégie ne sera pas appliquée, même si elle reste associée à un flux.	vrai	Facultatif
async	Cet attribut est obsolète.	faux	Obsolète

Élément <DisplayName>

Utilisez-le, en plus de l'attribut name, pour appliquer un libellé à la règle dans l'éditeur de proxys de l'interface de gestion en utilisant un nom différent, en langage naturel.

<DisplayName>Policy Display Name</DisplayName>

Par défaut	N/A Si vous omettez cet élément, la valeur de l'attribut name de la règle est utilisée.
Présence	Facultatif
Type	Chaîne

Élément <Source>

Variable, requête ou réponse, contenant le message XML que vous souhaitez convertir au format JSON.

L'en-tête HTTP Content-Type du message source doit être défini sur application/xml, sinon la règle n'est pas appliquée.

Si <Source> n'est pas défini, il est traité comme un message (qui renvoie une demande lorsque la règle est associée à un flux de requête ou une réponse lorsque la règle est associée à un flux de réponse).

Si la variable source ne peut pas être résolue ou est résolue en un type qui n'est pas un message, la règle génère une erreur.

<Source>response</Source>

Par défaut	requête ou réponse, déterminée par l'emplacement dans le flux de proxy de l'API où la règle est ajoutée.
Présence	Facultatif
Type	Message

Élément <OutputVariable>

Stocke la sortie de la conversion du format XML au format JSON. Il s'agit généralement de la même valeur que la source, c'est-à-dire que la réponse XML est généralement convertie en réponse JSON.

La charge utile du message XML est analysée et convertie en JSON, et l'en-tête HTTP Content-Type du message au format XML est défini sur application/json.

Si la variable OutputVariable n'est pas spécifiée, la source est traitée comme OutputVariable. Par exemple, si la source correspond à la requête (response), la valeur par défaut de OutputVariable est response.

<OutputVariable>response</OutputVariable>

Par défaut	requête ou réponse, déterminée par l'emplacement dans le flux de proxy de l'API où la règle est ajoutée.
Présence	Cet élément est obligatoire lorsque la variable définie dans l'élément <Source> est de type chaîne.
Type	Message

<Options>

Les options vous permettent de contrôler la conversion du format XML au format JSON. Utilisez le groupe <Options> pour ajouter des paramètres de conversion spécifiques, ou l'élément <Format>, qui vous permet de référencer un modèle d'options prédéfinies. Vous ne pouvez pas utiliser à la fois <Options> et <Format>.

<Options> est requis si <Format> n'est pas utilisé.

Élément <Options>/<RecognizeNumber>

Si la valeur est "true", les champs numériques de la charge utile XML conservent leur format d'origine.

<RecognizeNumber>true</RecognizeNumber>

Prenons l'exemple XML suivant :

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

Si la valeur est true, la conversion est effectuée comme suit :

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

Si la valeur est false, la conversion est effectuée comme suit :

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

Par défaut	false
Présence	Facultatif
Type	Booléen

Élément <Options>/<RecognizeBoolean>

Permet à la conversion de conserver les valeurs booléennes "true" et "false" plutôt que de les transformer en chaînes.

<RecognizeBoolean>true</RecognizeBoolean>

Pour l'exemple XML suivant :

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

Si la valeur est true, la conversion est effectuée comme suit :

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

Si la valeur est false, la conversion est effectuée comme suit :

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

Par défaut	false
Présence	Facultatif
Type	Booléen

Élément <Options>/<RecognizeNull>

Permet de convertir des valeurs vides en valeurs nulles.

<RecognizeNull>true</RecognizeNull>

Pour l'exemple XML suivant :

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

Si la valeur de RecognizeNull est true et qu'il n'y a pas d'option NullValue, l'élément XML est converti comme suit :

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

Si la valeur de RecognizeNull est false, l'élément XML est converti comme suit :

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

Default	false
Présence	Facultatif
Type	Booléen

Élément <Options>/<NullValue>

Indique la valeur à laquelle les valeurs nulles reconnues dans le message source doivent être converties. La valeur par défaut est null. Cette option n'est effective que si la valeur de RecognizeNull est "true".

<NullValue>not-present</NullValue>

Pour l'exemple XML suivant :

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

Si la valeur de RecognizeNull est true et que le champ NullValue n'est pas spécifié, l'élément XML est converti comme suit :

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

Si la valeur de RecognizeNull est true et que la valeur de NullValue est not-present, l'élément XML est converti comme suit :

{
  "a": {
    "b": "not-present",
    "c": "value"
  }
}

Default	null
Présence	Facultatif
Type	Chaîne

Éléments <Options>/<NamespaceBlockName>
<Options>/<DefaultNamespaceNodeName>
<Options>/<NamespaceSeparator>

Utilisez ces éléments ensemble.

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

Prenons l'exemple XML suivant :

<a xmlns="http://ns.com" xmlns:ns1="http://ns1.com">
  <ns1:b>value</ns1:b>
</a>

Si NamespaceSeparator n'est pas spécifié, la structure JSON suivante est générée :

{
    "a": {
        "b": "value"
    }
}

Si les éléments NamespaceBlockName, DefaultNamespaceNodeName et NamespaceSeparator sont spécifiés respectivement en tant que #namespaces, & et ***, la structure JSON suivante est générée :

{
    "a": {
        "#namespaces": {
            "&": "http://ns.com",
            "ns1": "http://ns1.com"
        },
        "ns1***b": "value"
    }
}

Par défaut	Voir exemples ci-dessus.
Présence	Facultatif Toutefois, si vous spécifiez <NamespaceBlockName>, vous devez également spécifier les deux autres éléments.
Type	Chaînes

Éléments <Options>/<TextAlwaysAsProperty>
<Options>/<TextNodeName>

Utilisez ces éléments ensemble.

Si la valeur est true, le contenu de l'élément XML est converti en propriété de chaîne.

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

Pour l'exemple XML suivant :

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

Si TextAlwaysAsProperty est défini sur true et si TextNodeName est spécifié en tant que TEXT, la structure JSON suivante est générée :

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

Si TextAlwaysAsProperty est défini sur false et si TextNodeName est spécifié en tant que TEXT, la structure JSON suivante est générée :

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

Par défaut	<TextAlwaysAsProperty> : false <TextNodeName> : N/A
Présence	Facultatif
Type	<TextAlwaysAsProperty> : booléen <TextNodeName> : chaîne

Éléments<Options>/<AttributeBlockName>
<Options>/<AttributePrefix>

Utilisez ces éléments ensemble.

Vous permet de regrouper des valeurs dans un bloc JSON et d'ajouter des préfixes aux noms d'attributs.

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

Prenons l'exemple XML suivant :

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

Si les attributs (AttributeBlockName et AttributePrefix) sont spécifiés tels qu'ils sont définis dans l'exemple de règle XMLtoJSON, la structure JSON suivante est générée :

{
  "a": {
    "FOO_BLOCK": {
      "BAR_attrib1": "value1",
      "BAR_attrib2": "value2"
    }
  }
}

Si seul AttributeBlockName est spécifié, la structure JSON suivante est générée :

{
    "a": {
        "FOO_BLOCK": {
            "attrib1": "value1",
            "attrib2": "value2"
        }
    }
}

Si seul AttributePrefix est spécifié, la structure JSON suivante est générée :

{
    "a": {
        "BAR_attrib1": "value1",
        "BAR_attrib2": "value2"
    }
}

Si aucun de ces éléments n'est spécifié, la structure JSON suivante est générée :

{
    "a": {
        "attrib1": "value1",
        "attrib2": "value2"
    }
}

Par défaut	Voir exemples ci-dessus.
Présence	Facultatif
Type	Chaîne

Éléments <Options>/<OutputPrefix>
<Options>/<OutputSuffix>

Utilisez ces éléments ensemble.

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

Prenons l'exemple XML suivant :

<a>value</a>

Si les attributs (OutputPrefix et OutputSuffix) sont spécifiés tels qu'ils sont définis dans l'exemple de règle XMLtoJSON, la structure JSON suivante est générée :

PREFIX_{
    "a": "value"
}_SUFFIX

Si seul OutputPrefix est spécifié, la structure JSON suivante est générée :

PREFIX_{
  "a" : "value"
}

Si seul OutputSuffix est spécifié, la structure JSON suivante est générée :

{
  "a" : "value"
}_SUFFIX

Si ni OutputPrefix, ni OutputSuffix n'est spécifié, la structure JSON suivante est générée :

{
    "a": "value"
}

Par défaut	Voir exemples ci-dessus.
Présence	Facultatif
Type	Chaîne

Élément <Options>/<StripLevels>

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

Parfois, les charges utiles XML, telles que SOAP, comportent de nombreux niveaux parents que vous ne souhaitez pas inclure dans le fichier JSON converti. Voici un exemple de réponse SOAP contenant de nombreux niveaux :

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

Il y a quatre niveaux avant d'accéder aux niveaux State, City, Description, et Temperature. Sans <StripLevels>, la réponse JSON convertie ressemblerait à ceci :

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

Si vous souhaitez supprimer ces quatre premiers niveaux dans la réponse JSON, vous devez définir <StripLevels>4</StripLevels>, ce qui vous donnera le message JSON suivant :

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

Vous pouvez supprimer des niveaux jusqu'au premier élément contenant plusieurs enfants. Qu'entendons-nous par là ? Examinons un exemple JSON plus complexe :

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

Dans cet exemple, le niveau 3 est GetCityForecastByZIPResponse, qui n'a qu'un seul enfant. Ainsi, si vous utilisez <StripLevels>3</StripLevels> (vous supprimez les trois premiers niveaux), le contenu JSON se présente comme suit :

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

Notez que GetCityForecastByZIPResult comporte plusieurs enfants. Comme il s'agit du premier élément contenant plusieurs enfants, vous pouvez supprimer ce dernier niveau à l'aide de <StripLevels>4</StripLevels>, ce qui vous donnera le message JSON suivant :

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

Comme le niveau 4 est le premier niveau contenant plusieurs enfants, vous ne pouvez pas supprimer des niveaux inférieurs à celui-ci. Si vous définissez le niveau de suppression sur 5, 6, 7 et ainsi de suite, vous obtiendrez la réponse ci-dessus.

Par défaut	0 (aucune suppression de niveau)
Présence	Facultatif
Type	Entier

Élément <Options>/<TreatAsArray>/<Path>

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

Cette combinaison d'éléments vous permet de vous assurer que les valeurs d'un document XML sont placées dans un tableau JSON. Cela est utile, par exemple, lorsque le nombre d'éléments enfants peut varier (d'un à plusieurs) et que vous souhaitez vous assurer que les valeurs se trouvent toujours dans un tableau. Cela permet de maintenir le code stable, car vous pouvez obtenir les données du tableau de la même manière à chaque fois. Par exemple, $.teachers.teacher.studentnames[0] obtient la première valeur de nom d'élève dans le tableau, quel que soit le nombre de valeurs que celui-ci contient.

Revenons en arrière et observons le comportement par défaut de la règle XMLtoJSON, puis découvrons comment contrôler la sortie à l'aide de <TreatAsArray>/<Path>.

Lorsqu'un document XML contient un élément comportant plusieurs valeurs enfants (généralement dans un schéma où la propriété maxOccurs='unbounded' de l'élément est appliquée), la règle XMLtoJSON les place automatiquement dans un tableau. Par exemple, le bloc XML suivant :

<teacher>
    <name>teacherA</name>
    <studentnames>
        <name>student1</name>
        <name>student2</name>
    </studentnames>
</teacher>

...est automatiquement converti dans le message JSON suivant sans configuration particulière de la règle :

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

Notez que les deux noms d'élèves sont placés dans un tableau.

Toutefois, si un seul élève apparaît dans le document XML, la règle XMLtoJSON traite automatiquement la valeur comme une chaîne unique et non comme un tableau de chaînes, comme illustré dans l'exemple suivant :

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

Dans les exemples précédents, des données similaires ont été converties différemment : une fois en tant que tableau, une autre en tant que chaîne unique. C'est là que l'élément <TreatAsArray>/<Path> vous permet de contrôler la sortie. Par exemple, vous pouvez vous assurer que les noms des élèves sont toujours placés dans un tableau, même s'il n'y a qu'une seule valeur. Pour ce faire, identifiez le chemin d'accès à l'élément dont vous souhaitez placer les valeurs dans un tableau, comme suit :

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

Remarque : Le chemin d'accès n'est pas JSONPath. Il s'agit simplement du chemin hiérarchique vers l'élément dont vous souhaitez placer les valeurs dans un tableau.

La configuration ci-dessus écrirait le message JSON comme suit :

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

Notez que "student1" se trouve désormais dans un tableau. Désormais, qu'il y ait un ou plusieurs élèves, vous pouvez les récupérer à partir d'un tableau JSON dans votre code en utilisant le JSONPath suivant : $.teachers.teacher.studentnames.name[0]

L'élément <Path> comporte également un attribut unwrap, qui est expliqué dans la section suivante.

Par défaut	N/A
Présence	Facultatif
Type	Chaîne

Attributs

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

Attribut	Description	Présence	Type
unwrap	Valeur par défaut : false Supprime l'élément de la sortie JSON. Utilisez cet attribut pour simplifier ou aplatir ("désencapsuler") le message JSON, ce qui raccourcit également le JSONPath nécessaire pour récupérer les valeurs. Par exemple, au lieu d'utiliser $.teachers.teacher.studentnames.name[*], vous pouvez aplatir le message JSON et utiliser $.teachers.studentnames[*]. Voici un exemple JSON : { "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ]}... Dans cet exemple, vous pouvez affirmer que l'élément teacher et l'élément name de "studentnames" sont inutiles. Vous pouvez les supprimer ou les désencapsuler. Pour configurer l'élément <Path> à cette fin, procédez comme suit : <TreatAsArray> <Path unwrap="true">teachers/teacher</Path> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> L'attribut unwrap est défini sur "true", et les chemins d'accès aux éléments à désencapsuler sont fournis. La sortie JSON doit maintenant se présenter comme suit : { "teachers" : [{ "name" : "teacherA", "studentnames" : ["student1","student2"] }]... Étant donné que l'élément <Path> se trouve dans l'élément <TreatAsArray>, les deux éléments du chemin sont traités comme des tableaux dans la sortie JSON.	Facultatif	Boolean

Pour obtenir plus d'exemples et un tutoriel présentant les fonctionnalités, consultez cet article de la communauté Apigee : https://community.apigee.com/content/kbentry/33374/new-edge-minifeature-the-treatasarray-option-in-th.html.

<Format>

Ce format vous permet de contrôler la conversion du format XML au format JSON. Saisissez le nom d'un modèle prédéfini contenant une combinaison spécifique d'éléments d'options décrits dans cet article. Les formats prédéfinis sont les suivants : xml.com, yahoo, google et badgerFish.

Utilisez l'élément <Format> ou le groupe <Options>. Vous ne pouvez pas utiliser à la fois <Format> et <Options>.

Vous trouverez ci-dessous les définitions de format de chaque modèle prédéfini.

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>

Syntaxe des éléments :

<Format>yahoo</Format>

Par défaut	Saisissez le nom d'un format disponible : xml.com, yahoo, google, badgerFish
Présence	Obligatoire si <Options> n'est pas utilisé.
Type	Chaîne

Schémas

Exemple : Consultez notre dépôt GitHub pour bénéficier des schémas les plus récents.

---

Informations de référence sur les erreurs

Cette section décrit les codes d'erreur et les messages d'erreur renvoyés et les variables d'erreur définies par Apigee lorsque cette règle déclenche une erreur. Ces informations sont importantes si vous développez des règles de défaillance afin de gérer les pannes. Pour en savoir plus, consultez les pages Ce que vous devez savoir à propos des erreurs liées aux règles et Gérer les pannes.

Erreurs d'exécution

Ces erreurs peuvent se produire lors de l'exécution de la règle.

Conseil : Vous avez besoin d'aide pour résoudre une erreur ? Cliquez sur dans la colonne "Corriger" pour obtenir des informations de dépannage détaillées.

Code d'erreur	État HTTP	Cause	Corriger
steps.xmltojson.ExecutionFailed	ExecutionFailed	Cette erreur se produit lorsque la charge utile d'entrée (XML) est vide ou que le code XML d'entrée est mal configuré ou non valide.
steps.xmltojson.InCompatibleTypes	ExecutionFailed	Cette erreur se produit si le type de la variable définie dans l'élément <Source> et l'élément <OutputVariable> ne sont pas identiques. La correspondance du type des variables contenues dans l'élément <Source> et l'élément <OutputVariable> est obligatoire.
steps.xmltojson.InvalidSourceType	ExecutionFailed	Cette erreur se produit si le type de la variable utilisée pour définir l'élément <Source> n'est pas valide. Les types de variable valides sont message et chaîne.
steps.xmltojson.OutputVariableIsNotAvailable	ExecutionFailed	Cette erreur se produit si la variable spécifiée dans l'élément <Source> de la règle XML vers JSON est de type chaîne et que l'élément <OutputVariable> n'est pas défini. L'élément <OutputVariable> est obligatoire lorsque la variable définie dans l'élément <Source> est de type chaîne.
steps.xmltojson.SourceUnavailable	ExecutionFailed	Cette erreur se produit si la variable message spécifiée dans l'élément <Source> de la règle XML vers JSON est l'une des suivantes : hors du champ d'application (non disponible dans le flux spécifique où la règle est exécutée) ou impossible à résoudre (non définie).

Erreurs de déploiement

Ces erreurs peuvent se produire lorsque vous déployez un proxy contenant cette règle.

Conseil : Vous avez besoin d'aide pour résoudre une erreur ? Cliquez sur dans la colonne "Corriger" pour obtenir des informations de dépannage détaillées.

Nom de l'erreur	Cause	Corriger
EitherOptionOrFormat	Si l'un des éléments <Options> ou <Format> n'est pas déclaré dans la règle XML vers JSON, le déploiement du proxy d'API échoue.
UnknownFormat	Si un format inconnu est défini sur l'élément <Format> de la règle XML vers JSON, le déploiement du proxy d'API échoue. Les formats prédéfinis sont les suivants : xml.com, yahoo, google et badgerFish.

Variables de panne

Ces variables sont définies lorsqu'une erreur d'exécution se produit. Pour en savoir plus, consultez la section Ce que vous devez savoir sur les erreurs liées aux règles.

Variables	Lieu	Exemple
fault.name="fault_name"	fault_name est le nom de l'erreur, tel qu'indiqué dans le tableau Erreurs d'exécution ci-dessus. Le nom d'erreur est la dernière partie du code d'erreur.	fault.name = "SourceUnavailable"
xmltojson.policy_name.failed	policy_name est le nom spécifié par l'utilisateur de la règle qui a provoqué l'erreur.	xmltojson.XMLtoJSON-1.failed = true

Exemple de réponse d'erreur

Remarque : Pour le traitement des erreurs, la meilleure pratique consiste à intercepter la partie errorcode de la réponse. Ne vous fiez pas au texte dans faultstring, car il pourrait changer.

{
  "fault": {
    "faultstring": "XMLToJSON[XMLtoJSON-1]: Source xyz is not available",
    "detail": {
      "errorcode": "steps.xml2json.SourceUnavailable"
    }
  }
}

Exemple de règle de défaillance

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

Articles associés

Conversion JSON en XML : Règle JSONtoXML