AVRO - Serializzazione tramite parser

È possibile leggere uno schema Avro in un programma generando una classe corrispondente a uno schema o utilizzando la libreria parser. In Avro, i dati vengono sempre archiviati con lo schema corrispondente. Pertanto, possiamo sempre leggere uno schema senza generazione di codice.

Questo capitolo descrive come leggere lo schema by using parsers library e a serialize i dati utilizzando Avro.

Serializzazione utilizzando la libreria dei parser

Per serializzare i dati, dobbiamo leggere lo schema, creare i dati in base allo schema e serializzare lo schema utilizzando l'API Avro. La procedura seguente serializza i dati senza generare alcun codice:

Passo 1

Prima di tutto, leggi lo schema dal file. Per farlo, usaSchema.Parserclasse. Questa classe fornisce metodi per analizzare lo schema in diversi formati.

Istanziare il file Schema.Parser class passando il percorso del file in cui è archiviato lo schema.

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

Passo 2

Crea l'oggetto di GenericRecord interfaccia, istanziando GenericData.Recordclasse come mostrato di seguito. Passa l'oggetto schema creato sopra al suo costruttore.

GenericRecord e1 = new GenericData.Record(schema);

Passaggio 3

Inserisci i valori nello schema usando il put() metodo del GenericData classe.

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

Passaggio 4

Crea un oggetto di DatumWriter interfaccia utilizzando il SpecificDatumWriterclasse. Converte gli oggetti Java in un formato serializzato in memoria. L'esempio seguente crea un'istanzaSpecificDatumWriter oggetto di classe per emp classe -

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

Passaggio 5

Istanziare DataFileWriter per empclasse. Questa classe scrive record serializzati di dati conformi a uno schema, insieme allo schema stesso, in un file. Questa classe richiede ilDatumWriter oggetto, come parametro per il costruttore.

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

Passaggio 6

Apri un nuovo file per memorizzare i dati corrispondenti allo schema specificato utilizzando create()metodo. Questo metodo richiede lo schema e il percorso del file in cui devono essere memorizzati i dati, come parametri.

Nell'esempio riportato di seguito, lo schema viene passato utilizzando getSchema() metodo e il file di dati viene memorizzato nel percorso

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

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

Passaggio 7

Aggiungi tutti i record creati al file utilizzando append( ) metodo come mostrato di seguito.

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

Esempio: serializzazione mediante parser

Il seguente programma completo mostra come serializzare i dati utilizzando i parser:

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”);
   }
}

Sfoglia nella directory in cui è posizionato il codice generato. In questo caso, ahome/Hadoop/Avro_work/without_code_gen.

$ cd home/Hadoop/Avro_work/without_code_gen/

Ora copia e salva il programma sopra nel file denominato Serialize.java. Compilalo ed eseguilo come mostrato di seguito -

$ javac Serialize.java
$ java Serialize

Produzione

data successfully serialized

Se verifichi il percorso fornito nel programma, puoi trovare il file serializzato generato come mostrato di seguito.