Política XMLtoJSON

Esta página se aplica à Apigee e à Apigee híbrida.

Confira a documentação da Apigee Edge.

O que

Essa política converte mensagens do formato extensível da linguagem de marcação (XML) para o JavaScript Object Notation (JSON), oferecendo várias opções para controlar como as mensagens são convertidas.

Supondo que o intent seja converter uma resposta formatada em XML em uma resposta formatada como JSON, a política será anexada a um fluxo de resposta (por exemplo, Resposta / ProxyEndpoint / PostFlow).

Esta é uma política padrão e pode ser implantada em qualquer tipo de ambiente. Nem todos os usuários têm necessidade de saber sobre os tipos de política e ambiente. Para informações sobre os tipos de políticas e a disponibilidade de cada tipo de ambiente, consulte Tipos de políticas.

Sobre

Em um cenário típico de mediação, uma política JSON para XML no fluxo de solicitação de entrada geralmente é pareada com uma política XMLtoJSON no fluxo de resposta de saída. Ao combinar políticas dessa maneira, uma API JSON pode ser exposta para serviços de backend que suportam apenas XML.

Para cenários em que as APIs são consumidas por diversos aplicativos de clientes que podem exigir JSON e XML, o formato da resposta pode ser definido dinamicamente pela configuração do JSON para XML e XML para políticas JSON que serão executadas condicionalmente. Consulte Variáveis e condições do fluxo para uma implementação desse cenário.

Amostras

Para uma discussão detalhada sobre a conversão entre JSON e XML, consulte este artigo.

Como converter uma resposta

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

Essa configuração, que é a configuração mínima necessária para converter XML para JSON, usa uma mensagem de resposta formatada em XML como origem e, em seguida, cria uma mensagem formatada em JSON que é preenchida na OutputVariable response. A Apigee usa automaticamente o conteúdo dessa variável como a mensagem para a próxima etapa de processamento.

Referência de elemento

Veja a seguir elementos e atributos que podem ser configurados com 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">

A tabela a seguir descreve atributos comuns a todos os elementos pai de políticas:

Atributo	Descrição	Padrão	Presença
`name`	O nome interno da política. O valor do atributo `name` pode conter letras, números, espaços, hifens, sublinhados e pontos. Esse valor não pode exceder 255 caracteres. Opcionalmente, use o elemento `<DisplayName>` para rotular a política no editor de proxy da IU de gerenciamento com um nome de linguagem natural diferente.	N/A	Obrigatório
`continueOnError`	Defina como `false` para retornar um erro quando uma política falhar. Esse é o comportamento esperado na maioria das políticas. Defina como `true` para que a execução do fluxo continue mesmo depois que uma política falhar. Consulte também: As regras de falha são acionadas SOMENTE em um estado de erro (sobre continueOnError) Como corrigir falhas no fluxo atual	falso	Opcional
`enabled`	Defina como `true` para aplicar a política. Defina como `false` para desativar a política. A política não será aplicada mesmo se ela permanecer anexada a um fluxo.	verdadeiro	Opcional
`async`	Esse atributo está obsoleto.	falso	Descontinuado

Elemento <DisplayName>

Use em conjunto com o atributo name para rotular a política no editor de proxy da IU de gerenciamento com um nome de linguagem natural diferente.

<DisplayName>Policy Display Name</DisplayName>

Padrão

Padrão	N/A Se você omitir esse elemento, será usado o valor do atributo `name` da política.
Presença	Opcional
Tipo	String

N/A

Se você omitir esse elemento, será usado o valor do atributo name da política.

Presença Opcional

Tipo String

Elemento <Source>

A variável que especifica a mensagem XML que você quer converter em JSON.

O cabeçalho HTTP Content-type da mensagem de origem precisa ser definido como application/xml. Caso contrário, a política não é aplicada.

Se <Source> não estiver definido, ele será tratado como message (o que resolve quando a política request é anexada a um fluxo de solicitação ou response quando a política está anexada a um fluxo de resposta).

Se a variável de origem não puder ser resolvida ou resolvida para um tipo não mensagem, a política gerará um erro.

<Source>response</Source>

Padrão	O valor do elemento `Source`
Presença	Opcional
Tipo	Mensagem

Elemento <OutputVariable>

Especifica onde armazenar a saída da conversão de formato XML para JSON. Normalmente, esse elemento não está incluído na configuração da política.

A Apigee analisa o payload da mensagem XML especificada em Source, converte-o em JSON, armazena o resultado no payload de OutputVariable e define o cabeçalho de tipo de conteúdo HTTP de OutputVariable mensagem para application/json.

Se OutputVariable não for especificado, o valor de Source será usado por padrão. Por exemplo, se source for response, então OutputVariable será definido como response por padrão.

<OutputVariable>response</OutputVariable>

Padrão	a mensagem especificada em `Source`
Presença	Opcional
Tipo	Mensagem

<Options>

As opções oferecem controle sobre a conversão de XML para JSON. Use o grupo <Options>, que permite adicionar configurações de conversão específicas, ou o elemento <Format>, que permite fazer referência a um modelo de opções predefinidas. Não é possível usar <Options> e <Format>.

<Options> será necessário se <Format> não for usado.

Elemento <RecognizeNumber>

Se for true, os campos numéricos no payload do XML mantêm o formato original.

<RecognizeNumber>true</RecognizeNumber>

Considere o seguinte exemplo de XML:

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

Se RecognizeNumber for true, a política converterá isso em:

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

Se RecognizeNumber for false, a política converterá isso em:

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

Padrão	falso
Presença	Opcional
Tipo	Booleano

Elemento <RecognizeBoolean>

Permite que a conversão mantenha valores booleanos/falsos em vez de transformar os valores em strings.

<RecognizeBoolean>true</RecognizeBoolean>

Para o seguinte exemplo de XML:

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

Se RecognizeBoolean for true, a política converterá isso em:

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

Se RecognizeBoolean for false, a política converterá isso em:

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

Padrão	falso
Presença	Opcional
Tipo	Booleano

Elemento <RecognizeNull>

Permite converter valores vazios em valores nulos.

<RecognizeNull>true</RecognizeNull>

Para o seguinte XML:

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

Se RecognizeNull for true e não houver uma opção NullValue, esse XML será convertido em:

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

Se RecognizeNull for false, este XML será convertido em:

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

Padrão	falso
Presença	Opcional
Tipo	Booleano

Elemento <NullValue>

Indica o valor para o qual valores nulos reconhecidos na mensagem de origem serão convertidos. Por padrão, o valor é null. Essa opção só será eficaz se RecognizeNull for verdadeiro.

<NullValue>not-present</NullValue>

Para o seguinte XML:

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

Se RecognizeNull for true e NullValue não for especificado, este XML converterá em:

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

Se RecognizeNull for true e NullValue for not-present, este XML converterá em:

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

Padrão	`null`
Presença	Opcional
Tipo	String

Opções de namespace

Por padrão, essa política omite namespaces XML no JSON gerado. Para especificar que os namespaces no documento XML precisam ser convertidos no JSON gerado, use esses elementos juntos.

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

Considere o seguinte exemplo de XML:

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

Se NamespaceSeparator não for especificado, a seguinte estrutura JSON será gerada:

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

Se os elementos NamespaceBlockName, DefaultNamespaceNodeName e NamespaceSeparator forem especificados como #namespaces, & e ***, respectivamente, a seguinte estrutura JSON é gerado:

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

Padrão	Nenhuma. Se `<NamespaceBlockName>` não for especificado, a política vai gerar um JSON de saída que não se refere a nenhum namespace XML, independente de a mensagem de origem ter feito referência a namespaces.
Presença	Opcional No entanto, se você especificar `<NamespaceBlockName>`, deverá também especificar os outros dois elementos.
Tipo	Strings

Opções de texto

Use esses elementos juntos.

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

Quando a política encontra um elemento XML que contém apenas um nó de texto como filho, ela converte o conteúdo de texto desse elemento XML em uma propriedade no hash JSON.

Quando a política encontra um elemento XML que contém vários filhos de conteúdo misto, essas opções permitem controlar o JSON de saída de qualquer nó de texto filho.

Por exemplo, considere esta configuração de política:

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

Para as entradas XML fornecidas, a política vai gerar essas saídas, dependendo de TextAlwaysAsProperty ser true ou false:

Entrada XML	Saída JSON
Entrada 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" } } }

Padrão	`<TextAlwaysAsProperty>`: falso `<TextNodeName>`: (string em branco)
Presença	Opcional
Tipo	`<TextAlwaysAsProperty>`: booleano `<TextNodeName>`: string

Opções do atributo

Juntos, esses elementos permitem agrupar valores de atributo em um bloco JSON e anexar prefixos aos nomes dos atributos.

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

Considere o seguinte exemplo de XML:

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

Se ambos os atributos (AttributeBlockName e AttributePrefix) forem especificados conforme definido no exemplo de XML para JSON, a seguinte estrutura JSON será gerada:

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

Se apenas AttributeBlockName for especificado, a seguinte estrutura JSON será gerada:

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

Se apenas AttributePrefix for especificado, a seguinte estrutura JSON será gerada:

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

Se nenhum deles for especificado, a seguinte estrutura JSON será gerada:

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

Padrão	nenhum.
Presença	Opcional
Tipo	String

Elementos <OutputPrefix> e <OutputSuffix>

Use esses elementos juntos para aplicar um prefixo e/ou sufixo ao JSON gerado.

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

Considere o seguinte exemplo de XML:

<a>value</a>

Suponha que a configuração da política seja a seguinte:

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

A seguinte estrutura JSON é gerada:

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

É possível omitir OutputPrefix e/ou OutputSuffix.

Com esses elementos, é possível gerar um JSON inválido. Por exemplo, usando esta configuração de política:

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

A política gera o seguinte, que não é um JSON válido:

PREFIX_{
  "a" : "value"
}

Se a configuração não especificar OutputPrefix nem OutputSuffix, a política vai gerar a seguinte estrutura JSON:

{
  "a": "value"
}

Padrão	Veja os exemplos acima.
Presença	Opcional
Tipo	String

Elemento <StripLevels>

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

payloadss vezes, os payloads XML, como o SOAP, têm muitos níveis pais que você não quer incluir no JSON convertido. Veja um exemplo de resposta SOAP com muitos níveis:

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

Existem quatro níveis antes de chegar ao nível Estado, Cidade, Descrição e Temperatura. Sem usar <StripLevels>, a resposta JSON convertida seria assim:

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

Se você quiser retirar esses quatro níveis na resposta JSON, <StripLevels>4</StripLevels>, que fornece o seguinte JSON:

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

Você pode eliminar os níveis até o primeiro elemento que contém vários filhos. O que isso significa? Vamos analisar um exemplo JSON mais complexo:

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

O nível 3 neste exemplo é GetCityForecastByZIPResponse, que tem apenas um filho. Se você usasse <StripLevels>3</StripLevels> (remova os três primeiros níveis), o JSON ficaria assim:

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

GetCityForecastByZIPResult tem vários filhos. Como é o primeiro elemento que contém vários filhos, é possível remover esse último nível usando <StripLevels>4</StripLevels>, que fornecerá o seguinte JSON:

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

Como o nível 4 é o primeiro que contém vários filhos, não é possível remover níveis inferiores a esse. Se você definir o nível da faixa como 5, 6, 7 e assim por diante, continuará recebendo a resposta acima.

Padrão	0 (sem remoção de nível)
Presença	Opcional
Tipo	Número inteiro

Elemento <TreatAsArray>/<Path>

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

Essa combinação de elementos garante que os valores de um documento XML sejam sempre convertidos em uma matriz JSON. Isso pode ser útil quando o número de elementos filhos varia de acordo com os diferentes payloads. O comportamento padrão da Apigee é converter vários elementos filhos com o mesmo nome em uma matriz JSON e elementos filhos únicos em um primitivo JSON. A opção TreatAsArray garante que os elementos filhos sejam sempre traduzidos para uma matriz JSON.

O uso de TreatAsArray pode melhorar a estrutura do código subsequente que processa a saída, porque os dados da matriz são sempre retornados da mesma maneira. Por exemplo, avaliar um JSONPath de $.teachers.teacher.studentnames.name[0] retornará o valor do nome de maneira consistente, independentemente de o XML original conter um ou mais de um elemento name.

Vamos voltar e analisar o comportamento padrão do XML para o JSON e, em seguida, explorar como controlar a saída usando <TreatAsArray>/<Path>.

Quando um documento XML contém um elemento com várias ocorrências, o que pode acontecer quando o esquema XML especifica maxOccurs='unbounded' para o elemento, a política XML para JSON coloca automaticamente esses valores em uma matriz. Por exemplo, o seguinte bloco XML

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

.…é convertido no seguinte JSON automaticamente, sem configuração de política especial:

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

Observe que os dois nomes de estudantes estão contidos em uma matriz.

No entanto, se apenas um aluno aparecer no documento XML, a política XML para JSON tratará automaticamente o valor como uma única string, não como uma matriz de strings, conforme mostrado no exemplo a seguir:

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

Nos exemplos anteriores, dados semelhantes eram convertidos de maneira diferente: uma vez em uma matriz e outro em uma única string. O elemento <TreatAsArray>/<Path> permite controlar a saída para garantir que os nomes dos estudantes sejam sempre convertidos em uma matriz, mesmo que haja apenas um valor. Para configurar isso, identifique o caminho para o elemento cujos valores você quer converter em uma matriz:

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

A configuração acima geraria o JSON assim:

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

Observe que student1 agora está em uma matriz. Agora, independentemente de haver um ou vários alunos, é possível recuperá-los de uma matriz JSON no seu código usando o seguinte JSONPath: $.teachers.teacher.studentnames.name[0]

O elemento <Path> também tem um atributo unwrap, explicado na próxima seção.

Padrão	N/A
Presença	Opcional
Tipo	String

Atributos

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

Atributo Descrição Presença Tipo

unwrap

Atributo	Descrição	Presença	Tipo
unwrap	Padrão: false Remove o elemento da saída JSON. Use-o para simplificar ou nivelar ("desencapsular") o JSON, o que também encurta o JSONPath necessário para recuperar valores. Por exemplo, em vez de `$.teachers.teacher.studentnames.name[]`, é possível nivelar o JSON e usar `$.teachers.studentnames[]`. Veja um exemplo de JSON: { "teachers" : { "teacher" : { "name" : "teacherA", "studentnames" : { "name" : [ "student1", "student2" ]}... Nesse exemplo, você poderia dizer que o elemento `teacher` e o elemento studentnames `name` são desnecessários. Assim, seria possível removê-los ou desagrupá-los. Veja como configurar o elemento `<Path>` para fazer isso: <TreatAsArray> <Path unwrap="true">teachers/teacher</Path> <Path unwrap="true">teachers/teacher/studentnames/name</Path> </TreatAsArray> O atributo `unwrap` é definido como verdadeiro, e os caminhos para os elementos que serão desencapsulados são fornecidos. A resposta JSON terá esta aparência: { "teachers" : [{ "name" : "teacherA", "studentnames" : ["student1","student2"] }]... Observe que, como o elemento `<Path>` está no elemento `<TreatAsArray>`, ambos os elementos no caminho serão tratados como matrizes na saída JSON.	Opcional	Booleano

Padrão: false

Remove o elemento da saída JSON. Use-o para simplificar ou nivelar ("desencapsular") o JSON, o que também encurta o JSONPath necessário para recuperar valores. Por exemplo, em vez de $.teachers.teacher.studentnames.name[*], é possível nivelar o JSON e usar $.teachers.studentnames[*].

Veja um exemplo de JSON:

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

Nesse exemplo, você poderia dizer que o elemento teacher e o elemento studentnames name são desnecessários. Assim, seria possível removê-los ou desagrupá-los. Veja como configurar o elemento <Path> para fazer isso:

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

O atributo unwrap é definido como verdadeiro, e os caminhos para os elementos que serão desencapsulados são fornecidos. A resposta JSON terá esta aparência:

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

Observe que, como o elemento <Path> está no elemento <TreatAsArray>, ambos os elementos no caminho serão tratados como matrizes na saída JSON.

Opcional

Booleano

Para mais exemplos e um tutorial sobre os recursos, consulte este artigo da Comunidade do Google Cloud.

<Format>

O formato permite que você controle a conversão de XML para JSON. Digite o nome de um modelo predefinido que contém uma combinação específica de elementos Options descritos neste tópico. Os formatos predefinidos incluem: xml.com, yahoo, google, badgerFish.

Use o elemento <Format> ou o grupo <Options>. Não é possível usar <Format> e <Options>.

Veja a seguir as definições de formato de cada modelo predefinido.

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>

Sintaxe do elemento:

<Format>yahoo</Format>

Padrão	(nenhum)
Valores válidos	Opções: `xml.com`, `yahoo`, `google`, `badgerFish`
Presença	Opcional, mas obrigatório se `<Options>` não for usado.
Tipo	String

Esquemas

Referência de erros

Esta seção descreve os códigos de falha e as mensagens de erro que são retornadas e as variáveis de falha definidas pela Apigee quando essa política aciona um erro. Essas informações são importantes para saber se você está desenvolvendo regras de falha para lidar com falhas. Para saber mais, consulte O que você precisa saber sobre erros de política e Como lidar com falhas.

Erros de execução

Esses erros podem ocorrer quando a política é executada.

Código de falha	Status HTTP	Causa
`steps.xmltojson.ExecutionFailed`	`ExecutionFailed`	Este erro ocorre quando o payload de entrada (XML) está vazio ou o XML de entrada é inválido ou está malformado.
`steps.xmltojson.InCompatibleTypes`	`ExecutionFailed`	Esse erro ocorrerá se o tipo da variável definido no elemento `<Source>` e o elemento `<OutputVariable>` não forem os mesmos. É obrigatório que o tipo das variáveis contidas no elemento `<Source>` e no elemento `<OutputVariable>` sejam iguais.
`steps.xmltojson.InvalidSourceType`	`ExecutionFailed`	Esse erro ocorre se o tipo da variável usada para definir o elemento `<Source>` é inválida. Os tipos válidos de variável são mensagem e string.
`steps.xmltojson.OutputVariableIsNotAvailable`	`ExecutionFailed`	Esse erro ocorre se a variável especificada no elemento `<Source>` da política XML para JSON é do tipo string e o elemento `<OutputVariable>` não é definido. O elemento `<OutputVariable>` é obrigatório quando a variável definida no elemento `<Source>` é do tipo string.
`steps.xmltojson.SourceUnavailable`	`ExecutionFailed`	Esse erro ocorre se a variável message especificada no elemento `<Source>` da política XML para JSON for: Fora do escopo (não disponível no fluxo específico em que a política está sendo executada) ou Não é possível resolver (não está definida)

Erros na implantação

Esses erros podem ocorrer quando você implanta um proxy que contém esta política.

Nome do erro	Causa	Correção
`EitherOptionOrFormat`	Se um dos elementos `<Options>` ou `<Format>` não for declarado na política XML para JSON, a implantação do proxy da API falhará.
`UnknownFormat`	Se o elemento `<Format>` na política XML para JSON tiver um formato desconhecido definido, a implantação do proxy de API falhará. Os formatos predefinidos incluem: `xml.com`, `yahoo`, `google` e `badgerFish`.

Variáveis de falha

Essas variáveis são definidas quando ocorre um erro de tempo de execução. Para mais informações, consulte O que você precisa saber sobre erros de política.

Variáveis	Onde	Exemplo
`fault.name="fault_name"`	`fault_name` é o nome da falha, conforme listado na tabela Erros de ambiente de execução acima. O nome da falha é a última parte do código de falha.	`fault.name = "SourceUnavailable"`
`xmltojson.policy_name.failed`	`policy_name` é o nome especificado pelo usuário da política que causou a falha.	`xmltojson.XMLtoJSON-1.failed = true`

Exemplo de resposta de erro

Observação: para tratamento de erros, a prática recomendada é interceptar a parte errorcode da resposta de erro. Não confie no texto do faultstring, porque ele pode mudar.

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

Exemplo de regra de falha

<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

JSON para XML: política JSONtoXML