streamalism.org

1. Áttekintés

Az adatok sorosítása az adatok bináris vagy szöveges formátumba konvertálásának technikája. Erre a célra többféle rendszer áll rendelkezésre. Az Apache Avro egyike azon adatszerializációs rendszereknek.

Az Avro egy nyelvtől független, séma-alapú adatszerializációs könyvtár. Sémát használ a szerializáció és a deszerializáció végrehajtására. Ezenkívül az Avro JSON formátumot használ az adatstruktúra meghatározásához, amely erősebbé teszi azt.

Ebben az oktatóanyagban többet fogunk megtudni az Avro beállításáról, a Java API-ról a sorosítás elvégzésére, valamint az Avro összehasonlításáról más adatok sorosítási rendszereivel.

Elsősorban a séma létrehozására összpontosítunk, amely az egész rendszer alapja.

2. Apache Avro

Az Avro egy nyelvtől független sorosítási könyvtár. Ehhez az Avro egy sémát használ, amely az egyik alapkomponens. Azt fájlban tárolja a sémát további adatfeldolgozás céljából.

Az Avro a legalkalmasabb a Big Data feldolgozására. Gyorsabb feldolgozása miatt nagyon népszerű a Hadoop és a Kafka világban.

Az Avro létrehoz egy adatfájlt, ahol metaadat-szakaszában az adatokat a sémával együtt tárolja. Mindenekelőtt gazdag adatstruktúrát biztosít, amely népszerűbbé teszi, mint a többi hasonló megoldás.

Az Avro sorozatszerűsítéséhez az alább említett lépéseket kell követnünk.

3. Probléma megfogalmazás

Kezdjük az úgynevezett osztály meghatározásával AvroHttRequest amelyet a példáinkra fogunk használni. Az osztály primitív és komplex típusú attribútumokat is tartalmaz:

class AvroHttpRequest {private long requestTime; private ClientIdentifier clientIdentifier; private List workerNames; privát Aktív aktív; } 

Itt, requestTime primitív érték. ClientIdentifier egy másik osztály, amely komplex típust képvisel. Nekünk is van Alkalmazott Neve ami megint egy összetett típus. Aktív egy leírás annak leírására, hogy az adott alkalmazottak listája aktív-e vagy sem.

Célunk a AvroHttRequest osztály Apache Avro segítségével.

4. Avro adattípusok

Mielőtt tovább folytatnánk, beszéljük meg az Avro által támogatott adattípusokat.

Az Avro kétféle adatot támogat:

• Primitív típus: Az Avro támogatja az összes primitív típust. A primitív típusú nevet használjuk az adott mező típusának meghatározására. Például egy olyan érték, amely a Húr a sémában {{type ":" string "} néven kell deklarálni
• Komplex típus: Az Avro hatféle komplex típust támogat: rekordok, enumok, tömbök, térképek, szakszervezetek és fixek

Például problémamegállapodásunkban ClientIdentifier egy rekord.

Ebben az esetben a ClientIdentifier kell kinéznie:

{"type": "record", "name": "ClientIdentifier", "namespace": "com.baeldung.avro", "fields": [{"name": "hostName", "type": "string" }, {"name": "ipAddress", "type": "string"}]}

5. Az Avro használata

Először egészítsük ki a szükséges Maven-függőségeket pom.xml fájl.

A következő függőségeket kell felvennünk:

• Apache Avro - magkomponensek
• Fordító - Apache Avro fordítók az Avro IDL és az Avro-specifikus Java APIT-hez
• Eszközök - amely magában foglalja az Apache Avro parancssori eszközöket és segédprogramokat
• Apache Avro Maven beépülő modul a Maven projektekhez

Az oktatóanyaghoz az 1.8.2-es verziót használjuk.

Mindig ajánlott azonban megtalálni a legújabb verziót a Maven Central oldalán:

 org.apache.avro avro-compiler 1.8.2 org.apache.avro avro-maven-plugin 1.8.2 

Maven-függőségek hozzáadása után a következő lépések lesznek:

• Séma létrehozása
• A program sémájának elolvasása
• Adataink sorosítása az Avro segítségével
• Végül törölje az adatok sorosítását

6. Séma létrehozása

Az Avro JSON formátummal írja le a sémáját. Főleg négy attribútum van egy adott Avro-sémához:

• Típus- amely leírja a séma típusát, akár annak komplex típusa, akár primitív értéke
• Névtér- amely leírja a névteret, ahova az adott séma tartozik
• Név - a Séma neve
• Mezők amely az adott sémához tartozó mezőkről mesél. A mezők lehetnek primitívek és összetettek is.

A séma létrehozásának egyik módja a JSON reprezentáció megírása, amint azt az előző szakaszokban láttuk.

Sémát is létrehozhatunk a segítségével SchemaBuilder ami tagadhatatlanul jobb és hatékonyabb módszer a létrehozására.

6.1. SchemaBuilder Hasznosság

Osztály org.apache.avro.SchemaBuilder hasznos a Séma létrehozásához.

Először hozzuk létre a sémát ClientIdentifier:

Séma clientIdentifier = SchemaBuilder.record ("ClientIdentifier") .namespace ("com.baeldung.avro") .fields (). RequiredString ("hostName"). RequiredString ("ipAddress") .endRecord ();

Most használjuk ezt egy avroHttpRequest séma:

Séma avroHttpRequest = SchemaBuilder.record ("AvroHttpRequest") .névtér ("com.baeldung.avro") .fields (). RequiredLong ("requestTime") .name ("clientIdentifier") .type (clientIdentifier) ​​.noDefault (). név ("alkalmazottnév") .type () .array () .items () .stringType () .arrayDefault (null) .name ("aktív") .type () .számlálás ("Aktív") .szimbólumok ("IGEN "," NO ") .noDefault () .endRecord ();

Fontos itt megjegyezni, hogy kijelöltük clientIdentifier mint a clientIdentifier terület. Ebben az esetben, clientIdentifier a típus definiálására ugyanaz a séma, amelyet korábban létrehoztunk.

Később alkalmazhatjuk a Sztring módszer a JSON felépítése Séma.

A sémafájlok mentése az .avsc kiterjesztéssel történik. Mentsük el a létrehozott sémánkat a „Src / main / resources / avroHttpRequest-schema.avsc” fájl.

7. A séma elolvasása

Egy séma olvasása többé-kevésbé kb Avro osztályok létrehozása az adott sémához. Az Avro osztályok létrehozása után felhasználhatjuk őket az objektumok sorosítására és deserializálására.

Az Avro osztályok létrehozásának két módja van:

• Programozatosan generáló Avro osztályok: Az osztályokat a segítségével lehet létrehozni SchemaCompiler. Van néhány API, amelyekkel Java osztályokat generálhatunk. A generációs osztályok kódját megtalálhatjuk a GitHubon.
• Maven használata osztályok előállításához

Van egy maven pluginünk, amely jól végzi a munkát. Be kell építenünk a plugint és futtatnunk mvn tiszta telepítés.

Vegyük hozzá a bővítményt a mi oldalunkhoz pom.xml fájl:

 org.apache.avro avro-maven-plugin $ {avro.version} sémák generál-források séma protokoll idl-protokoll $ {project.basedir} / src / main / resources / $ {project.basedir} / src / main / java / 

8. Serializálás és deserializálás Avróval

Miután befejeztük a séma előállítását, folytassuk a szerializációs rész feltárását.

Az Avro két adatszerializációs formátumot támogat: JSON formátumot és bináris formátumot.

Először a JSON formátumra koncentrálunk, majd megbeszéljük a bináris formátumot.

Mielőtt továbblépnénk, át kell mennünk néhány kulcsfelületen. Az alábbi interfészeket és osztályokat felhasználhatjuk a sorosításhoz:

DatumWriter: Ezt arra kell felhasználnunk, hogy adatokat írjunk egy adott sémára. Használjuk a SpecificDatumWriter a példánkban szereplő megvalósítás azonban DatumWriter van más megvalósítása is. Egyéb megvalósítások GenericDatumWriter, Json.Writer, ProtobufDatumWriter, ReflectDatumWriter, ThriftDatumWriter.

Encoder: A kódolót használják, vagy meghatározzák a formátumot, ahogyan azt korábban említettük. EncoderFactory kétféle kódolót kínál, a bináris kódolót és a JSON kódolót.

DatumReader: Egyetlen interfész a szériamentesítéshez. Ismét több megvalósítást kapott, de használni fogjuk SpecificDatumReader példánkban. Egyéb megvalósítások GenericDatumReader, Json.ObjectReader, Json.Reader, ProtobufDatumReader, ReflectDatumReader, ThriftDatumReader.

Dekóder: A dekódert az adatok szériamentesítése közben használják. Dekódergyár kétféle dekódert kínál: bináris dekódert és JSON dekódert.

Ezután nézzük meg, hogyan történik a sorosítás és a sorosítás megszüntetése az Avro-ban.

8.1. Serializálás

Példát fogunk venni AvroHttpRequest osztály és próbáld meg sorosítani az Avro segítségével.

Először sorosítsuk JSON formátumban:

nyilvános bájt [] serealizeAvroHttpRequestJSON (AvroHttpRequest kérés) {DatumWriter író = új SpecificDatumWriter (AvroHttpRequest.class); bájt [] adatok = új bájt [0]; ByteArrayOutputStream stream = new ByteArrayOutputStream (); Encoder jsonEncoder = null; próbáld ki: {jsonEncoder = EncoderFactory.get (). jsonEncoder (AvroHttpRequest.getClassSchema (), stream); író.írja (kérés, jsonEncoder); jsonEncoder.flush (); adatok = stream.toByteArray (); } catch (IOException e) {logger.error ("Sorosítási hiba:" + e.getMessage ()); } visszatérési adatok; } 

Vessünk egy pillantást a módszer tesztesetére:

@Test public void whenSerialized_UsingJSONEncoder_ObjectGetsSerialized () {byte [] data = serealizer.serealizeAvroHttpRequestJSON (kérés); assertTrue (Objects.nonNull (adatok)); assertTrue (adat.hossz> 0); }

Itt használtuk a jsonEncoder módszer és a séma átadása neki.

Ha bináris kódolót akartunk használni, akkor le kell cserélnünk a jsonEncoder () módszerrel binaryEncoder ():

Kódoló jsonEncoder = EncoderFactory.get (). BinaryEncoder (stream, null);

8.2. Deserializáció

Ehhez a fentieket fogjuk használni DatumReader és Dekóder interfészek.

Ahogy használtuk EncoderFactory hogy egy Kódoló, hasonlóan fogjuk használni DecoderFactory hogy a Dekóder tárgy.

Távolítsuk el az adatok sorosítását JSON formátumban:

public AvroHttpRequest deSerealizeAvroHttpRequestJSON (byte [] adatok) {DatumReader olvasó = new SpecificDatumReader (AvroHttpRequest.class); Dekóder dekóder = null; próbáld ki a {decoder = DecoderFactory.get (). jsonDecoder (AvroHttpRequest.getClassSchema (), új String (adatok)); visszatérő olvasó.olvasott (null, dekóder); } catch (IOException e) {logger.error ("Deserializációs hiba:" + e.getMessage ()); }} 

És lássuk a tesztesetet:

@Test public void whenDeserializeUsingJSONDecoder_thenActualAndExpectedObjectsAreEqual () {byte [] data = serealizer.serealizeAvroHttpRequestJSON (kérés); AvroHttpRequest actualRequest = deSerealizer .deSerealizeAvroHttpRequestJSON (adatok); assertEquals (actualRequest, request); assertTrue (actualRequest.getRequestTime () .equals (request.getRequestTime ())); }

Hasonlóképpen használhatunk egy bináris dekódert is:

Dekóder dekóder = DecoderFactory.get (). BinaryDecoder (adatok, null);

9. Következtetés

Az Apache Avro különösen nagy adatok használata közben hasznos. Az adatok sorosítását bináris és JSON formátumban kínálja, amelyek felhasználási esetek szerint használhatók.

Az Avro sorosítási folyamat gyorsabb, és helytakarékos is. Az Avro nem őrzi a mezők típusát az egyes mezőknél; ehelyett metaadatokat hoz létre egy sémában.

Végül, de nem utolsósorban az Avro nagyszerű kötéssel rendelkezik a programozási nyelvek széles skálájával, ami előnyt biztosít számára.

Mint mindig, a kód megtalálható a GitHubon.