Política XMLtoJSON

Esta página se aplica a Apigee y Apigee Hybrid.

Consulta la documentación de Apigee Edge.

Qué

Esta política convierte mensajes del formato de lenguaje de marcación extensible (XML) a la notación de objetos de JavaScript (JSON), lo que te brinda varias opciones para controlar cómo se convierten los mensajes.

Si se desea convertir una respuesta con formato XML en una respuesta con formato JSON, la política se debe adjuntar a un flujo de respuesta (por ejemplo, Response/ProxyEndpoint/PostFlow).

Esta es una política estándar y se puede implementar en cualquier tipo de entorno. No todos los usuarios necesitan conocer los tipos de políticas y el entorno. Para obtener información sobre los tipos de políticas y la disponibilidad con cada tipo de entorno, consulta Tipos de políticas.

Información

En una situación de mediación típica, una política de JSON a XML en el flujo de solicitud entrante se suele vincular con una política de XML a JSON en el flujo de respuesta saliente. Cuando se combinan políticas de esta manera, se puede exponer una API de JSON para servicios de backend que solo admiten XML de forma nativa.

En situaciones en que las diversas apps cliente que consumen las API pueden requerir JSON o XML, el formato de respuesta se puede configurar de forma dinámica mediante la configuración de políticas de JSON a XML y de XML a JSON para ejecutarlas de manera condicional. Consulta Variables y condiciones de flujo para ver una implementación de esta situación.

Ejemplos

Para ver un análisis detallado sobre la conversión entre JSON y XML, consulta este artículo.

Convierte una respuesta

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

Esta configuración, que es la configuración mínima necesaria para convertir XML en JSON, toma un mensaje de respuesta con formato XML como la fuente y, luego, crea un mensaje con formato JSON que se propaga en la OutputVariable de response. Apigee usa de forma automática el contenido de esta variable como el mensaje para el próximo paso de procesamiento.

Referencia del elemento

A continuación, se describen los elementos y los atributos que puedes configurar en esta política.

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

Atributos <XMLtoJSON>

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

En la siguiente tabla, se describen los atributos que son comunes a todos los elementos principales de las políticas:

Atributo	Descripción	Predeterminado	Presencia
`name`	El nombre interno de la política. El valor del atributo `name` puede contener letras, números, espacios, guiones, guiones bajos y puntos. Este valor no puede superar los 255 caracteres. De forma opcional, usa el elemento `<DisplayName>` para etiquetar la política en el editor de proxy de la IU de administración con un nombre de lenguaje natural diferente.	N/A	Obligatorio
`continueOnError`	Configúralo como `false` para mostrar un error cuando una política falla. Este es el comportamiento previsto para la mayoría de las políticas. Configúralo como `true` para continuar con la ejecución del flujo incluso después de que una política falle. También consulta lo siguiente: Las reglas de fallas se activan SOLAMENTE en un estado de error (sobre el continueOnError) Controla fallas dentro del flujo actual	falso	Opcional
`enabled`	Configúralo como `true` para aplicar la política. Configúralo como `false` para desactivar la política. La política no se aplicará incluso si permanece adjunta a un flujo.	true	Opcional
`async`	Este atributo dejó de estar disponible.	falso	Obsoleta

Elemento <DisplayName>

Se usan además del atributo name para etiquetar la política en el editor de proxy de la IU de administración con un nombre de lenguaje natural diferente.

<DisplayName>Policy Display Name</DisplayName>

Predeterminada

Predeterminada	N/A Si omites este elemento, se usa el valor del atributo `name` de la política.
Presencia	Opcional
Tipo	String

N/A

Si omites este elemento, se usa el valor del atributo name de la política.

Presencia Opcional

Tipo String

Elemento <Source>

Es la variable que especifica el mensaje XML que deseas convertir en JSON.

El encabezado de tipo de contenido HTTP del mensaje fuente debe establecerse como application/xml; de lo contrario, la política no se aplica.

Si <Source> no está definido, se trata como un message, que se resuelve como request cuando la política se adjunta a un flujo de solicitud, o response cuando la política se adjunta a un flujo de respuesta.

Si la variable de origen no se puede resolver o se resuelve en un tipo que no es de mensaje, la política muestra un error.

<Source>response</Source>

Predeterminada	El valor del elemento `Source`
Presencia	Opcional
Tipo	Mensaje

Elemento <OutputVariable>

Especifica dónde almacenar el resultado de la conversión de formato XML a JSON. Por lo general, este elemento no se incluye en la configuración de la política.

Apigee analiza la carga útil del mensaje XML especificado en Source, lo convierte en JSON, almacena el resultado en la carga útil deOutputVariable y establece el encabezado de tipo de contenido HTTP del mensaje OutputVariable como application/json.

Si no se especifica OutputVariable, se usa el valor de Source de forma predeterminada. Por ejemplo, si el source es response, entonces OutputVariable se configura de forma predeterminada como response.

<OutputVariable>response</OutputVariable>

Predeterminada	el mensaje especificado en `Source`
Presencia	Opcional
Tipo	Mensaje

<Options>

Las opciones te permiten controlar la conversión de XML a JSON. Usa el grupo <Options>, que te permite agregar una configuración de conversión específica, o el elemento <Format>, que te permite hacer referencia a una plantilla de opciones predefinidas. No puedes usar <Options> y <Format> al mismo tiempo.

El elemento <Options> es obligatorio si no se usa <Format>.

Elemento <RecognizeNumber>

Si es verdadero, los campos de número en la carga útil de XML conservan su formato original.

<RecognizeNumber>true</RecognizeNumber>

Considera el siguiente ejemplo de XML:

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

Si RecognizeNumber es true, la política convierte esto en lo siguiente:

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

Si RecognizeNumber es false, la política convierte esto en lo siguiente:

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

Predeterminada	falso
Presencia	Opcional
Tipo	Booleano

Elemento <RecognizeBoolean>

Permite que la conversión mantenga valores booleanos verdaderos o falsos en lugar de convertir los valores en strings.

<RecognizeBoolean>true</RecognizeBoolean>

Observa este ejemplo de XML:

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

Si RecognizeBoolean es true, la política convierte esto en lo siguiente:

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

Si RecognizeBoolean es false, la política convierte esto en lo siguiente:

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

Predeterminada	falso
Presencia	Opcional
Tipo	Booleano

Elemento <RecognizeNull>

Te permite convertir valores vacíos en valores nulos.

<RecognizeNull>true</RecognizeNull>

Observa el siguiente XML:

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

Si RecognizeNull es true y si no hay opción NullValue, este XML se convierte en lo siguiente:

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

Si RecognizeNull es false, este XML se convierte en lo siguiente:

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

Predeterminada	falso
Presencia	Opcional
Tipo	Booleano

Elemento <NullValue>

Indica el valor al que se deben convertir los valores nulos reconocidos en el mensaje de origen. El valor predeterminado es null. Esta opción solo es efectiva si RecognizeNull es verdadero.

<NullValue>not-present</NullValue>

Observa el siguiente XML:

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

Si RecognizeNull es true y no se especifica NullValue, este XML se convierte en lo siguiente:

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

Si RecognizeNull es true y NullValue es not-present, este XML se convierte en lo siguiente:

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

Predeterminada	`null`
Presencia	Opcional
Tipo	Cadena

Opciones de espacio de nombres

De forma predeterminada, esta política omite los espacios de nombres XML en el JSON generado. Para especificar que los espacios de nombres en el documento XML se deben traducir al archivo JSON generado, usa estos elementos juntos.

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

Considera el siguiente ejemplo de XML:

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

Si no se especifica NamespaceSeparator, se genera la siguiente estructura JSON:

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

Si los elementos NamespaceBlockName, DefaultNamespaceNodeName y NamespaceSeparator se especifican como #namespaces, & y ***, respectivamente, entonces se genera la siguiente estructura JSON:

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

Predeterminada	Ninguno Si no se especifica `<NamespaceBlockName>`, la política generará un archivo JSON de salida que no hará referencia a ningún espacio de nombres XML, independientemente de si el mensaje de origen hace referencia a espacios de nombres.
Presencia	Opcional Sin embargo, si especificas `<NamespaceBlockName>`, también debes especificar los otros dos elementos.
Tipo	Strings

Opciones de texto

Usa estos elementos en conjunto.

      <TextAlwaysAsProperty>true|false</TextAlwaysAsProperty>
      <TextNodeName>TEXT</TextNodeName>

Cuando la política encuentra un elemento XML que contiene solo un nodo de texto como secundario, la política traduce el contenido de texto de ese elemento XML a una propiedad en el hash JSON.

Cuando la política encuentra un elemento XML que contiene varios elementos secundarios de contenido mixto, estas opciones te permiten controlar el JSON de salida de cualquier nodo de texto secundario.

Por ejemplo, considera esta configuración de política:

<XMLToJSON name='XMLToJSON-1'>
  <Options>
    <TextAlwaysAsProperty>???</TextAlwaysAsProperty>
    <TextNodeName>#text</TextNodeName>
  </Options>
</XMLToJSON>

Para las entradas XML dadas, la política generará estos resultados, según si TextAlwaysAsProperty es true o false:

Entrada XML	Salida de JSON
Entrada XML	cuando `TextAlwaysAsProperty` es `false`	cuando `TextAlwaysAsProperty` es `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" } } }

Predeterminada	`<TextAlwaysAsProperty>`: falso `<TextNodeName>`: (cadena en blanco)
Presencia	Opcional
Tipo	`<TextAlwaysAsProperty>`: booleano `<TextNodeName>`: string

Opciones de atributo

Estos elementos, en conjunto, te permiten agrupar valores de atributos en un bloque JSON y agregar prefijos a los nombres de atributos.

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

Considera el siguiente ejemplo de XML:

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

Si los atributos (AttributeBlockName y AttributePrefix) se especifican como se define en el ejemplo de XML a JSON, se genera la siguiente estructura JSON:

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

Si solo se especifica AttributeBlockName, se genera la siguiente estructura JSON:

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

Si solo se especifica AttributePrefix, se genera la siguiente estructura JSON:

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

Si no se especifica ninguna, se genera la siguiente estructura JSON:

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

Predeterminada	ninguno.
Presencia	Opcional
Tipo	Cadena

Elementos <OutputPrefix> y <OutputSuffix>

Usa estos elementos juntos para aplicar un prefijo o sufijo al JSON generado.

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

Considera el siguiente ejemplo de XML:

<a>value</a>

Supongamos que la configuración de la política es la siguiente:

<XMLToJSON name='XMLToJSON-4'>
  <Options>
    <OutputPrefix>{ "result": </OutputPrefix>
    <OutputSuffix>}</OutputSuffix>
  </Options>
</XMLToJSON>

Se genera la siguiente estructura JSON:

{
  "result": {
    "a": "value"
  }
}

Puedes omitir OutputPrefix o OutputSuffix, o ambos.

Si usas estos elementos, es posible generar un JSON no válido. Por ejemplo, con esta configuración de política:

<XMLToJSON name='XMLToJSON-4'>
  <Options>
    <OutputPrefix>PREFIX_</OutputPrefix>
  </Options>
</XMLToJSON>

La política genera lo siguiente, que no es un JSON válido:

PREFIX_{
  "a" : "value"
}

Si la configuración no especifica OutputPrefix ni OutputSuffix, la política genera la siguiente estructura JSON:

{
  "a": "value"
}

Predeterminada	Consulta los ejemplos anteriores.
Presencia	Opcional
Tipo	Cadena

Elemento <StripLevels>

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

A veces, las cargas útiles XML, como SOAP, tienen muchos niveles superiores que no quieres incluir en el JSON convertido. A continuación, se muestra un ejemplo de una respuesta de SOAP que contiene muchos niveles:

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

Hay 4 niveles antes de llegar al nivel de estado, ciudad, descripción y temperatura. Sin usar <StripLevels>, la respuesta JSON convertida se vería de la siguiente manera:

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

Si deseas quitar esos primeros 4 niveles de la respuesta JSON, debes establecer <StripLevels>4</StripLevels>, lo que generará el siguiente JSON:

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

Puedes quitar niveles hasta el primer elemento que contiene varios elementos secundarios. ¿Qué significa eso? Veamos un ejemplo de JSON más complejo:

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

En el ejemplo, el nivel 3 es GetCityForecastByZIPResponse, que solo tiene un elemento secundario. Entonces, si usaras <StripLevels>3</StripLevels> (se deben quitar los primeros tres niveles), el JSON se vería así:

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

Ten en cuenta que GetCityForecastByZIPResult tiene varios elementos secundarios. Como es el primer elemento que contiene varios elementos secundarios, puedes quitar este último nivel con <StripLevels>4</StripLevels>, lo que generará el siguiente JSON:

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

Debido a que el nivel 4 es el primer nivel que contiene varios elementos secundarios, no puedes anular los niveles inferiores a él. Si configuras el nivel de banda en 5, 6, 7, etc., seguirás recibiendo la respuesta anterior.

Predeterminada	0 (sin quitar niveles)
Presencia	Opcional
Tipo	Integer

Elemento <TreatAsArray>/<Path>

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

Esta combinación de elementos te permite asegurarte de que los valores de un documento XML se traduzcan siempre en un array de JSON. Esto puede ser útil cuando la cantidad de elementos secundarios varía para diferentes cargas útiles. El comportamiento predeterminado de Apigee es convertir varios elementos secundarios del mismo nombre en un array JSON y elementos secundarios individuales en un primitivo JSON. La opción TreatAsArray te permite asegurarte de que los elementos secundarios siempre se traduzcan en un array JSON.

Usar TreatAsArray puede mejorar la estructura del código posterior que controla el resultado, ya que los datos del arreglo se muestran siempre de la misma manera. Por ejemplo, cuando se evalúa un JSONPath de $.teachers.teacher.studentnames.name[0], se mostrará el valor de nombre de manera coherente, ya sea que el XML original contenga un elemento name o más de uno.

Observemos el comportamiento predeterminado de la conversión XML a JSON y, luego, exploremos cómo controlar el resultado mediante <TreatAsArray>/<Path>.

Cuando un documento XML contiene un elemento con varios casos (lo que puede suceder cuando el esquema XML especifica maxOccurs='unbounded' para el elemento), la política de XML a JSON coloca automáticamente esos valores en un array. Por ejemplo, el siguiente bloque XML

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

se convierte al siguiente JSON de forma automática sin una configuración de política especial:

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

Observa que los dos nombres de estudiantes están contenidos en un array.

Sin embargo, si solo aparece un alumno en el documento XML, la política de XML a JSON trata automáticamente el valor como una sola string, no como un arreglo de strings, como se muestra en el siguiente ejemplo:

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

En los ejemplos anteriores, los datos similares se convirtieron de maneras diferentes: una vez en un array y otra en una sola cadena. El elemento <TreatAsArray>/<Path> te permite controlar el resultado para asegurarte de que los nombres de los estudiantes siempre se conviertan en un array, incluso si solo hay un valor. Para configurar esto, identifica la ruta de acceso al elemento cuyos valores deseas convertir en un array, de la siguiente manera:

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

Con la configuración anterior, el JSON se generaría de esta manera:

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

Observa que student1 ahora está en un array. Ahora, independientemente de si hay uno o varios estudiantes, puedes recuperarlos desde un array de JSON en tu código con la siguiente ruta JSON: $.teachers.teacher.studentnames.name[0]

El elemento <Path> también tiene un atributo unwrap, que se explica en la siguiente sección.

Predeterminada	N/A
Presencia	Opcional
Tipo	Cadena

Atributos

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

Atributo Descripción Presencia Tipo

unwrap

Atributo	Descripción	Presencia	Tipo
unwrap	Valor predeterminado: false Quita el elemento del resultado JSON. Usa esto para optimizar o aplanar (“separar”) el JSON, que también abrevia la JSONPath necesaria para recuperar valores. Por ejemplo, en lugar de `$.teachers.teacher.studentnames.name[]`, puedes aplanar el JSON y usar `$.teachers.studentnames[]`. Este es un ejemplo de JSON: { "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ]}... En este ejemplo, puedes argumentar que el elemento `teacher` y el elemento `name` de studentnames no son necesarios. Por lo tanto, podrás quitarlos o separarlos. A continuación, te mostramos cómo configurar el elemento `<Path>` para que realices estas acciones: <TreatAsArray> <Path unwrap="true">teachers/teacher</Path> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> El atributo `unwrap` se configura como verdadero, y se proporcionan las rutas a los elementos que se separarán. El resultado JSON se verá de la siguiente manera: { "teachers" : [{ "name" : "teacherA", "studentnames" : ["student1","student2"] }]... Ten en cuenta que, como el elemento `<Path>` está en el elemento `<TreatAsArray>`, ambos elementos de la ruta se tratarán como arreglos en el resultado JSON.	Opcional	Booleano

Valor predeterminado: false

Quita el elemento del resultado JSON. Usa esto para optimizar o aplanar (“separar”) el JSON, que también abrevia la JSONPath necesaria para recuperar valores. Por ejemplo, en lugar de $.teachers.teacher.studentnames.name[*], puedes aplanar el JSON y usar $.teachers.studentnames[*].

Este es un ejemplo de JSON:


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

En este ejemplo, puedes argumentar que el elemento teacher y el elemento name de studentnames no son necesarios. Por lo tanto, podrás quitarlos o separarlos. A continuación, te mostramos cómo configurar el elemento <Path> para que realices estas acciones:


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

El atributo unwrap se configura como verdadero, y se proporcionan las rutas a los elementos que se separarán. El resultado JSON se verá de la siguiente manera:


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

Ten en cuenta que, como el elemento <Path> está en el elemento <TreatAsArray>, ambos elementos de la ruta se tratarán como arreglos en el resultado JSON.

Opcional

Booleano

Para ver más ejemplos y obtener una explicación sobre las funciones, consulta este artículo de la Comunidad de Google Cloud.

<Format>

El formato te permite controlar la conversión de XML a JSON. Ingresa el nombre de una plantilla predefinida que contiene una combinación específica de elementos de opciones que se describen en este tema. Los formatos predefinidos incluyen los siguientes: xml.com, yahoo, google y badgerFish.

Usa el elemento <Format> o el grupo <Options>. No puedes usar <Format> y <Options> al mismo tiempo.

A continuación, se presentan las definiciones de Format de cada plantilla predefinida.

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>

Sintaxis del elemento:

<Format>yahoo</Format>

Predeterminada	(ninguno)
Valores válidos	Uno de los siguientes: `xml.com`, `yahoo`, `google`, `badgerFish`
Presencia	Opcional, pero obligatorio si no se usa `<Options>`.
Tipo	Cadena

Esquemas

Referencia de errores

This section describes the fault codes and error messages that are returned and fault variables that are set by Apigee when this policy triggers an error. This information is important to know if you are developing fault rules to handle faults. To learn more, see What you need to know about policy errors and Handling faults.

Runtime errors

These errors can occur when the policy executes.

Fault code	HTTP status	Cause
`steps.xmltojson.ExecutionFailed`	`ExecutionFailed`	This error occurs when the input payload (XML) is empty or the input XML is invalid or malformed.
`steps.xmltojson.InCompatibleTypes`	`ExecutionFailed`	This error occurs if the type of the variable defined in the `<Source>` element and the `<OutputVariable>` element are not the same. It is mandatory that the type of the variables contained within the `<Source>` element and the `<OutputVariable>` element matches.
`steps.xmltojson.InvalidSourceType`	`ExecutionFailed`	This error occurs if the type of the variable used to define the `<Source>` element is invalid.The valid types of variable are message and string.
`steps.xmltojson.OutputVariableIsNotAvailable`	`ExecutionFailed`	This error occurs if the variable specified in the `<Source>` element of the XML to JSON policy is of type string and the `<OutputVariable>` element is not defined. The `<OutputVariable>` element is mandatory when the variable defined in the `<Source>` element is of type string.
`steps.xmltojson.SourceUnavailable`	`ExecutionFailed`	This error occurs if the message variable specified in the `<Source>` element of the XML to JSON policy is either: Out of scope (not available in the specific flow where the policy is being executed) or Can't be resolved (is not defined)

Deployment errors

These errors can occur when you deploy a proxy containing this policy.

Error name	Cause	Fix
`EitherOptionOrFormat`	If one of the elements `<Options>` or `<Format>` is not declared in the XML to JSON Policy, then the deployment of the API proxy fails.
`UnknownFormat`	If the `<Format>` element within the XML to JSON policy has an unknown format defined, then the deployment of the API proxy fails. Predefined formats include: `xml.com`, `yahoo`, `google`, and `badgerFish`.

Fault variables

These variables are set when a runtime error occurs. For more information, see What you need to know about policy errors.

Variables	Where	Example
`fault.name="fault_name"`	`fault_name` is the name of the fault, as listed in the Runtime errors table above. The fault name is the last part of the fault code.	`fault.name = "SourceUnavailable"`
`xmltojson.policy_name.failed`	`policy_name` is the user-specified name of the policy that threw the fault.	`xmltojson.XMLtoJSON-1.failed = true`

Example error response

Note: For error handling, the best practice is to trap the errorcode part of the error response. Do not rely on the text in the faultstring, because it could change.

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

Example fault rule

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

Temas relacionados

De JSON a XML: política JSONtoXML