Rövid útmutató az Apache Geode használatához

1. Áttekintés

Az Apache Geode egy elosztott memória-adatrács, amely támogatja a gyorsítótárat és az adatok kiszámítását.

Ebben az oktatóanyagban bemutatjuk a Geode legfontosabb fogalmait, és néhány kódmintát futtatunk a Java kliens segítségével.

2. Beállítás

Először le kell töltenünk és telepítenünk kell az Apache Geode-ot, és be kell állítanunk a gfsh környezet. Ehhez követhetjük a Geode hivatalos útmutatójában található utasításokat.

Másodszor, ez az oktatóanyag létrehoz néhány fájlrendszer-mellékterméket. Tehát elkülöníthetjük őket egy ideiglenes könyvtár létrehozásával és a dolgok onnan történő elindításával.

2.1. Telepítés és konfigurálás

Az ideiglenes könyvtárunkból el kell indítanunk a Helykereső példa:

gfsh> start locator - név = locator --bind-address = localhost

Helymeghatározók felelősek a Geode különböző tagjai közötti koordinációért Fürt, amelyet tovább kezelhetünk a JMX-en keresztül.

Ezután kezdjük a szerver például egy vagy több adat tárolására Vidéks:

gfsh> szerver indítása - név = kiszolgáló1 - kiszolgáló-port = 0

Beállítottuk a -szerver port opció 0-ra, így a Geode kiválasztja az elérhető portokat. Bár ha kihagyjuk, a szerver az alapértelmezett 40404 portot fogja használni. A szerver a. Konfigurálható tagja Fürt amely hosszú életű folyamatként fut és felelős az adatok kezeléséért Régiók.

És végül szükségünk van egy Vidék:

gfsh> region létrehozása --name = baeldung --type = REPLICATE

A Vidék végső soron ott tároljuk adatainkat.

2.2. Igazolás

Gondoskodjunk arról, hogy minden működjön, mielőtt tovább megyünk.

Először ellenőrizzük, hogy megvan-e a miénk szerver és a mi Helykereső:

gfsh> lista tagjai Név | Id ------- | -------------------------------------------------- -------- szerver1 | 192.168.0.105 (szerver1: 6119): 1024 lokátor | 127.0.0.1 (lokátor: 5996: lokátor): 1024 [Koordinátor]

És ezután, hogy megvan a miénk Vidék:

gfsh> régió leírása - név = baeldung ......................................... ................. Név: baeldung Adatpolitika: a hosting tagok megismétlése: server1 Nem alapértelmezett attribútumok, amelyeket a hosting tagok osztanak meg | Név | Érték ------ | ----------- | --------------- Régió | adatpolitika | REPLICATE | méret | 0 | hatály | osztott-ack

Ezenkívül rendelkeznünk kell néhány könyvtárral a fájlrendszerben az ideiglenes könyvtárunk alatt, „locator” és „server1” néven.

Ezzel a kimenettel tudjuk, hogy készek vagyunk továbblépni.

3. Maven-függőség

Most, hogy van egy futó Geode, kezdjük el vizsgálni az ügyfél kódját.

Ahhoz, hogy a Geode-tal Java-kódunkban dolgozzunk, hozzá kell adnunk az Apache Geode Java kliens könyvtárat a könyvtárunkhoz pom:

 org.apache.geode geode-core 1.6.0 

Kezdjük azzal, hogy egyszerűen tárolunk és visszakeresünk néhány adatot néhány régióban.

4. Egyszerű tárolás és visszakeresés

Bemutassuk, hogyan kell tárolni az egyes értékeket, az értékek kötegeit és az egyedi objektumokat.

Az adatok „baeldung” régiónkban történő tárolásának megkezdéséhez csatlakozzunk hozzájuk a lokátor segítségével:

@A nyilvános void connect () előtt {this.cache = new ClientCacheFactory () .addPoolLocator ("localhost", 10334) .create (); this.region = gyorsítótár. createClientRegionFactory (ClientRegionShortcut.CACHING_PROXY) .create ("baeldung"); }

4.1. Egyetlen értékek mentése

Most egyszerűen tárolhatunk és visszakereshetünk adatokat régiónkban:

@Test public void whenSendMessageToRegion_thenMessageSavedSuccessfully () {this.region.put ("A", "Hello"); this.region.put ("B", "Baeldung"); assertEquals ("Hello", region.get ("A")); assertEquals ("Baeldung", region.get ("B")); }

4.2. Több érték mentése egyszerre

Több értéket is elmenthetünk egyszerre, például, ha megpróbáljuk csökkenteni a hálózati késést:

@Test public void whenPutMultipleValuesAtOnce_thenValuesSavedSuccessfully () {Beszállító kulcsok = () -> Stream.of ("A", "B", "C", "D", "E"); Térképértékek = keys.get () .collect (Collectors.toMap (Function.identity (), String :: toLowerCase)); this.region.putAll (értékek); keys.get () .forEach (k -> assertEquals (k.toLowerCase (), this.region.get (k))); }

4.3. Egyéni objektumok mentése

A karakterláncok hasznosak, de előbb-utóbb egyedi objektumokat kell tárolnunk.

Képzeljük el, hogy van egy ügyfélrekordunk, amelyet a következő kulcstípus használatával szeretnénk tárolni:

public class A CustomerKey végrehajtja a Serializable {private long id; privát String ország; // getters and setters // egyenlő és hashcode}

És a következő értéktípus:

public class Ügyfél végrehajtja a Serializable {private CustomerKey kulcsot; privát karakterlánc keresztnév; privát karakterlánc vezetéknév; magán Egész életkor; // szerelők és beállítók}

Néhány további lépés van ezek tárolásához:

Első, végre kellene hajtaniuk Sorosítható. Bár ez nem szigorú követelmény, azáltal, hogy ezeket megteszi Serializálható, A Geode robusztusabban tudja tárolni őket.

Második, nekik kell lenniük az alkalmazásunk osztályútvonalán, valamint a Geode osztályvonalán szerver.

Ha el akarjuk jutni a kiszolgáló osztályútvonalára, csomagoljuk össze őket, mondjuk használjuk mvn tiszta csomag.

És akkor hivatkozhatunk a kapott korsóra egy új indítsa el a szervert parancs:

gfsh> kiszolgáló leállítása - név = kiszolgáló1 gfsh> szerver indítása - név = kiszolgáló1 - osztályútvonal = .. / lib / apache-geode-1.0-SNAPSHOT.jar - kiszolgáló-port = 0

Ismét futtatnunk kell ezeket a parancsokat az ideiglenes könyvtárból.

Végül hozzunk létre egy újat Vidék nevű „baeldung-ügyfelek” a szerver ugyanazzal a paranccsal, amelyet a „baeldung” régió létrehozásához használtunk:

gfsh> region létrehozása --name = baeldung-customers --type = REPLICATE

A kódban megkeressük a helymeghatározót, mint korábban, megadva az egyéni típust:

@ Mielőtt nyilvános void connect () {// ... csatlakozzon a lokátoron keresztül this.customerRegion = this.cache. createClientRegionFactory (ClientRegionShortcut.CACHING_PROXY) .create ("baeldung-customers"); }

Ezután tárolhatjuk vásárlóinkat, mint korábban:

@Test public void whenPutCustomKey_thenValuesSavedSuccessfully () {CustomerKey kulcs = new CustomerKey (123); Ügyfél vevő = új ügyfél (kulcs, "William", "Russell", 35); this.customerRegion.put (kulcs, ügyfél); Ügyfél tároltCustomer = this.customerRegion.get (kulcs); assertEquals ("William", tároltCustomer.getFirstName ()); assertEquals ("Russell", tároltCustomer.getLastName ()); }

5. Régiótípusok

A legtöbb környezetben régiónknak több példánya vagy több partíciója lesz, az olvasási és írási átviteli követelményektől függően.

Eddig memóriában replikált régiókat használtunk. Nézzük meg közelebbről.

5.1. Replikált régió

Ahogy a neve is sugallja, a Replikált régió nem egynél tartja fenn adatainak másolatait szerver. Teszteljük ezt.

Tól gfsh konzolt a munka könyvtárban, adjunk hozzá még egyet szerver nevezett szerver2 a klaszterhez:

gfsh> szerver indítása - név = kiszolgáló2 - osztálypálya = .. / lib / apache-geode-1.0-SNAPSHOT.jar --kiszolgáló-port = 0

Ne feledje, hogy amikor „baeldung” -ot készítettünk, akkor használtuk –Type = REPLIKÁL. Emiatt, A Geode automatikusan replikálja adatainkat az új szerverre.

Ellenőrizzük ezt megállással szerver1:

gfsh> állítsa le a kiszolgálót - név = szerver1

És akkor hajtsunk végre egy gyors lekérdezést a „baeldung” régióról.

Ha az adatokat sikeresen replikáltuk, akkor visszakapjuk az eredményeket:

gfsh> query --query = 'válassza ki az e.key-t a /baeldung.entries e' menüből: Eredmény: true Limit: 100 sor: 5 eredmény ------ C B A E D

Úgy tűnik, hogy a replikáció sikerült!

Replika hozzáadása régiónkhoz javítja az adatok elérhetőségét. És mivel egynél több szerver válaszolhat a lekérdezésekre, nagyobb olvasási teljesítményt is kapunk.

De, mi van, ha mindketten lezuhannak? Mivel ezek memóriában lévő régiók, az adatok elvesznek.Ehhez inkább felhasználhatjuk –Típus = REPLICATE_PERSISTENT amely replikálás közben az adatokat is lemezen tárolja.

5.2. Particionált régió

Nagyobb adathalmazokkal jobban méretezhetjük a rendszert, ha úgy konfiguráljuk a Geode-ot, hogy egy régiót külön partíciókra vagy vödrökre bontson.

Hozzunk létre egy partíciót Vidék „baeldung-partitioned” néven:

gfsh> régió létrehozása --name = baeldung-partitioned --type = PARTITION

Adjon hozzá néhány adatot:

gfsh> put --region = baeldung-partitioned --key = "1" --value = "one" gfsh> put --region = baeldung-partitioned --key = "2" --value = "two" gfsh> put --region = baeldung-partitioned --key = "3" --value = "three"

És gyorsan ellenőrizze:

gfsh> lekérdezés --query = 'válasszon e.kulcsot, e.értéket a /baeldung-partitioned.entries e'ből Eredmény: igaz Korlát: 100 Sor: 3 kulcs | érték --- | ----- 2 | kettő 1 | egy 3 | három

Ezután állítsuk le az adatok particionálásának ellenőrzéséhez szerver1 újra, és kérdezze újra:

gfsh> stop server --name = server1 gfsh> query --query = 'select e.key, e.value from /baeldung-partitioned.entries e' Eredmény: true Korlát: 100 Sor: 1 kulcs | érték --- | ----- 2 | kettő

Ezúttal csak néhány adatbevitelt kaptunk vissza, mert a kiszolgálónak csak egy partíciója van az adatoknak, tehát mikor szerver1 esett, adatai elvesztek.

De mi van, ha egyszerre van szükségünk particionálásra és redundanciára? A Geode számos más típust is támogat. A következő három hasznos:

  • PARTITION_REDUNDANT partíciók és megismétli adatainkat a fürt különböző tagjai között
  • PARTITION_PERSISTENT particionálja az adatokat, mint FELOSZTÁS, hanem lemezre, és
  • PARTITION_REDUNDANT_PERSISTENT mindhárom viselkedést megadja nekünk.

6. Objektumlekérdezés nyelve

A Geode támogatja az Object Query Language-t, vagyis az OQL-t is, amely erősebb lehet, mint egy egyszerű kulcskeresés. Kicsit olyan, mint az SQL.

Ehhez a példához használjuk a korábban épített „baeldung-customer” régiót.

Ha hozzáadunk még pár ügyfelet:

Térképadatok = új HashMap (); data.put (új CustomerKey (1), új Customer ("Gheorge", "Manuc", 36)); data.put (új CustomerKey (2), új Customer ("Allan", "McDowell", 43)); this.customerRegion.putAll (adatok);

Akkor használhatjuk QueryService „Allan” keresztnevű ügyfelek keresése:

QueryService queryService = this.cache.getQueryService (); Karakterlánc lekérdezés = "select * from / baeldung-customers c where c.firstName = 'Allan'"; SelectResults results = (SelectResults) queryService.newQuery (query) .execute (); assertEquals (1, results.size ());

7. Funkció

A memóriában lévő adatrácsok egyik legerőteljesebb elképzelése az a gondolat, hogy „a számításokat az adatokhoz vigyék”.

Egyszerűen fogalmazva, mivel a Geode tiszta Java, nekünk könnyű nemcsak adatokat küldenünk, hanem logikailag is elvégezhetjük ezeket az adatokat.

Ez emlékeztethet minket az olyan SQL kiterjesztések ötletére, mint a PL-SQL vagy a Transact-SQL.

7.1. Funkció meghatározása

A Geode elvégzendő munkaegységének meghatározásáhozmegvalósítjuk a Geode-okat Funkció felület.

Képzeljük el például, hogy az ügyfél összes nevét nagybetűre kell cserélnünk.

Az adatok lekérdezése és az alkalmazásunk elvégzése helyett egyszerűen megvalósíthatjuk Funkció:

public class UpperCaseNames végrehajtja a Function {@Override public void execute (FunctionContext context) {RegionFunctionContext regionContext = (RegionFunctionContext) kontextust; Region region = regionContext.getDataSet (); for (Map.Entry bejegyzés: region.entrySet ()) {Ügyfél ügyfél = entry.getValue (); customer.setFirstName (customer.getFirstName (). toUpperCase ()); } context.getResultSender (). lastResult (true); } @Orride public String getId () {return getClass (). GetName (); }}

Vegye figyelembe, hogy getId egyedi értéket kell adnia, így az osztály neve általában jó választás.

A FunctionContext tartalmazza az összes régiónk adatait, és így kifinomultabb lekérdezést is megtehetünk belőle, vagy ahogy itt tettük, mutáljuk is.

És Funkció ennél sokkal több energiával rendelkezik, ezért nézze meg a hivatalos kézikönyvet, különösen a getResultSender módszer.

7.2. Telepítési funkció

Tudatosítanunk kell a Geode funkcióját, hogy futtatni tudjuk azt. Akárcsak az egyedi adattípusainkkal, úgy mi is becsomagoljuk az üveget.

De ezúttal csak a bevetni parancs:

gfsh> telepítés --jar =. / lib / apache-geode-1.0-SNAPSHOT.jar

7.3. Funkció végrehajtása

Most végre tudjuk hajtani a Funkció az alkalmazásból a FunkcióSzolgáltatás:

@Test public void whenExecuteUppercaseNames_thenCustomerNamesAreUppercased () {Végrehajtás végrehajtása = FunctionService.onRegion (this.customerRegion); végrehajtás.execute (UpperCaseNames.class.getName ()); Ügyfél ügyfél = this.customerRegion.get (új CustomerKey (1)); assertEquals ("GHEORGE", customer.getFirstName ()); }

8. Következtetés

Ebben a cikkben megismertük a Apache Geode ökoszisztéma. Megnéztük az egyszerű lekérdezéseket standard és egyedi típusokkal, replikált és particionált régiókkal, valamint az oql és a függvények támogatásával.

És mint mindig, ezek a minták elérhetők a GitHubon.