Útmutató az Apache Ignite-hez

1. Bemutatkozás

Az Apache Ignite egy nyílt forráskódú memória-központú elosztott platform. Használhatjuk adatbázisként, gyorsítótár-rendszerként vagy a memóriában lévő adatfeldolgozáshoz.

A platform memóriát használ tárolórétegként, ezért lenyűgöző teljesítményarányú. Egyszerűen fogalmazva, ez az egyik leggyorsabb atomi adatfeldolgozó platform, amelyet jelenleg gyártanak.

2. Telepítés és beállítás

Első lépésként tekintse meg az első lépéseket tartalmazó oldalt a kezdeti telepítési és telepítési utasításokért.

A felépítendő alkalmazás Maven-függőségei:

 org.apache.ignite ignite-core $ {ignite.version} org.apache.ignite ignite-indexelés $ {ignite.version} 

meggyullad-mag a projekt egyetlen kötelező függősége. Mivel mi is szeretnénk kölcsönhatásba lépni az SQL-szel, gyújtás-indexelés itt is van. $ {ignite.version} az Apache Ignite legújabb verziója.

Utolsó lépésként elindítjuk az Ignite csomópontot:

A Ignite csomópont indult OK (id = 53c77dea) Topológia pillanatkép [ver = 1, szerverek = 1, kliensek = 0, CPU-k = 4, offheap = 1,2 GB, kupac = 1,0 GB] Adatrégiók konfigurálva: ^ - alapértelmezett [initSize = 256.0 MiB, maxSize = 1,2 GiB, persistenceEnabled = false]

A fenti konzol kimenete azt mutatja, hogy készen állunk az indulásra.

3. Memória építészet

A platform a Durable Memory Architecture-en alapul. Ez lehetővé teszi az adatok tárolását és feldolgozását mind a lemezen, mind a memóriában. A fürt RAM-erőforrásainak hatékony felhasználásával növeli a teljesítményt.

A memóriában és a lemezen lévő adatok bináris ábrázolása megegyezik. Ez azt jelenti, hogy nincs szükség további adatok konvertálására, miközben egyik rétegről a másikra lép.

A tartós memória architektúra fix méretű blokkokra oszlik, amelyeket oldalaknak nevezünk. Az oldalakat a Java kupacon kívül tárolják, és RAM-ban rendezik. Egyedi azonosítóval rendelkezik: FullPageId.

Az oldalak kölcsönhatásba lépnek a memóriával a PageMemory absztrakció.

Segít az oldal elolvasásában, írásában, valamint egy oldalazonosító kiosztásában is. A memóriában az Ignite oldalakat társít a Memória pufferek.

4. Memóriaoldalak

Egy oldal a következő állapotokkal rendelkezhet:

  • Unloaded - nincs oldalpuffer betöltve a memóriába
  • Törlés - az oldalpuffer betöltődik és szinkronizálva van a lemezen lévő adatokkal
  • Durty - az oldalpuffer olyan adatokat tárol, amelyek eltérnek a lemezen tároltaktól
  • Dirty in checkpoint - van egy másik módosítás, mielőtt az első megmarad a lemezen. Itt egy ellenőrző pont indul és PageMemory két memóriapuffert tart minden oldalhoz.

A tartós memória helyileg lefoglal egy ún. Memóriaszegmenst Adat régió. Alapértelmezés szerint a fürt memóriájának 20% -a. A több régió konfigurációja lehetővé teszi a használható adatok memóriában tartását.

A régió maximális kapacitása Memória szegmens. Ez fizikai memória vagy folyamatos bájt tömb.

A memória töredezettségének elkerülése érdekében egyetlen oldalon több kulcsérték-bejegyzés található. Minden új bejegyzés bekerül a legoptimálisabb oldalra. Ha a kulcsérték-pár mérete meghaladja az oldal maximális kapacitását, az Ignite több oldalon tárolja az adatokat. Ugyanez a logika érvényes az adatok frissítésére is.

Az SQL és a cache indexek a B + Fák néven ismert struktúrákban vannak tárolva. A gyorsítótár kulcsok a kulcsértékeik szerint vannak rendezve.

5. Életciklus

Minden Ignite csomópont egyetlen JVM példányon fut. Lehetséges azonban konfigurálni, hogy több Ignite csomópont fusson egyetlen JVM folyamatban.

Menjünk át az életciklus eseménytípusain:

  • BEFORE_NODE_START - az Ignite csomópont indítása előtt
  • AFTER_NODE_START - tüzek közvetlenül az Ignite csomópont elindulása után
  • BEFORE_NODE_STOP - a csomópont leállításának megkezdése előtt
  • AFTER_NODE_STOP - miután az Ignite csomópont leáll

Alapértelmezett Ignite csomópont indításához:

Gyújtás gyújt = gyújtás.indítás ();

Vagy egy konfigurációs fájlból:

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

Abban az esetben, ha jobban ellenőriznünk kell az inicializálási folyamatot, van egy másik módszer is a segítségével LifecycleBean felület:

public class CustomLifecycleBean implementálja a LifecycleBean {@Override public void onLifecycleEvent (LifecycleEventType lifecycleEventType) dobja az IgniteException {if (lifecycleEventType == LifecycleEventType.AFTER_NODE_START) {// ...}}}

Itt használhatjuk az életciklus eseménytípusokat műveletek végrehajtására a csomópont elindulása vagy leállítása előtt vagy után.

Ebből a célból átadjuk a konfigurációs példányt a CustomLifecycleBean a start módszerhez:

IgniteConfiguration configuration = new IgniteConfiguration (); configuration.setLifecycleBeans (új CustomLifecycleBean ()); Ignite ignite = Ignition.start (konfiguráció);

6. Memórián belüli adatrács

Az Ignite data grid egy elosztott kulcsérték-tároló, nagyon ismerős a particionálás HashMap. Vízszintesen méretezett. Ez azt jelenti, hogy több fürtcsomópontot adunk hozzá, több adat tárolódik vagy tárolódik a memóriában.

Jelentős teljesítménynövekedést nyújthat a harmadik féltől származó szoftverekben, például a NoSql, az RDMS adatbázisokban, mint a gyorsítótár további rétegében.

6.1. Gyorsítótár-támogatás

Az adatelérési API a JCache JSR 107 specifikáción alapul.

Példaként hozzunk létre egy gyorsítótárat egy sablonkonfiguráció segítségével:

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

Nézzük meg, mi történik itt további részletekért. Először az Ignite megtalálja azt a memóriaterületet, ahol a gyorsítótár tárolt.

Ezután a B + fa indexoldal a kulcs kivonatkódja alapján található. Ha létezik index, akkor a megfelelő kulcs adatlapja található.

Ha az index NULL, a platform a megadott kulcs használatával létrehozza az új adatbevitelt.

Ezután adjunk hozzá néhányat Munkavállaló tárgyak:

cache.put (1, új alkalmazott (1, "John", igaz)); cache.put (2, új alkalmazott (2, "Anna", hamis)); cache.put (3, új alkalmazott (3, "George", igaz));

A tartós memória ismét megkeresi azt a memóriaterületet, ahová a gyorsítótár tartozik. A gyorsítótár kulcs alapján az indexoldal egy B + fa struktúrában található.

Ha az indexoldal nem létezik, újat kérünk és hozzáadunk a fához.

Ezután egy adatlap kerül hozzárendelésre az index oldalhoz.

Az alkalmazott kiolvasásához a gyorsítótárból csak a kulcsértéket használjuk:

Alkalmazott alkalmazott = cache.get (1);

6.2. Streaming támogatás

A memóriában az adatfolyam egy alternatív megközelítést kínál a lemez- és fájlrendszer alapú adatfeldolgozó alkalmazások számára. A Streaming API több szakaszra osztja a nagy terhelésű adatfolyamot, és továbbítja feldolgozásra.

Módosíthatjuk a példánkat és streamelhetjük az adatokat a fájlból. Először meghatározunk egy adatfolyamot:

IgniteDataStreamer streamer = ignite .dataStreamer (cache.getName ());

Ezután regisztrálhatunk egy adatfolyam transzformátort a befogadott munkavállalók foglalkoztatottként való megjelölésére:

streamer.receiver (StreamTransformer.from ((e, arg) -> {Munkavállaló alkalmazottja = e.getValue (); munkavállaló.setEmployed (igaz); e.setValue (alkalmazott); visszatérő alkalmazott;}));

Utolsó lépésként iterálunk a alkalmazottak.txt fájlsorokat, és konvertálja őket Java objektumokká:

Elérési útvonal = Paths.get (IgniteStream.class.getResource ("alkalmazottak.txt") .toURI ()); Gson gson = új Gson (); Files.lines (elérési út) .forEach (l -> streamer.addData (worker.getId (), gson.fromJson (l, Employee.class)));

A használatával streamer.addData () tegye az alkalmazott tárgyakat a patakba.

7. SQL támogatás

A platform memóriaközpontú, hibatűrő SQL adatbázist biztosít.

Csatlakozhatunk tiszta SQL API-val vagy JDBC-vel. Az SQL szintaxis itt ANSI-99, tehát a lekérdezések, a DML, DDL nyelvi műveletek összes standard összesítési funkciója támogatott.

7.1. JDBC

A praktikusabb működés érdekében hozzunk létre egy alkalmazotti táblázatot, és adjunk hozzá néhány adatot.

Ebből a célból regisztrálunk egy JDBC illesztőprogramot és megnyitunk egy kapcsolatot következő lépésként:

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

A standard DDL parancs segítségével feltöltjük a Munkavállaló asztal:

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

A WITH kulcsszó után beállíthatjuk a gyorsítótár konfigurációs sablonját. Itt használjuk a MÁSOLT. Alapértelmezés szerint a sablon mód VÁLASZTOTT. Az adatok példányszámának megadásához szintén megadhatjuk HÁTTÉREK paraméter itt, amely alapértelmezés szerint 0.

Ezután adjunk hozzá néhány adatot az INSERT DML utasítás használatával:

PreparedStatement sql = conn.prepareStatement ("INSERT INTO Employee (id, név, isEmployed) ÉRTÉKEK (?,?,?)"); sql.setLong (1, 1); sql.setString (2, "James"); sql.setBoolean (3, igaz); sql.executeUpdate (); // add hozzá a többit 

Utána kiválasztjuk a rekordokat:

ResultSet rs = sql.executeQuery ("SELECT e.name, e.isEmployed" + "FROM Employee e" + "WHERE e.isEmployed = TRUE")

7.2. Az Objektumok lekérdezése

Lehetőség van lekérdezés végrehajtására a gyorsítótárban tárolt Java objektumok felett is. Az Ignite a Java objektumot külön SQL rekordként kezeli:

IgniteCache cache = ignite.cache ("baeldungCache"); SqlFieldsQuery sql = new SqlFieldsQuery ("válasszon nevet az Employee-ból, ahol isEmployed = 'true'"); QueryCursor kurzor = cache.query (sql); for (Lista sor: kurzor) {// tegyen valamit a sorral}

8. Összefoglalás

Ebben az oktatóanyagban gyorsan áttekintettük az Apache Ignite projektet. Ez az útmutató rávilágít a platform előnyeire más szimális termékekkel szemben, mint például a teljesítménynövekedés, a tartósság és a könnyű API-k.

Ennek eredményeként megtanultuk, hogyan kell használni az SQL nyelvet és Java API-t az adatok tárolásához, visszakereséséhez, streameléséhez a perzisztencia vagy a memóriában lévő rácson belül.

Szokás szerint a cikk teljes kódja elérhető a GitHubon.