AVRO - Serialisierung mit Parsern

Man kann ein Avro-Schema in ein Programm einlesen, indem man entweder eine Klasse generiert, die einem Schema entspricht, oder indem man die Parser-Bibliothek verwendet. In Avro werden Daten immer mit dem entsprechenden Schema gespeichert. Daher können wir ein Schema immer ohne Codegenerierung lesen.

In diesem Kapitel wird das Lesen des Schemas beschrieben by using parsers library und zu serialize die Daten mit Avro.

Serialisierung mit Parsers Library

Um die Daten zu serialisieren, müssen wir das Schema lesen, Daten gemäß dem Schema erstellen und das Schema mithilfe der Avro-API serialisieren. Das folgende Verfahren serialisiert die Daten, ohne Code zu generieren:

Schritt 1

Lesen Sie zunächst das Schema aus der Datei. Verwenden Sie dazuSchema.ParserKlasse. Diese Klasse bietet Methoden zum Parsen des Schemas in verschiedenen Formaten.

Instanziieren Sie die Schema.Parser Klasse durch Übergeben des Dateipfads, in dem das Schema gespeichert ist.

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

Schritt 2

Erstellen Sie das Objekt von GenericRecord Schnittstelle durch Instanziierung GenericData.RecordKlasse wie unten gezeigt. Übergeben Sie das oben erstellte Schemaobjekt an seinen Konstruktor.

GenericRecord e1 = new GenericData.Record(schema);

Schritt 3

Fügen Sie die Werte mit dem in das Schema ein put() Methode der GenericData Klasse.

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

Schritt 4

Erstellen Sie ein Objekt von DatumWriter Schnittstelle mit der SpecificDatumWriterKlasse. Es konvertiert Java-Objekte in das speicherinterne serialisierte Format. Das folgende Beispiel instanziiertSpecificDatumWriter Klassenobjekt für emp Klasse -

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

Schritt 5

Instanziieren DataFileWriter zum empKlasse. Diese Klasse schreibt serialisierte Datensätze von Daten, die einem Schema entsprechen, zusammen mit dem Schema selbst in eine Datei. Diese Klasse erfordert dieDatumWriter Objekt als Parameter für den Konstruktor.

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

Schritt 6

Öffnen Sie eine neue Datei, um die Daten zu speichern, die mit dem angegebenen Schema übereinstimmen create()Methode. Diese Methode erfordert das Schema und den Pfad der Datei, in der die Daten gespeichert werden sollen, als Parameter.

Im folgenden Beispiel wird das Schema mit übergeben getSchema() Methode und die Datendatei wird im Pfad gespeichert

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

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

Schritt 7

Fügen Sie der Datei alle erstellten Datensätze mit hinzu append( ) Methode wie unten gezeigt.

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

Beispiel - Serialisierung mit Parsern

Das folgende vollständige Programm zeigt, wie die Daten mithilfe von Parsern serialisiert werden:

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

Navigieren Sie in das Verzeichnis, in dem sich der generierte Code befindet. In diesem Fall beihome/Hadoop/Avro_work/without_code_gen.

$ cd home/Hadoop/Avro_work/without_code_gen/

Kopieren Sie nun das obige Programm und speichern Sie es in der genannten Datei Serialize.java. Kompilieren Sie es und führen Sie es wie unten gezeigt aus -

$ javac Serialize.java
$ java Serialize

Ausgabe

data successfully serialized

Wenn Sie den im Programm angegebenen Pfad überprüfen, finden Sie die generierte serialisierte Datei wie unten gezeigt.