Esta página se ha traducido con Cloud Translation API.

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 los mensajes del formato de lenguaje de marcado extensible (XML) a la notación de objetos JavaScript (JSON), lo que te ofrece varias opciones para controlar cómo se convierten los mensajes.

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

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

Información

En un escenario de mediación habitual, una política de JSON a XML en el flujo de solicitudes entrantes suele combinarse con una política de XML a JSON en el flujo de respuestas salientes. Al combinar las políticas de esta forma, se puede exponer una API JSON para los servicios de backend que solo admiten XML de forma nativa.

En los casos en los que las APIs se usan en diversas aplicaciones cliente que pueden requerir JSON o XML, el formato de respuesta se puede definir de forma dinámica configurando políticas de JSON a XML y de XML a JSON para que se ejecuten de forma condicional. Consulta Variables y condiciones de flujo para ver una implementación de este caso.

Ejemplos

Para obtener información detallada sobre la conversión entre JSON y XML, consulta este artículo.

Convertir una respuesta

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

Esta configuración, que es la mínima necesaria para convertir XML a JSON, toma como origen un mensaje de respuesta con formato XML y, a continuación, crea un mensaje con formato JSON que se rellena en response OutputVariable. Apigee usa automáticamente el contenido de esta variable como mensaje para el siguiente paso de procesamiento.

Referencia de elemento

A continuación, se indican los elementos y 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 de <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 superiores de la política:

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. Opcionalmente, usa el elemento `<DisplayName>` para etiquetar la política en el editor de proxy de la interfaz de gestión con un nombre diferente en lenguaje natural.	N/A	Obligatorio
`continueOnError`	Asigna el valor `false` para devolver un error cuando falle una política. Este es el comportamiento esperado de la mayoría de las políticas. Asigna el valor `true` para que la ejecución del flujo continúe incluso después de que falle una política. Consulta también: Las reglas de errores solo se activan cuando hay un error (sobre continueOnError) Gestionar fallos en el flujo actual	falso	Opcional
`enabled`	Asigna el valor `true` para aplicar la política. Selecciona `false` para desactivar la política. La política no se aplicará aunque siga adjunta a un flujo.	true	Opcional
`async`	Este atributo está obsoleto.	falso	Obsoleto

Elemento <DisplayName>

Úsalo junto con el atributo name para etiquetar la política en el editor de proxy de la interfaz de gestión con un nombre diferente en lenguaje natural.

<DisplayName>Policy Display Name</DisplayName>

Predeterminado

Predeterminado	N/A Si omite este elemento, se usará el valor del atributo `name` de la política.
Presencia	Opcional
Tipo	Cadena

N/A

Si omite este elemento, se usará el valor del atributo name de la política.

Presencia Opcional

Tipo Cadena

Elemento <Source>

La variable que especifica el mensaje XML que quieres convertir a JSON.

El encabezado Content-type HTTP del mensaje de origen debe tener el valor application/xml. De lo contrario, no se aplicará la política.

Si no se define <Source>, se trata como message, que se resuelve como request cuando la política se adjunta a un flujo de solicitudes o response cuando la política se adjunta a un flujo de respuestas.

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

<Source>response</Source>

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

Elemento <OutputVariable>

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

Apigee analiza la carga útil del mensaje XML especificado en Source, la convierte en JSON, almacena el resultado en la carga útil de OutputVariable y asigna el valor application/json al encabezado Content-type HTTP del mensaje OutputVariable.

Si no se especifica OutputVariable, se usa el valor de Source de forma predeterminada. Por ejemplo, si source es response, OutputVariable tendrá el valor predeterminado response.

<OutputVariable>response</OutputVariable>

Predeterminado	El mensaje especificado en `Source`
Presencia	Opcional
Tipo	Mensaje

<Opciones>

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

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

Elemento <RecognizeNumber>

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

<RecognizeNumber>true</RecognizeNumber>

Veamos el siguiente ejemplo de XML:

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

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

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

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

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

Predeterminado	falso
Presencia	Opcional
Tipo	Booleano

Elemento <RecognizeBoolean>

Permite que la conversión mantenga los valores booleanos true/false en lugar de convertir los valores en cadenas.

<RecognizeBoolean>true</RecognizeBoolean>

En el siguiente ejemplo de XML:

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

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

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

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

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

Predeterminado	falso
Presencia	Opcional
Tipo	Booleano

Elemento <RecognizeNull>

Permite convertir valores vacíos en valores nulos.

<RecognizeNull>true</RecognizeNull>

Para el siguiente XML:

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

Si RecognizeNull es true y no hay ninguna 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"
  }
}

Predeterminado	falso
Presencia	Opcional
Tipo	Booleano

Elemento <NullValue>

Indica el valor al que se deben convertir los valores nulos reconocidos en el mensaje de origen. De forma predeterminada, el valor es null. Esta opción solo tiene efecto si RecognizeNull es true.

<NullValue>not-present</NullValue>

Para 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"
  }
}

Predeterminado	`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 del documento XML se traduzcan al JSON generado, utilice estos elementos juntos.

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

Veamos 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, se generará la siguiente estructura JSON:

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

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

Opciones de texto

Usa estos elementos juntos.

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

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

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

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

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

En función de si TextAlwaysAsProperty es true o false, la política generará los siguientes resultados para las entradas XML proporcionadas:

Entrada XML	Salida 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" } } }

Predeterminado	`<TextAlwaysAsProperty>`: false `<TextNodeName>`: (cadena vacía)
Presencia	Opcional
Tipo	`<TextAlwaysAsProperty>`: booleano `<TextNodeName>`: cadena

Opciones de atributo

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

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

Veamos el siguiente ejemplo de XML:

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

Si se especifican ambos atributos (AttributeBlockName y AttributePrefix) tal como se definen 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 ninguno de los dos, se genera la siguiente estructura JSON:

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

Predeterminado	Ninguna.
Presencia	Opcional
Tipo	Cadena

Elementos <OutputPrefix> y <OutputSuffix>

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

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

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

Con estos elementos, se puede generar un JSON no válido. Por ejemplo, si usas 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 en la configuración no se especifica ni OutputPrefix ni OutputSuffix, la política genera la siguiente estructura JSON:

{
  "a": "value"
}

Predeterminado	Consulta los ejemplos de arriba.
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 respuesta 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 a los niveles Estado, Ciudad, Descripción y Temperatura. Sin usar <StripLevels>, la respuesta JSON convertida tendría este aspecto:

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

Si quieres eliminar esos cuatro primeros niveles de la respuesta JSON, debes definir <StripLevels>4</StripLevels>, lo que te dará el siguiente JSON:

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

Puedes eliminar niveles hasta el primer elemento que contenga 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
                        }  ...

El nivel 3 de este ejemplo es GetCityForecastByZIPResponse, que solo tiene un elemento secundario. Por lo tanto, si usara <StripLevels>3</StripLevels> (quitar los tres primeros niveles), el JSON tendría este aspecto:

{
   "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 eliminar este último nivel con <StripLevels>4</StripLevels>, lo que te dará el siguiente JSON:

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

Como el nivel 4 es el primero que contiene varios elementos secundarios, no puedes eliminar ningún nivel inferior. Si ajustas el nivel de la tira a 5, 6, 7, etc., seguirás recibiendo la respuesta anterior.

Predeterminado	0 (sin eliminación de niveles)
Presencia	Opcional
Tipo	Entero

Elemento <TreatAsArray>/<Path>

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

Esta combinación de elementos le permite asegurarse de que los valores de un documento XML siempre se traducen a una matriz JSON. Esto puede ser útil cuando el número de elementos secundarios varía en diferentes cargas útiles. El comportamiento predeterminado de Apigee es convertir varios elementos secundarios con el mismo nombre en una matriz JSON y los elementos secundarios únicos en un primitivo JSON. La opción TreatAsArray le permite asegurarse de que los elementos secundarios se traduzcan siempre a una matriz JSON.

Si usas TreatAsArray, puedes mejorar la estructura del código posterior que gestiona la salida, ya que los datos de la matriz se devuelven de la misma forma cada vez. Por ejemplo, al evaluar un JSONPath de $.teachers.teacher.studentnames.name[0], se devolverá el valor del nombre de forma coherente, independientemente de si el XML original contenía uno o más elementos name.

Vamos a volver a ver el comportamiento predeterminado de XML a JSON y, después, vamos a descubrir cómo controlar el resultado con <TreatAsArray>/<Path>.

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

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

...se convierte automáticamente en el siguiente JSON sin necesidad de configurar ninguna política especial:

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

Observa que los dos nombres de los alumnos están incluidos en una matriz.

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

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

En los ejemplos anteriores, los datos similares se han convertido de forma diferente: una vez en una matriz y otra en una sola cadena. El elemento <TreatAsArray>/<Path> te permite controlar la salida para asegurarte de que los nombres de los alumnos se conviertan siempre en un array, aunque solo haya un valor. Para configurarlo, debe identificar la ruta al elemento cuyos valores quiera convertir en una matriz, de la siguiente manera:

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

La configuración anterior generaría el JSON de la siguiente manera:

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

Observa que student1 ahora está en una matriz. Ahora, independientemente de si hay uno o varios alumnos, puedes recuperarlos de una matriz JSON en tu código mediante el siguiente JSONPath: $.teachers.teacher.studentnames.name[0]

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

Predeterminado	N/A
Presencia	Opcional
Tipo	Cadena

Atributos

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

Atributo Descripción Presencia Tipo

desenvolver

Atributo	Descripción	Presencia	Tipo
desenvolver	Valor predeterminado: false Quita el elemento del resultado JSON. Úsalo para simplificar o aplanar ("desenvolver") el JSON, lo que también acorta el JSONPath necesario para recuperar valores. Por ejemplo, en lugar de `$.teachers.teacher.studentnames.name[]`, puedes acoplar el JSON y usar `$.teachers.studentnames[]`. Aquí tienes un ejemplo en JSON: { "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ]}... En este ejemplo, podría decirse que el elemento `teacher` y el elemento studentnames `name` no son necesarios. Por lo tanto, puedes quitar o envolver los elementos. Para configurar el elemento `<Path>` de esta forma, sigue estos pasos: <TreatAsArray> <Path unwrap="true">teachers/teacher</Path> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> El atributo `unwrap` se define como true y se proporcionan las rutas a los elementos que se van a desenvolver. La salida JSON tendrá este aspecto: { "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 matrices en el resultado JSON.	Opcional	Booleano

Valor predeterminado: false

Quita el elemento del resultado JSON. Úsalo para simplificar o aplanar ("desenvolver") el JSON, lo que también acorta el JSONPath necesario para recuperar valores. Por ejemplo, en lugar de $.teachers.teacher.studentnames.name[*], puedes acoplar el JSON y usar $.teachers.studentnames[*].

Aquí tienes un ejemplo en JSON:

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

En este ejemplo, podría decirse que el elemento teacher y el elemento studentnames name no son necesarios. Por lo tanto, puedes quitar o envolver los elementos. Para configurar el elemento <Path> de esta forma, sigue estos pasos:

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

El atributo unwrap se define como true y se proporcionan las rutas a los elementos que se van a desenvolver. La salida JSON tendrá este aspecto:

{
  "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 matrices en el resultado JSON.

Opcional

Booleano

Para ver más ejemplos y una guía de la función, consulta este artículo de la comunidad de Google Cloud.

<Format>

El formato te permite controlar la conversión de XML a JSON. Introduce el nombre de una plantilla predefinida que contenga una combinación específica de elementos Options descritos en este tema. Entre los formatos predefinidos se incluyen 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 muestran las definiciones de formato 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>

Predeterminado	(ninguna)
Valores válidos	Uno de los siguientes: `xml.com`, `yahoo`, `google` o `badgerFish`
Presencia	Es opcional, pero obligatorio si no se usa `<Options>`.
Tipo	Cadena

Esquemas

Referencia de errores

En esta sección se describen los códigos de error y los mensajes de error que devuelve Apigee, así como las variables de error que define, cuando esta política activa un error. Es importante que conozcas esta información si vas a desarrollar reglas de errores para gestionarlos. Para obtener más información, consulta Qué debes saber sobre los errores de políticas y Cómo gestionar los fallos.

Errores de tiempo de ejecución

Estos errores pueden producirse cuando se ejecuta la política.

Código de fallo	Estado de HTTP	Causa
`steps.xmltojson.ExecutionFailed`	`ExecutionFailed`	Este error se produce cuando la carga útil de entrada (XML) está vacía o el XML de entrada no es válido o tiene un formato incorrecto.
`steps.xmltojson.InCompatibleTypes`	`ExecutionFailed`	Este error se produce si el tipo de la variable definida en el elemento `<Source>` y el elemento `<OutputVariable>` no son el mismo. Es obligatorio que el tipo de las variables contenidas en el elemento `<Source>` y en el elemento `<OutputVariable>` coincida.
`steps.xmltojson.InvalidSourceType`	`ExecutionFailed`	Este error se produce si el tipo de la variable utilizada para definir el elemento `<Source>` no es válido.Los tipos de variable válidos son message y string.
`steps.xmltojson.OutputVariableIsNotAvailable`	`ExecutionFailed`	Este error se produce si la variable especificada en el elemento `<Source>` del XML de la política JSON es de tipo cadena y el elemento `<OutputVariable>` no está definido. El elemento `<OutputVariable>` es obligatorio cuando la variable definida en el elemento `<Source>` es de tipo cadena.
`steps.xmltojson.SourceUnavailable`	`ExecutionFailed`	Este error se produce si la variable message especificada en el elemento `<Source>` de la política XML a JSON es: Fuera del ámbito (no disponible en el flujo específico en el que se está ejecutando la política) o No se puede resolver (no está definido)

Errores de implementación

Estos errores pueden producirse al implementar un proxy que contenga esta política.

Nombre del error	Causa	Solucionar
`EitherOptionOrFormat`	Si no se declara uno de los elementos `<Options>` o `<Format>` en la política de XML a JSON, se producirá un error en la implementación del proxy de API.
`UnknownFormat`	Si el elemento `<Format>` de la política XML a JSON tiene un formato desconocido, no se podrá implementar el proxy de API. Entre los formatos predefinidos se incluyen los siguientes: `xml.com`, `yahoo`, `google` y `badgerFish`.

Variables de error

Estas variables se definen cuando se produce un error de tiempo de ejecución. Para obtener más información, consulta el artículo Información sobre los errores de las políticas.

Variables	Dónde	Ejemplo
`fault.name="fault_name"`	`fault_name` es el nombre del fallo, tal como se indica en la tabla Errores de tiempo de ejecución de arriba. El nombre del error es la última parte del código de error.	`fault.name = "SourceUnavailable"`
`xmltojson.policy_name.failed`	`policy_name` es el nombre de la política especificado por el usuario que ha provocado el error.	`xmltojson.XMLtoJSON-1.failed = true`

Ejemplo de respuesta de error

Nota: Para gestionar los errores, la práctica recomendada es detectar la parte errorcode de la respuesta de error. No te fíes del texto de la faultstring, ya que podría cambiar.

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

Regla de error de ejemplo

<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

Política XMLtoJSON Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Qué

Información

Ejemplos

Convertir una respuesta

Referencia de elemento

Atributos de <XMLtoJSON>

Elemento <DisplayName>

Elemento <Source>

Elemento <OutputVariable>

<Opciones>

Elemento <RecognizeNumber>

Elemento <RecognizeBoolean>

Elemento <RecognizeNull>

Elemento <NullValue>

Opciones de espacio de nombres

Opciones de texto

Opciones de atributo

Elementos <OutputPrefix> y <OutputSuffix>

Elemento <StripLevels>

Elemento <TreatAsArray>/<Path>

Atributos

<Format>

xml.com

yahoo

google

badgerFish

Esquemas

Referencia de errores

Errores de tiempo de ejecución

Errores de implementación

Variables de error

Ejemplo de respuesta de error

Regla de error de ejemplo

Temas relacionados

Política XMLtoJSON