Transformação e Validação de Dados

CSV

Descrição: o componente CSV é utilizado para ler e escrever dados no formato CSV (Comma-Separated Values). Ele facilita a manipulação de arquivos CSV, permitindo conversões e transformações de dados de forma eficiente.

CSV para JSON

Exemplo
- A rota é acionada quando uma requisição POST é feita para o endpoint /csv-to-json.
- Os dados no corpo da requisição, no formato CSV, são desserializados (unmarshal) em mapas (useMaps: true) utilizando o delimitador definido (delimiter: ",").
- Esses mapas são transformados em JSON e retornados como resposta.

Script

Diagrama

- from:
    uri: "rest:POST:/csv-to-json"
    steps:
    - unmarshal:
        csv:
          delimiter: ","
          useMaps: true
    - marshal:
        json: {}

JSON para CSV

Exemplo
- O fluxo começa com uma requisição POST para o endpoint /json-to-csv com dados no formato JSON.
- O JSON recebido é convertido (unmarshal) para uma estrutura interna manipulável (mapas).
- Os dados processados são convertidos para o formato CSV (marshal).
  - Adicionalmente, o delimitador ; (ponto e vírgula) é usado para separar valores e
  - Os cabeçahos firstName e lastName são adicionados.

Script

Diagrama

- from:
    uri: "rest:POST:/json-to-csv"
    steps:
    - unmarshal:
        json: {}
    - marshal:
        csv:
          delimiter: ";"
          header:
          - firstName
          - lastName

Veja mais informações sobre Data Format como um componente Camel.

JOLT

Descrição: o componente JOLT permite transformar e manipular dados JSON de forma declarativa, utilizando especificações definidas em arquivos JOLT.
Exemplo
- O fluxo começa com uma requisição POST no endpoint /jolt-poc.
- O corpo da requisição é registrado nos logs.
- O fluxo transforma o corpo da requisição usando um template Jolt localizado no arquivo template.json.
  - Os parâmetros inputType: JsonString e outputType: JsonString garantem que a entrada e a saída sejam manipuladas como strings JSON.
  - contentCache: true permite cache dos resultados.
- Por fim, o fluxo registra o resultado da transformação nos logs.

Script

Diagrama

- from:
    uri: "rest:post:/jolt-poc"
    steps:
        - log:
            message: "Got body: ${body}"
        - to:
            uri: "jolt:template.json"
            parameters:
                inputType: JsonString
                outputType: JsonString
                contentCache: true
        - log:
            message: "Result: ${body}"

JSLT

Descrição: o componente JSLT é utilizado para transformar dados usando templates escritos em JSLT. Ele processa informações de entrada, como JSON ou XML, reorganizando e formatando-as de acordo com um modelo que você define.
Exemplo
- O fluxo começa com uma requisição POST no endpoint /hello.
- Os dados da requisição são transformados por meio do componente JSLT usando o arquivo de template expression.jslt.
  - O parâmetro contentCache=true habilita o cache do conteúdo do template.
- Por fim, a mensagem transformada é registrada no log de nível info.

Script

Diagrama

- from:
    uri: "rest:post:/hello"
    steps:
    - to:
        uri: "jslt:classpath:expression.jslt"
        parameters:
          contentCache: true
    - to:
        uri: "log:info"

JSONata

Descrição: o componente JSONata permite processar e transformar dados JSON utilizando a linguagem de consulta JSONata. Ele possibilita a realização de operações complexas, como filtragem, transformação e agregação de dados.
Exemplo
- O fluxo começa com uma requisição POST no endpoint /jsonata.
- Depois, o conteúdo da requisição é transformado usando uma expressão JSONata armazenada no arquivo expression.jsonata.
- Os parâmetros indicam que:
  - os resultados da transformação podem ser armazenados em cache (contentCache: true);
  - o tipo de entrada para a transformação é uma string JSON (inputType: JsonString) ;
  - o tipo de saída também será uma string JSON (outputType: JsonString).
- Depois, os dados são enviados a um endpoint externo via requisição POST.

Script

Diagrama

- from:
      uri: rest:post:/jsonata
      steps:
        - to:
            uri: jsonata:classpath:expression.jsonata
            parameters:
              contentCache: true
              inputType: JsonString
              outputType: JsonString
        - to:
            uri: https://enzcomwvg2nng.x.pipedream.net
            parameters:
              bridgeEndpoint: true
              httpMethod: POST

JSON Schema Validator

Descrição: o componente JSON Schema Validator realiza validação de bean do corpo da mensagem.
Exemplo
- O fluxo começa quando uma requisição POST é recebida no endpoint /hello.
- Depois o componente de validação JSON é usado para verificar se o corpo da requisição corresponde ao esquema definido no arquivo my-json-schema.json.

Script

Diagrama

- from:
    uri: "rest:post:/hello"
    steps:
       - to:
           uri: "json-validator:file:/etc/camel/resources/sensedia-integration-camel-poc-configmap/my-json-schema.json"

XJ

Descrição: o componente XJ permite converter documentos XML e JSON sem a necessidade de objetos Java intermediários.
Exemplo
- O fluxo começa ao receber uma requisição POST no endpoint /example-xj.
- Faz uma chamada GET via HTTPS.
- Transforma a resposta XML recebida em JSON usando o componente XSLT.
  - O parâmetro transformDirection: XML2JSON indica a direção da transformação, que neste caso é de XML para JSON.
- Converte o JSON em um objeto Java.
- Por fim, define o cabeçalho Content-Type como application/json para indicar o tipo da resposta.

Script

Diagrama

- from:
    uri: "rest:post:/example-xj"
    steps:
    - toD:
        uri: "https://httpbin.org/xml"
        parameters:
          bridgeEndpoint: true
          httpMethod: GET

    - to:
        uri: "xj:classpath:response_to_json.xslt"
        parameters:
          transformDirection: XML2JSON

    - unmarshal:
        json: {}

    - set-header:
        name: "Content-Type"
        constant: "application/json"

XSLT

Descrição: o componente XSLT é utilizado para transformar documentos XML usando uma folha de estilo XSLT, permitindo que os dados sejam convertidos para diferentes formatos ou estruturas.
Exemplo
- O fluxo começa com uma requisição POST no endpoint /source-xslt.
- O EIP toD indica que o fluxo deve direcionar a execução para uma URI dinâmica.
- A rota então faz uma requisição GET, obtendo uma resposta em XML.
- Depois, transforma a resposta XML em JSON utilizando um arquivo XSLT: response_to_json.xslt.

Script

Diagrama

- from:
    uri: "rest:post:/source-xslt"
    steps:
      - toD:
          uri: "https://httpbin.org/xml"
          parameters:
            bridgeEndpoint: true
            httpMethod: GET
      - to:
          uri: "xslt:classpath:response_to_json.xslt"

Thanks for your feedback!

EDIT

Share your suggestions with us!
Click here and then [+ Submit idea]