[Anderson Paraibano]

Avro: Como Usar Campos Padrão sem Conhecer o Esquema Exato do Escritor em Java, JSON e Avro

Introdução

Ao trabalhar com a biblioteca Avro em Java e lidar com dados serializados em formato JSON, pode haver situações em que você precise lidar com campos ausentes ou desconhecidos no esquema exato usado pelo escritor. Nesses casos, uma abordagem útil é utilizar campos padrão, que permitem definir valores predefinidos para campos que não estão presentes nos dados de entrada. Neste artigo, exploraremos como usar campos padrão em Avro para tratar essa situação e garantir um processamento suave dos dados.

O que é Avro?

Avro é um sistema de serialização de dados desenvolvido pela Apache Software Foundation. Ele permite a descrição de tipos de dados complexos em um esquema, que é armazenado junto com os dados serializados. Essa característica torna o Avro autodescritivo e permite a evolução dos esquemas ao longo do tempo. O Avro suporta vários idiomas de programação, incluindo Java, e é amplamente utilizado em sistemas distribuídos para comunicação eficiente entre diferentes componentes.

Campos Padrão em Avro

Os campos padrão em Avro permitem definir valores predefinidos para campos que não estão presentes nos dados de entrada durante a desserialização. Esses valores são usados quando o escritor não fornece um valor para um campo específico. Isso é útil quando você não possui o conhecimento exato sobre o esquema usado pelo escritor ou quando ocorrem alterações no esquema ao longo do tempo.

Usando Campos Padrão em Avro

Para usar campos padrão em Avro, você precisa definir um valor padrão no esquema do campo. Considere o seguinte exemplo de um esquema Avro em formato JSON:

json
Copy code
{
“type”: “record”,
“name”: “Exemplo”,
“fields”: [
{“name”: “campo1”, “type”: “int”, “default”: 0},
{“name”: “campo2”, “type”: “string”, “default”: “desconhecido”}
]
}
No exemplo acima, definimos dois campos no esquema: “campo1” e “campo2”. O campo1 é do tipo “int” e tem um valor padrão de 0. O campo2 é do tipo “string” e tem um valor padrão de “desconhecido”.

Ao desserializar dados usando esse esquema, se o escritor não fornecer um valor para “campo1”, ele será preenchido com o valor padrão de 0. Da mesma forma, se o escritor não fornecer um valor para “campo2”, ele será preenchido com o valor padrão “desconhecido”.

Implementando em Java

Agora, vamos ver como podemos usar campos padrão em Avro no contexto do Java. Para começar, você precisará das bibliotecas Avro e Avro Maven em seu projeto Java.

Primeiro, defina o esquema em um arquivo JSON ou crie um objeto Schema em seu código Java. Em seguida, utilize o esquema para desserializar os dados Avro usando um GenericDatumReader e um DataFileReader. A classe GenericDatumReader é capaz de ler dados Avro sem conhecer o esquema exato, enquanto o DataFileReader lida com a leitura do arquivo Avro.

Aqui está um exemplo de código Java que demonstra o uso de campos padrão em Avro:

java
Copy code
import org.apache.avro.Schema;
import org.apache.avro.generic.GenericDatumReader;
import org.apache.avro.generic.GenericRecord;
import org.apache.avro.file.DataFileReader;
import org.apache.avro.file.FileReader;

import java.io.File;
import java.io.IOException;

public class ExemploAvro {

public static void main(String[] args) throws IOException {
// Carregando o esquema do arquivo JSON
Schema schema = new Schema.Parser().parse(new File(“exemplo.avsc”));

// Criando um leitor de arquivo Avro
FileReader<GenericRecord> fileReader = DataFileReader.openReader(new File(“dados.avro”), new GenericDatumReader<>(schema));

// Lendo os registros do arquivo
while (fileReader.hasNext()) {
GenericRecord record = fileReader.next();

// Acessando os campos do registro
int campo1 = (int) record.get(“campo1”);
String campo2 = (String) record.get(“campo2”);

// Exibindo os valores dos campos
System.out.println(“Campo1: ” + campo1);
System.out.println(“Campo2: ” + campo2);
}

// Fechando o leitor de arquivo
fileReader.close();
}
}
Nesse exemplo, primeiro carregamos o esquema Avro do arquivo JSON usando Schema.Parser. Em seguida, criamos um FileReader para ler o arquivo Avro e um loop para iterar sobre os registros do arquivo. Usamos record.get(“campo1”) e record.get(“campo2”) para acessar os valores dos campos, e então exibimos os valores na saída.

Conclusão

Usar campos padrão em Avro é uma estratégia útil quando você não tem conhecimento exato do esquema usado pelo escritor ou quando há campos ausentes nos dados de entrada. Neste artigo, vimos como definir campos padrão em um esquema Avro e como usá-los em um programa Java para lidar com campos desconhecidos. Isso permite um processamento suave dos dados, mesmo quando o esquema não é completamente conhecido.

[Autor]

Posts