AVRO - Serialización mediante analizadores

Se puede leer un esquema Avro en un programa generando una clase correspondiente a un esquema o utilizando la biblioteca de analizadores. En Avro, los datos siempre se almacenan con su esquema correspondiente. Por lo tanto, siempre podemos leer un esquema sin generar código.

Este capítulo describe cómo leer el esquema by using parsers library y para serialize los datos usando Avro.

Serialización mediante la biblioteca de analizadores

Para serializar los datos, necesitamos leer el esquema, crear datos de acuerdo con el esquema y serializar el esquema usando la API de Avro. El siguiente procedimiento serializa los datos sin generar ningún código:

Paso 1

En primer lugar, lea el esquema del archivo. Para hacerlo, useSchema.Parserclase. Esta clase proporciona métodos para analizar el esquema en diferentes formatos.

Instancia del Schema.Parser class pasando la ruta del archivo donde se almacena el esquema.

Schema schema = new Schema.Parser().parse(new File("/path/to/emp.avsc"));

Paso 2

Crea el objeto de GenericRecord interfaz, instanciando GenericData.Recordclase como se muestra a continuación. Pase el objeto de esquema creado anteriormente a su constructor.

GenericRecord e1 = new GenericData.Record(schema);

Paso 3

Inserte los valores en el esquema usando el put() método del GenericData clase.

e1.put("name", "ramu");
e1.put("id", 001);
e1.put("salary",30000);
e1.put("age", 25);
e1.put("address", "chennai");

Paso 4

Crea un objeto de DatumWriter interfaz usando el SpecificDatumWriterclase. Convierte objetos Java en formato serializado en memoria. El siguiente ejemplo crea una instanciaSpecificDatumWriter objeto de clase para emp clase -

DatumWriter<emp> empDatumWriter = new SpecificDatumWriter<emp>(emp.class);

Paso 5

Instanciar DataFileWriter para empclase. Esta clase escribe registros serializados de datos que se ajustan a un esquema, junto con el propio esquema, en un archivo. Esta clase requiereDatumWriter objeto, como un parámetro para el constructor.

DataFileWriter<emp> dataFileWriter = new DataFileWriter<emp>(empDatumWriter);

Paso 6

Abra un nuevo archivo para almacenar los datos que coinciden con el esquema dado usando create()método. Este método requiere el esquema y la ruta del archivo donde se almacenarán los datos como parámetros.

En el ejemplo que se muestra a continuación, el esquema se pasa usando getSchema() método y el archivo de datos se almacena en la ruta

/home/Hadoop/Avro/serialized_file/emp.avro.

empFileWriter.create(e1.getSchema(), new
File("/home/Hadoop/Avro/serialized_file/emp.avro"));

Paso 7

Agregue todos los registros creados al archivo usando append( ) método como se muestra a continuación.

empFileWriter.append(e1);
empFileWriter.append(e2);
empFileWriter.append(e3);

Ejemplo: serialización mediante analizadores

El siguiente programa completo muestra cómo serializar los datos usando analizadores:

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

import org.apache.avro.Schema;
import org.apache.avro.file.DataFileWriter;

import org.apache.avro.generic.GenericData;
import org.apache.avro.generic.GenericDatumWriter;
import org.apache.avro.generic.GenericRecord;

import org.apache.avro.io.DatumWriter;

public class Seriali {
   public static void main(String args[]) throws IOException{
	
      //Instantiating the Schema.Parser class.
      Schema schema = new Schema.Parser().parse(new File("/home/Hadoop/Avro/schema/emp.avsc"));
		
      //Instantiating the GenericRecord class.
      GenericRecord e1 = new GenericData.Record(schema);
		
      //Insert data according to schema
      e1.put("name", "ramu");
      e1.put("id", 001);
      e1.put("salary",30000);
      e1.put("age", 25);
      e1.put("address", "chenni");
		
      GenericRecord e2 = new GenericData.Record(schema);
		
      e2.put("name", "rahman");
      e2.put("id", 002);
      e2.put("salary", 35000);
      e2.put("age", 30);
      e2.put("address", "Delhi");
		
      DatumWriter<GenericRecord> datumWriter = new GenericDatumWriter<GenericRecord>(schema);
		
      DataFileWriter<GenericRecord> dataFileWriter = new DataFileWriter<GenericRecord>(datumWriter);
      dataFileWriter.create(schema, new File("/home/Hadoop/Avro_work/without_code_gen/mydata.txt"));
		
      dataFileWriter.append(e1);
      dataFileWriter.append(e2);
      dataFileWriter.close();
		
      System.out.println(“data successfully serialized”);
   }
}

Busque en el directorio donde se coloca el código generado. En este caso, enhome/Hadoop/Avro_work/without_code_gen.

$ cd home/Hadoop/Avro_work/without_code_gen/

Ahora copie y guarde el programa anterior en el archivo llamado Serialize.java. Compílelo y ejecútelo como se muestra a continuación:

$ javac Serialize.java
$ java Serialize

Salida

data successfully serialized

Si verifica la ruta proporcionada en el programa, puede encontrar el archivo serializado generado como se muestra a continuación.