Útmutató a MapDB-hez

1. Bemutatkozás

Ebben a cikkben megnézzük a MapDB könyvtár - beágyazott adatbázis-motor, amely egy gyűjteményszerű API-n keresztül érhető el.

Kezdjük az alaposztályok feltárásával DB és DBMaker amelyek segítenek az adatbázisunk konfigurálásában, megnyitásában és kezelésében. Ezután bemutatunk néhány példát a MapDB adatstruktúráiról, amelyek adatokat tárolnak és lekérnek.

Végül megvizsgáljuk a memória néhány módját, mielőtt összehasonlítanánk a MapDB-t a hagyományos adatbázisokkal és a Java gyűjteményekkel.

2. Adatok tárolása a MapDB-ben

Először mutassuk be azt a két osztályt, amelyeket folyamatosan fogunk használni ebben az oktatóanyagban - DB és DBMaker. A DB osztály egy nyitott adatbázist jelent. Módszerei az adatbázis-rekordok kezeléséhez, valamint a tranzakciós események kezeléséhez műveleteket hívnak elő a tároló gyűjtemények létrehozására és bezárására.

DBMaker kezeli az adatbázis konfigurálását, létrehozását és megnyitását. A konfiguráció részeként választhatjuk, hogy adatbázisunkat a memóriában vagy a fájlrendszerünkön tároljuk.

2.1. Egy egyszerű HashMap Példa

Hogy megértsük ennek működését, példányosítsunk egy új adatbázist a memóriában.

Először hozzunk létre egy új memóriában lévő adatbázist a DBMaker osztály:

DB db = DBMaker.memoryDB (). Make ();

Egyszer a mi DB az objektum működik, használhatjuk egy HTreeMap az adatbázis-nyilvántartásainkkal való munka:

String welcomeMessageKey = "Üdvözlő üzenet"; String welcomeMessageString = "Hello Baeldung!"; HTreeMap myMap = db.hashMap ("saját térkép"). CreateOrOpen (); myMap.put (welcomeMessageKey, welcomeMessageString);

HTreeMap a MapDB's HashMap végrehajtás. Tehát most, hogy vannak adatok az adatbázisunkban, lekérhetjük azokat a kap módszer:

String welcomeMessageFromDB = (String) myMap.get (welcomeMessageKey); assertEquals (welcomeMessageString, welcomeMessageFromDB);

Végül, miután befejeztük az adatbázist, be kell zárnunk, hogy elkerüljük a további mutációkat:

db.zár ();

Adataink fájlban történő tárolásához, nem pedig a memóriához, csak annyit kell tennünk, hogy megváltoztatjuk az adatmódunkat DB az objektum példányos:

DB db = DBMaker.fileDB ("file.db"). Make ();

A fenti példánk nem használ típusú paramétereket. Ennek eredményeként ragaszkodunk ahhoz, hogy az eredményeket meghatározott típusokkal dolgozzuk. A következő példánkban bemutatjuk Sorosítók az öntés szükségességének kiküszöbölésére.

2.2. Gyűjtemények

A MapDB különböző gyűjteménytípusokat tartalmaz. A bemutatáshoz adjunk hozzá és töltsünk le néhány adatot az adatbázisunkból az a használatával NavigableSet, amely úgy működik, ahogy elvárható egy Java-tól Készlet:

Kezdjük egy egyszerű példányosítással DB tárgy:

DB db = DBMaker.memoryDB (). Make ();

Ezután hozzuk létre a sajátunkat NavigableSet:

NavigableSet set = db .treeSet ("mySet") .serializer (Serializer.STRING) .createOrOpen ();

Itt a sorosító biztosítja, hogy az adatbázisunkból származó bemeneti adatok sorosítottak és deserializáltak legyenek Húr tárgyakat.

Ezután adjunk hozzá néhány adatot:

set.add ("Baeldung"); set.add ("fantasztikus");

Most ellenőrizzük, hogy a két különböző értékünket helyesen adtuk-e az adatbázisba:

assertEquals (2, set.size ());

Végül, mivel ez egy halmaz, adjunk hozzá egy másodlagos karakterláncot, és ellenőrizzük, hogy adatbázisunk továbbra is csak két értéket tartalmaz:

set.add ("Baeldung"); assertEquals (2, set.size ());

2.3. Tranzakciók

A hagyományos adatbázisokhoz hasonlóan a DB osztály módszereket nyújt arra elkövetni és visszagörgetés az adatbázisunkba felvett adatok.

Ennek a funkciónak az engedélyezéséhez inicializálnunk kell DB a ... val ügyletEnable módszer:

DB db = DBMaker.memoryDB (). TranzakcióEnable (). Make ();

Ezután hozzunk létre egy egyszerű halmazt, adjunk hozzá néhány adatot, és rendeljük hozzá az adatbázishoz:

NavigableSet set = db .treeSet ("mySet") .serializer (Serializer.STRING) .createOrOpen (); set.add ("Egy"); set.add ("Kettő"); db.vállalás (); assertEquals (2, set.size ());

Vegyünk fel egy harmadik, nem kötelező karakterláncot az adatbázisunkba:

set.add ("Három"); assertEquals (3, set.size ());

Ha nem vagyunk elégedettek az adatainkkal, akkor visszaállíthatjuk az adatokat a használatával A DB visszagörgetése módszer:

db.vissza (); assertEquals (2, set.size ());

2.4. Sorosítók

A MapDB számos különféle sorosítót kínál, amelyek a gyűjteményben lévő adatokat kezelik. A legfontosabb konstrukciós paraméter a név, amely azonosítja az egyes gyűjteményeket az DB tárgy:

HTreeMap map = db.hashMap ("indentification_name") .keySerializer (Serializer.STRING) .valueSerializer (Serializer.LONG) .create ();

Bár a szerializálás ajánlott, opcionális és kihagyható. Érdemes azonban megjegyezni, hogy ez lassabb generikus sorosítási folyamathoz vezet.

3. HTreeMap

MapDB-k HTreeMap biztosítja HashMap és HashSet gyűjtemények az adatbázisunk használatához. HTreeMap egy szegmentált hash fa, és nem használ fix méretű hash táblázatot. Ehelyett automatikusan kibővülő indexfát használ, és a tábla növekedésével nem újrateremti az összes adatot. Ennek tetejébe, HTreeMap szálbiztos és támogatja a párhuzamos írásokat több szegmens használatával.

Először példázzunk egy egyszerűt HashMap hogy használja Húr mind a kulcsok, mind az értékek esetében:

DB db = DBMaker.memoryDB (). Make (); HTreeMap hTreeMap = db .hashMap ("myTreeMap") .keySerializer (Serializer.STRING) .valueSerializer (Serializer.STRING) .create ();

A fentiekben külön definiáltuk sorozatok a kulcshoz és az értékhez. Most, hogy a mi HashMap létrejön, adjunk hozzá adatokat a tedd módszer:

hTreeMap.put ("kulcs1", "érték1"); hTreeMap.put ("kulcs2", "érték2"); assertEquals (2, hTreeMap.size ());

Mint HashMap működik egy Az objektum hashCode-ja metódus, az adatok hozzáadása ugyanazzal a kulccsal az érték felülírását eredményezi:

hTreeMap.put ("kulcs1", "érték3"); assertEquals (2, hTreeMap.size ()); assertEquals ("érték3", hTreeMap.get ("kulcs1"));

4. SortedTableMap

MapDB-k SortedTableMap a kulcsokat rögzített méretű táblában tárolja, és bináris keresést használ a visszakereséshez. Érdemes megjegyezni, hogy miután elkészült, a térkép csak olvasható.

Végigjárjuk az a létrehozásának és lekérdezésének folyamatát SortedTableMap. Először létrehozunk egy memóriában leképezett kötetet az adatok tárolására, valamint egy mosogatót az adatok hozzáadásához. Kötetünk első behívásakor a csak olvasható jelzőt állítjuk hamis, biztosítva, hogy írhatunk a kötetbe:

Karakterlánc VOLUME_LOCATION = "sortedTableMapVol.db"; Vol. Vol = MappedFileVol.FACTORY.makeVolume (VOLUME_LOCATION, hamis); SortedTableMap.Sink sink = SortedTableMap.create (vol, Serializer.INTEGER, Serializer.STRING) .createFromSink ();

Ezután hozzáadjuk adatainkat és felhívjuk a teremt módszer a mosogatón a térképünk elkészítéséhez:

for (int i = 0; i <100; i ++) {sink.put (i, "Érték" + Integer.toString (i)); } süllyed.create ();

Most, hogy térképünk létezik, meghatározhatunk egy csak olvasható kötetet, és a segítségével megnyithatjuk a térképünket A SortedTableMap meg van nyitva módszer:

Volume openVol = MappedFileVol.FACTORY.makeVolume (VOLUME_LOCATION, true); SortedTableMap sortedTableMap = SortedTableMap .open (openVol, Serializer.INTEGER, Serializer.STRING); assertEquals (100, sortedTableMap.size ());

4.1. Bináris keresés

Mielőtt továbblépnénk, értsük meg, hogyan SortedTableMap a bináris keresést részletesebben hasznosítja.

SortedTableMap oldalakra osztja a tárhelyet, és mindegyik oldal több csomópontot tartalmaz, amelyek kulcsokból és értékekből állnak. Ezeken a csomópontokon belül találhatók a kulcs-érték párok, amelyeket a Java kódunkban definiálunk.

SortedTableMap Három bináris keresést végez a helyes érték lekérése érdekében:

  1. Az egyes oldalak kulcsait halmban tárolják egy tömbben. A SortedTableMap bináris keresést végez a megfelelő oldal megtalálásához.
  2. Ezután a csomópont minden kulcsához dekompresszió történik. A bináris keresés létrehozza a megfelelő csomópontot a kulcsok szerint.
  3. Végül a SortedTableMap a csomóponton belüli kulcsok felett keres, hogy megtalálja a helyes értéket.

5. Memória üzemmódban

MapDB ajánlatok háromféle memóriatároló. Vessünk egy gyors pillantást az egyes üzemmódokra, értjük meg azok működését és tanulmányozzuk az előnyeit.

5.1. Halomra

Halom mód objektumokat egy egyszerű Java Gyűjteményben tárol Térkép. Azt nem alkalmazza a sorosítást, és nagyon gyors lehet kis adatkészletek esetén.

Mivel azonban az adatokat halmban tárolják, az adatkészletet a szemétgyűjtés (GC) kezeli. A GC időtartama az adatkészlet méretével növekszik, ami teljesítménycsökkenést eredményez.

Lássunk egy példát, amely meghatározza az on-heap módot:

DB db = DBMaker.heapDB (). Make ();

5.2. Byte[]

A második tárolótípus bájt tömbökön alapszik. Ebben a módban az adatokat sorosítják és legfeljebb 1 MB méretű tömbökbe tárolják. Bár technikailag halmozott, ez a módszer hatékonyabb a szemétszállításhoz.

Ez alapértelmezés szerint ajánlott, és aHello Baeldung ' példa:

DB db = DBMaker.memoryDB (). Make ();

5.3. DirectByteBuffer

A végső bolt alapja DirectByteBuffer. A Java 1.4-ben bevezetett közvetlen memória lehetővé teszi az adatok közvetlen átadását a natív memóriába, nem pedig a Java halomba. Ennek eredményeként az adatok tárolásra kerülnek teljesen halmozottan.

Meghívhatunk egy ilyen típusú üzletet:

DB db = DBMaker.memoryDirectDB (). Make ();

6. Miért éppen a MapDB?

Miért érdemes használni a MapDB-t?

6.1. MapDB vs hagyományos adatbázis

A MapDB számos adatbázis-funkcionalitást kínál, csak néhány sor Java-kóddal konfigurálva. A MapDB alkalmazásakor elkerülhetjük a program működéséhez szükséges különféle szolgáltatások és kapcsolatok gyakran időigényes beállítását.

Ezen túlmenően a MapDB lehetővé teszi számunkra, hogy hozzáférjünk egy adatbázis bonyolultságához a Java gyűjtemény ismeretében. A MapDB használatával nincs szükségünk SQL-re, és a rekordokhoz egyszerűen hozzáférhetünk kap metódus hívások.

6.2. MapDB vs Simple Java Gyűjtemények

A Java Gyűjtemények nem fogják megőrizni alkalmazásunk adatait, ha leállítja a végrehajtást. A MapDB egy egyszerű, rugalmas, bedugható szolgáltatást kínál, amely lehetővé teszi számunkra, hogy gyorsan és egyszerűen megőrizzük az alkalmazásunk adatait, miközben fenntartjuk a Java gyűjteménytípusok hasznosságát.

7. Következtetés

Ebben a cikkben mélyen belemerültünk a MapDB beágyazott adatbázis-motorjába és gyűjtemény-keretrendszerébe.

Azzal kezdtük, hogy megnéztük az alaposztályokat DB és DBMaker adatbázisunk konfigurálásához, megnyitásához és kezeléséhez. Ezután áttekintettük az adatstruktúrák néhány példáját, amelyeket a MapDB felajánl a nyilvántartásainkhoz. Végül megvizsgáltuk a MapDB előnyeit egy hagyományos adatbázissal vagy Java Collection-el szemben.

Mint mindig, a példa kód elérhető a GitHubon.