streamalism.org

1. Introduksjon

Apache Ignite er en åpen kildekode minnesentrert distribuert plattform. Vi kan bruke den som en database, et caching-system eller for databehandling i minnet.

Plattformen bruker minne som lagringslag, og har derfor imponerende ytelsesrate. For å si det enkelt, dette er en av de raskeste atombehandlingsplattformene som for tiden er i produksjonsbruk.

2. Installasjon og oppsett

Som en begynnelse, sjekk ut i gang-siden for den første installasjons- og installasjonsinstruksjonen.

Maven-avhengighetene for applikasjonen vi skal bygge:

 org.apache.ignite ignite-core $ {ignite.version} org.apache.ignite ignite-indeksering $ {ignite.version} 

antennekjerne er den eneste obligatoriske avhengigheten for prosjektet. Som vi også vil samhandle med SQL, antenne-indeksering er også her. $ {ignite.version} er den siste versjonen av Apache Ignite.

Som det siste trinnet starter vi Ignite-noden:

Ignite node start OK (id = 53c77dea) Topology snapshot [ver = 1, servers = 1, clients = 0, CPUs = 4, offheap = 1.2GB, heap = 1.0GB] Dataregioner konfigurert: ^ - standard [initSize = 256.0 MiB, maxSize = 1.2 GiB, persistenceEnabled = false]

Konsollutgangen ovenfor viser at vi er klare til å gå.

3. Minne Arkitektur

Plattformen er basert på Durable Memory Architecture. Dette gjør det mulig å lagre og behandle dataene både på disken og i minnet. Det øker ytelsen ved å bruke klyngens RAM-ressurser effektivt.

Dataene i minnet og på disken har samme binære representasjon. Dette betyr ingen ekstra konvertering av dataene mens du flytter fra ett lag til et annet.

Holdbar minnearkitektur deler seg i blokker i fast størrelse som kalles sider. Sider lagres utenfor Java-bunken og organiseres i RAM. Den har en unik identifikator: FullPageId.

Sider samhandler med minnet ved hjelp av PageMemory abstraksjon.

Det hjelper å lese, skrive en side, og også tildele en side-ID. Inne i minnet forbinder Ignite sider med Minne buffere.

4. Minne sider

En side kan ha følgende tilstander:

• Ulastet - ingen sidebuffer er lastet i minnet
• Tøm - sidebufferen lastes inn og synkroniseres med dataene på disken
• Durty - sidebufferen inneholder data som er forskjellig fra disken
• Skittent i kontrollpunktet - det er en ny modifisering starter før den første fortsetter til disk. Her starter et sjekkpunkt og PageMemory holder to minnebuffere for hver side.

Holdbart minne tildeler lokalt et minnesegment som kalles Dataregion. Som standard har den en kapasitet på 20% av klyngeminnet. Konfigurering av flere regioner gjør det mulig å holde de brukbare dataene i et minne.

Maksimum kapasitet i regionen er et minnesegment. Det er et fysisk minne eller et kontinuerlig byte-utvalg.

For å unngå minnefragmenteringer inneholder en enkelt side flere nøkkelverdier. Hver nye oppføring vil bli lagt til den mest optimale siden. Hvis nøkkelverdiparstørrelsen overstiger den maksimale kapasiteten til siden, lagrer Ignite dataene på mer enn én side. Den samme logikken gjelder oppdatering av dataene.

SQL- og cacheindekser er lagret i strukturer kjent som B + Trees. Cache-nøkler er ordnet etter nøkkelverdiene.

5. Livssyklus

Hver Ignite-node kjører på en enkelt JVM-forekomst. Det er imidlertid mulig å konfigurere slik at flere Ignite-noder kjører i en enkelt JVM-prosess.

La oss gå gjennom livssyklushendelsestypene:

• BEFORE_NODE_START - før oppstart av tenningen
• AFTER_NODE_START - branner like etter start av tenningen
• BEFORE_NODE_STOP - før du starter nodestoppet
• AFTER_NODE_STOP - etter at Ignite-noden stopper

Slik starter du en standard tenningsnode:

Ignite ignite = Ignition.start ();

Eller fra en konfigurasjonsfil:

Ignite ignite = Ignition.start ("config / example-cache.xml");

I tilfelle vi trenger mer kontroll over initialiseringsprosessen, er det en annen måte ved hjelp av LifecycleBean grensesnitt:

offentlig klasse CustomLifecycleBean implementerer LifecycleBean {@Override public void onLifecycleEvent (LifecycleEventType lifecycleEventType) kaster IgniteException {if (lifecycleEventType == LifecycleEventType.AFTER_NODE_START) {// ...}}}

Her kan vi bruke livssyklushendelsestypene til å utføre handlinger før eller etter at noden starter / stopper.

For det formålet sender vi konfigurasjonsforekomsten med CustomLifecycleBean til startmetoden:

IgniteConfiguration konfigurasjon = ny IgniteConfiguration (); configuration.setLifecycleBeans (ny CustomLifecycleBean ()); Ignite ignite = Ignition.start (konfigurasjon);

6. Datanett i minnet

Ignite data grid er en distribuert nøkkelverdilagring, veldig kjent for partisjonert HashMap. Det er horisontalt skalert. Dette betyr at flere klyngenoder vi legger til, flere data blir lagret i minnet.

Det kan gi betydelig ytelsesforbedring til tredjepartsprogramvaren, som NoSql, RDMS-databaser som et ekstra lag for hurtigbufring.

6.1. Cache-støtte

API-et for datatilgang er basert på JCache JSR 107-spesifikasjonen.

Som et eksempel, la oss lage en cache ved hjelp av en malkonfigurasjon:

IgniteCache cache = ignite.getOrCreateCache ("baeldingCache");

La oss se hva som skjer her for mer informasjon. Først finner Ignite minneområdet der hurtigbufferen er lagret.

Deretter vil B + treindeks siden være lokalisert basert på nøkkel hash-koden. Hvis indeksen eksisterer, vil en dataside for den tilsvarende nøkkelen bli lokalisert.

Når indeksen er NULL, oppretter plattformen den nye dataoppføringen ved å bruke den gitte nøkkelen.

La oss deretter legge til noen Ansatt gjenstander:

cache.put (1, ny ansatt (1, "John", sant)); cache.put (2, ny ansatt (2, "Anna", falsk)); cache.put (3, ny ansatt (3, "George", sant));

Igjen vil det holdbare minnet se etter minneområdet der cachen hører hjemme. Basert på hurtignøkkelen vil indeksiden være plassert i en B + trestruktur.

Når indeksiden ikke eksisterer, blir det bedt om en ny og lagt til i treet.

Deretter tilordnes en dataside til indeksiden.

For å lese den ansatte fra hurtigbufferen bruker vi bare nøkkelverdien:

Ansatt ansatt = cache.get (1);

6.2. Streaming-støtte

I minnet gir datastreaming en alternativ tilnærming for disk- og filsystembaserte databehandlingsapplikasjoner. Streaming API deler datastrømmen med høy belastning i flere trinn og ruter dem for behandling.

Vi kan endre eksemplet vårt og streame dataene fra filen. Først definerer vi en datastreamer:

IgniteDataStreamer streamer = antenne. DataStreamer (cache.getName ());

Deretter kan vi registrere en strømtransformator for å markere de mottatte ansatte som ansatt:

streamer.receiver (StreamTransformer.from ((e, arg) -> {Medarbeideransatt = e.getValue (); ansatt.settEn ansatt (sann); e.setValue (ansatt); returmedarbeider;}));

Som et siste trinn, gjentar vi over ansatte.txt fillinjer og konvertere dem til Java-objekter:

Banesti = Paths.get (IgniteStream.class.getResource ("ansatte.txt") .toURI ()); Gson gson = ny Gson (); Files.lines (sti) .forEach (l -> streamer.addData (medarbeider.getId (), gson.fromJson (l, ansatt.klasse)));

Med bruk av streamer.addData () sette de ansatte objektene i strømmen.

7. SQL-støtte

Plattformen tilbyr minnesentrert, feiltolerant SQL-database.

Vi kan koble til enten med ren SQL API eller med JDBC. SQL-syntaks her er ANSI-99, så alle standardaggregasjonsfunksjonene i spørsmålene, DML, DDL-språkoperasjoner støttes.

7.1. JDBC

For å bli mer praktisk, la oss lage en tabell over ansatte og legge til litt data i den.

For den grunnen, registrerer vi en JDBC-driver og åpner en forbindelse som et neste trinn:

Class.forName ("org.apache.ignite.IgniteJdbcThinDriver"); Connection conn = DriverManager.getConnection ("jdbc: antenne: tynn: //127.0.0.1/");

Ved hjelp av standard DDL-kommandoen fyller vi ut Ansatt bord:

sql.executeUpdate ("CREATE TABLE Employee (" + "id LONG PRIMARY KEY, name VARCHAR, isEm Employed tinyint (1))" + "WITH \" template = replicated \ "");

Etter WITH-nøkkelordet kan vi stille cache-konfigurasjonsmalen. Her bruker vi REPLIKERT. Malmodus er som standard DELT. For å spesifisere antall kopier av dataene kan vi også spesifisere SIKKERHETER parameteren her, som er 0 som standard.

La oss deretter legge sammen noen data ved å bruke INSERT DML-setning:

PreparedStatement sql = conn.prepareStatement ("INSERT TO Employee (id, name, isEm Employed) VALUES (?,?,?)"); sql.setLong (1, 1); sql.setString (2, "James"); sql.setBoolean (3, sant); sql.executeUpdate (); // legg til resten 

Etterpå velger vi postene:

ResultSet rs = sql.executeQuery ("SELECT e.name, e.isEm Employed" + "FRA Employee e" + "WHERE e.isEm Employed = TRUE")

7.2. Spør objektene

Det er også mulig å utføre et spørsmål over Java-objekter som er lagret i hurtigbufferen. Ignite behandler Java-objekt som en separat SQL-post:

IgniteCache cache = ignite.cache ("baeldungCache"); SqlFieldsQuery sql = new SqlFieldsQuery ("velg navn fra ansatt der isEmployed = 'true'"); QueryCursor markør = cache.query (sql); for (Liste rad: markør) {// gjør noe med raden}

8. Oppsummering

I denne veiledningen så vi raskt på Apache Ignite-prosjektet. Denne guiden fremhever fordelene med plattformen i forhold til andre lignende produkter som ytelsesgevinster, holdbarhet, lette API-er.

Som et resultat, vi lærte hvordan vi bruker SQL-språket og Java API for å lagre, hente, streame dataene i persistens- eller in-memory-rutenettet.

Som vanlig er den komplette koden for denne artikkelen tilgjengelig på GitHub.