streamalism.org

1. Áttekintés

A Redisson egy Redis kliens a Java számára. Ebben a cikkben megvizsgáljuk néhány jellemzőjét, és bemutatjuk, hogyan segíthetné elő az elosztott üzleti alkalmazások felépítését.

A Redisson a memóriában lévő adatrácsot alkotja amely elosztott Java objektumokat és szolgáltatásokat kínál Redis támogatásával. Elosztott memóriájú adatmodellje lehetővé teszi a tartományi objektumok és szolgáltatások megosztását alkalmazások és szerverek között.

Ebben a cikkben hamarosan látni fogjuk a Redisson beállítását, megértjük annak működését, és felfedezhetjük a Redisson néhány tárgyát és szolgáltatását.

2. Maven-függőségek

Kezdjük az importálással Redisson projektünkhöz az alábbi szakasz hozzáadásával a projektünkhöz pom.xml:

 org.redisson redisson 3.13.1 

A függőség legújabb verziója itt található.

3. Konfiguráció

Mielőtt elkezdenénk, meg kell győződnünk arról, hogy rendelkezünk a Redis legfrissebb verziójával és telepítésével. Ha még nem rendelkezik Redis-szel, és Linuxot vagy Macintosh-t használ, az itt található információkat követheti a beállításhoz. Ha Ön Windows-felhasználó, akkor a nem hivatalos port segítségével beállíthatja a Redist.

Be kell állítanunk a Redissont, hogy csatlakozzon a Redishez. A Redisson támogatja a kapcsolatokat a következő Redis-konfigurációkkal:

• Egyetlen csomópont
• Mester rabszolga csomópontokkal
• Sentinel bólint
• Fürtözött csomópontok
• Replikált csomópontok

A Redisson támogatja az Amazon Web Services (AWS) ElastiCache fürtöt és az Azure Redis gyorsítótárat fürtözött és replikált csomópontokhoz.

Csatlakozzunk a Redis egyetlen csomópontú példányához. Ez a példány helyben fut az alapértelmezett 6379-es porton:

RedissonClient kliens = Redisson.create ();

Különböző konfigurációkat adhat át a Redisson objektumé teremt módszer. Ez lehet konfiguráció, hogy egy másik porthoz csatlakozzon, vagy esetleg egy Redis-fürthöz. Ez A konfiguráció lehet Java-kód, vagy külső konfigurációs fájlból tölthető be.

3.1. Java konfiguráció

Konfiguráljuk a Redissont Java-kódban:

Config config = új Config (); config.useSingleServer () .setAddress ("redis: //127.0.0.1: 6379"); RedissonClient kliens = Redisson.create (config);

Mi adja meg a Redisson-konfigurációkat a Konfig tárgy majd adja át a teremt módszer. A fentiekben megadtuk Redisson-nek, hogy a Redis egyetlen csomópontú példányához szeretnénk csatlakozni. Ehhez a Konfig objektumé useSingleServer módszer. Ez egy hivatkozást ad vissza a SingleServerConfig tárgy.

A SingleServerConfig Az objektumnak vannak olyan beállításai, amelyeket a Redisson a Redis egyetlen csomópont-példányához való kapcsolódáshoz használ. Itt használjuk setAddress metódus a cím beállítás. Ez állítja be annak a csomópontnak a címét, amelyhez kapcsolódunk. Néhány egyéb beállítás tartalmazza a próbálkozzon újra, kapcsolat időtúllépés és Ügyfél Neve. Ezek a beállítások a megfelelő beállító módszerekkel konfigurálhatók.

A Redissont a Redis különböző konfigurációihoz hasonló módon konfigurálhatjuk a Konfig objektum következő módszerei:

• useSingleServer - egycsomópontos példányhoz. Itt szerezheti be az egy csomópont beállításait
• useMasterSlaveServers - rabszolgacsomópontú mester számára. Itt szerezheti be a master-slave csomópont beállításait
• useSentinelServers - őrcsomópontokra. Itt kaphatja meg az őrszem csomópont beállításait
• useClusterServers - fürtözött csomópontokhoz. Itt fürtözött csomópontbeállításokat kaphat
• useReplicatedServers - replikált csomópontokhoz. Itt kaphatja meg a replikált csomópont-beállításokat

3.2. Fájl konfigurálása

A Redisson külső JSON-ból vagy YAML-ből töltheti be a konfigurációkat fájlok:

Config config = Config.fromJSON (új fájl ("singleNodeConfig.json")); RedissonClient kliens = Redisson.create (config);

A Konfig objektumé tólJSON metódus betöltheti a konfigurációkat egy karakterláncból, fájlból, bemeneti adatfolyamból vagy URL-ből.

Itt található a minta konfigurációja a singleNodeConfig.json fájl:

{"singleServerConfig": {"idleConnectionTimeout": 10000, "connectTimeout": 10000, "timeout": 3000, "retryAtt próbálkozások": 3, "retryInterval": 1500, "password": null, "subscriptionsPerConnection": 5, "clientName ": null," address ":" redis: //127.0.0.1: 6379 "," subscriptionConnectionMinimumIdleSize ": 1," subscriptionConnectionPoolSize ": 50," connectionMinimumIdleSize ": 10," connectionPoolSize ": 64," adatbázis ": 0, "dnsMonitoringInterval": 5000}, "szálak": 0, "nettyThreads": 0, "kodek": null}

Itt van egy megfelelő YAML konfigurációs fájl:

singleServerConfig: idleConnectionTimeout: 10000 connectTimeout: 10000 timeout: 3000 újra 64 adatbázis: 0 dnsMonitoringInterval: 5000 szál: 0 nettyThreads: 0 kodek:! {} 

Konfigurálhatunk más Redis-konfigurációkat is egy fájlból hasonló módon, az adott konfigurációra jellemző beállításokkal. Tájékoztatásul, itt vannak a JSON és YAML fájlformátumok:

• Egy csomópont - formátum
• Mester szolga csomópontokkal - formátum
• Sentinel csomópontok - formátum
• Fürtözött csomópontok - formátum
• Replikált csomópontok - formátum

A Java konfiguráció JSON vagy YAML formátumba történő mentéséhez használhatjuk a toJSON vagy toYAML módszerei Konfig tárgy:

Config config = új Config (); // ... itt több beállítást konfigurálunk a Java karakterláncban: jsonFormat = config.toJSON (); String yamlFormat = config.toYAML ();

Most, hogy tudjuk, hogyan kell konfigurálni a Redissont, nézzük meg, hogyan hajtja végre a Redisson a műveleteket.

4. Működés

A Redisson támogatja a szinkron, aszinkron és reaktív interfészeket. Műveletek ezek felett az interfészek menetesek.

Minden entitás (objektumok, gyűjtemények, zárak és szolgáltatások), amelyeket a RedissonClient szinkron és aszinkron módszerekkel rendelkeznek. A szinkron módszerek aszinkron változatokat hordoznak. Ezek a módszerek általában ugyanazt a metódusnevet viselik, mint az „Async” mellékelt szinkronváltozataik. Vizsgáljuk meg a RAtomicLong tárgy:

RedissonClient kliens = Redisson.create (); RAtomicLong myLong = client.getAtomicLong ('myLong'); 

A szinkron aszinkron változata CompareAndSet módszer a következő lenne:

RFuture isSet = myLong.compareAndSetAsync (6, 27);

A módszer aszinkron változata egy RFuture tárgy. Beállíthatjuk, hogy a hallgatók visszakapják az eredményt, amikor elérhetővé válik:

isSet.handle ((eredmény, kivétel) -> {// itt kezeli az eredményt vagy kivételt.});

Reaktív objektumok előállításához a RedissonReactiveClient:

RedissonReactiveClient kliens = Redisson.createReactive (); RAtomicLongReactive myLong = client.getAtomicLong ("myLong"); Kiadó isSetPublisher = myLong.compareAndSet (5, 28);

Ez a módszer a reaktív objektumokat adja vissza a Java 9 Reactive Streams Standard alapján.

Fedezzük fel a Redisson által biztosított elosztott objektumokat.

5. Tárgyak

A A Redisson objektum sorosítva van, és a Redissont támogató Redis csomópontok bármelyikében tárolódik. Ezek az objektumok egy fürtben oszthatók el több csomóponton, és egyetlen alkalmazással vagy több alkalmazással / kiszolgálóval érhetők el.

Ezek az elosztott objektumok követik a java.util.concurrent.atomic csomag. Támogatják a Redis-ben tárolt objektumok zárolás nélküli, szálbiztos és atomi műveleteit. Az alkalmazások / kiszolgálók közötti adatkonzisztencia biztosított, mivel az értékek nem frissülnek, miközben egy másik alkalmazás az objektumot olvassa.

A Redisson objektumok a Redis kulcsokhoz vannak kötve. Ezeket a kulcsokat a RKeys felület. Ezután ezeken a billentyűkön keresztül elérhetjük Redisson-objektumainkat.

Számos lehetőséget használhatunk a Redis kulcsok megszerzésére.

Egyszerűen megszerezhetjük az összes kulcsot:

RKeys kulcsok = client.getKeys ();

Alternatív megoldásként csak a neveket vonhatjuk ki:

Iterálható allKeys = keys.getKeys ();

És végül elérhetjük, hogy a kulcsok megfeleljenek egy mintának:

Iterálható kulcsokByPattern = keys.getKeysByPattern ('kulcs *')

Az RKeys interfész lehetővé teszi a kulcsok törlését, a minták szerinti törlést és más hasznos kulcsalapú műveleteket is, amelyeket felhasználhatnánk a kulcsok és objektumok kezelésére.

A Redisson által biztosított terjesztett objektumok a következők:

• ObjectHolder
• BinaryStreamHolder
• GeospatialHolder
• BitSet
• AtomicLong
• AtomicDouble
• Téma
• BloomFilter
• HyperLogLog

Vessünk egy pillantást az alábbi három objektumra: ObjectHolder, AtomicLong, és Téma.

5.1. Tárgytartó

Képviseli a RBucket osztályban, ez az objektum bármilyen típusú objektumot tartalmazhat. Az objektum maximális mérete 512 MB:

RBucket vödör = client.getBucket ("főkönyv"); bucket.set (new Ledger ()); Ledger ledger = vödör.get ();

A RBucket objektum végezhet atomi műveleteket, mint pl hasonlítsa összeAndSet ésgetAndSet a rajta lévő tárgyakon.

5.2. AtomicLong

Képviseli a RAtomicLong osztályban ez az objektum nagyon hasonlít a java.util.concurrent.atomic.AtomicLong osztály és képviseli a hosszú atomilag frissíthető érték:

RAtomicLong atomicLong = client.getAtomicLong ("myAtomicLong"); atomicLong.set (5); atomicLong.incrementAndGet ();

5.3. Téma

A Téma objektum támogatja a Redis „közzététel és feliratkozás” mechanizmusát. A közzétett üzenetek meghallgatása:

RTopic subscribeTopic = client.getTopic ("baeldung"); subscribeTopic.addListener (CustomMessage.class, (channel, customMessage) -> future.complete (customMessage.getMessage ()));

Fent a Téma regisztrálva van a „baeldung” csatornáról érkező üzenetek meghallgatásához. Ezután hozzáadunk egy hallgatót a témához, hogy kezelje az adott csatornáról érkező üzeneteket. Több hallgatót felvehetünk egy csatornára.

Tegyünk közzé üzeneteket a „baeldung” csatornán:

RTopic publishTopic = client.getTopic ("baeldung"); long clientsReceivedMessage = publishTopic.publish (új CustomMessage ("Ez egy üzenet"));

Ezt közzé lehet tenni egy másik alkalmazásból vagy szerverről. A CustomMessage objektumot a hallgató megkapja, és a onMessage módszer.

Itt többet megtudhatunk más Redisson-objektumokról.

6. Gyűjtemények

A Redisson kollekciókat ugyanúgy kezeljük, mint a tárgyakat.

A Redisson által biztosított terjesztett gyűjtemények a következőket tartalmazzák:

• Térkép
• Multimap
• Készlet
• SortedSet
• ScoredSortedSet
• LexSortedSet
• Lista
• Sor
• Deque
• BlockingQueue
• BoundedBlockingQueue
• BlockingDeque
• BlockingFairQueue
• DelayedQueue
• PriorityQueue
• PriorityDeque

Vessünk egy pillantást a következő három gyűjteményre: Térkép, Set, és Lista.

6.1. Térkép

Redisson alapú térképek valósítják meg a java.util.concurrent.ConcurrentMap és java.util.Térkép interfészek. Redisson négy térképmegvalósítással rendelkezik. Ezek RMap, RMapCache, RLocalCachedMap és RClusteredMap.

Hozzunk létre egy térképet a Redisson segítségével:

RMap map = client.getMap ("főkönyv"); Ledger newLedger = map.put ("123", új Ledger ()); térkép

RMapCache támogatja a térképbejegyzés kilakoltatását. RLocalCachedMap lehetővé teszi a térképbejegyzések helyi gyorsítótárba helyezését. RClusteredMap lehetővé teszi, hogy egyetlen térkép adatait fel lehessen osztani a Redis-fürt fő csomópontjai között.

Itt többet megtudhatunk a Redisson-térképekről.

6.2. Készlet

Redisson alapú Készlet végrehajtja a java.util.Set felület.

Redissonnek három van Készlet megvalósítások, RSet, RSetCache, és RClusteredSet hasonló funkcionalitással, mint a térképi társaik.

Hozzunk létre egy Készlet Redissonnal:

RSet ledgerSet = client.getSet ("főkönyvkészlet"); ledgerSet.add (new Ledger ());

Itt többet megtudhatunk a Redisson-készletekről.

6.3. Lista

Redisson-alapú Listák végre a java.util.List felület.

Hozzunk létre egy Lista Redissonnal:

RList ledgerList = client.getList ("főkönyv"); ledgerList.add (új Ledger ());

A Redisson egyéb gyűjteményeiről itt tudhat meg többet.

7. Zárak és szinkronizátorok

Redisson-é az elosztott zárak lehetővé teszik a szálak szinkronizálását alkalmazások / szerverek között. Redisson zárak és szinkronizálók listája a következőket tartalmazza:

• Zár
• FairLock
• MultiLock
• ReadWriteLock
• Szemafor
• PermitExpirableSemaphore
• CountDownLatch

Vessünk egy pillantást Zár és MultiLock.

7.1. Zár

Redisson-é Zár megvalósítja java.util.concurrent.locks.Lock felület.

Vezessünk be egy zárat, amelyet a RLock osztály:

RLock lock = client.getLock ("zár"); lock.lock (); // végezzen néhány hosszú műveletet ... lock.unlock ();

7.2. MultiLock

Redisson-é RedissonMultiLock többszörös csoportok RLock tárgyakat, és egyetlen zárként kezeli őket:

RLock lock1 = clientInstance1.getLock ("lock1"); RLock lock2 = clientInstance2.getLock ("lock2"); RLock lock3 = clientInstance3.getLock ("lock3"); RedissonMultiLock lock = új RedissonMultiLock (lock1, lock2, lock3); lock.lock (); // hosszú futási művelet végrehajtása ... lock.unlock ();

Itt többet tudhat meg más zárakról.

8. Szolgáltatások

Redisson négyféle elosztott szolgáltatást tár fel. Ezek: Távoli szolgáltatás, Élő objektum szolgáltatás, Végrehajtó szolgálat és Ütemezett végrehajtó szolgálat. Nézzük meg a Távoli szolgáltatást és az Élő objektum szolgáltatást.

8.1. Távoli szolgáltatás

Ez a szolgáltatás biztosítja Java távoli módszer meghívását Redis segíti. A Redisson távoli szolgáltatás egy kiszolgálóoldali (dolgozói példány) és kliensoldali megvalósításból áll. A kiszolgálóoldali megvalósítás az ügyfél által meghívott távoli metódust hajtja végre. A távoli szolgáltatásból érkező hívások lehetnek szinkronosak vagy aszinkronak.

A kiszolgáló oldala regisztrálja az interfészt a távoli meghíváshoz:

RRemoteService remoteService = client.getRemoteService (); LedgerServiceImpl ledgerServiceImpl = új LedgerServiceImpl (); remoteService.register (LedgerServiceInterface.class, ledgerServiceImpl);

Az ügyféloldal meghívja a regisztrált távoli interfész metódusát:

RRemoteService remoteService = client.getRemoteService (); LedgerServiceInterface ledgerService = remoteService.get (LedgerServiceInterface.class); Lista bejegyzések = ledgerService.getEntries (10);

Itt többet megtudhatunk a távoli szolgáltatásokról.

8.2. Élő objektum szolgáltatás

A Redisson Live Objects kiterjeszti a standard Java objektumok fogalmát, amelyekhez csak egyetlen JVM-től lehet hozzáférni továbbfejlesztett Java objektumok, amelyeket meg lehet osztani a különböző JVM-ek között, különböző gépeken. Ez úgy valósul meg, hogy az objektum mezőit egy Redis hash-hoz hozzárendeli. Ez a leképezés futásidejűleg felépített proxy osztályon keresztül történik. A terepi getterek és beállítók a Redis hget / hset parancsokra vannak leképezve.

A Redisson Live Objects támogatja az atommező hozzáférést Redis egyszálú jellege miatt.

Élő objektum létrehozása egyszerű:

@REntity public class LedgerLiveObject {@RId privát karakterlánc neve; // szerelők és beállítók ...}

Jelöljük az osztályunkat azzal @REntity és egy egyedi vagy azonosító mező a @RId. Miután ezt megtettük, használhatjuk az élő objektumunkat az alkalmazásunkban:

RLiveObjectService service = client.getLiveObjectService (); LedgerLiveObject főkönyv = new LedgerLiveObject (); ledger.setName ("főkönyv1"); főkönyv = service.persist (főkönyv);

Live Object-jünket a standard Java objektumokhoz hasonlóan hozzuk létre a új kulcsszó. Ezután használjuk a RLiveObjectService hogy az objektumot Redis-re mentse annak használatával kitartani módszer.

Ha az objektum korábban már fennmaradt a Redis számára, akkor lekérhetjük az objektumot:

LedgerLiveObject returnLedger = service.get (LedgerLiveObject.class, "főkönyv1");

Használjuk a RLiveObjectService hogy megkapjuk a Live Object-t a (z) mezővel annotált mező használatával @RId.

Itt többet találhatunk a Redisson Live Objects-ről, és itt leírjuk a Redisson egyéb szolgáltatásait.

9. Csővezeték

Redisson támogatja a csővezeték-vezetést. Több művelet köthető össze egyetlen atomi műveletként. Ezt elősegíti a RBatch osztály. Több parancsot összesítenek egy an ellen RBatch objektumpéldány a végrehajtás előtt:

RBatch batch = kliens.createBatch (); batch.getMap ("főkönyv"). fastPutAsync ("1", "2"); batch.getMap ("főkönyvMap"). putAsync ("2", "5"); BatchResult batchResult = batch.execute ();

10. Szkriptelés

Redisson támogatja az LUA szkriptelését. Végrehajthatjuk az LUA szkriptjeit Redis ellen:

client.getBucket ("foo"). set ("bar"); Karakterlánc eredménye = client.getScript (). Eval (Mode.READ_ONLY, "return redis.call ('get', 'foo')", RScript.ReturnType.VALUE);

11. Alacsony szintű kliens

Lehetséges, hogy olyan Redis műveleteket szeretnénk végrehajtani, amelyeket a Redisson még nem támogat. A Redisson egy alacsony szintű klienst biztosít, amely lehetővé teszi a natív Redis parancsok végrehajtását:

RedisClientConfig redisClientConfig = új RedisClientConfig (); redisClientConfig.setAddress ("localhost", 6379); RedisClient kliens = RedisClient.create (redisClientConfig); RedisConnection conn = kliens.connect (); conn.sync (StringCodec.INSTANCE, RedisCommands.SET, "teszt", 0); conn.closeAsync (); kliens.leállítás ();

Az alacsony szintű kliens az aszinkron műveleteket is támogatja.

12. Következtetés

Ez a cikk bemutatta a Redissont és néhány olyan funkciót, amelyek ideálisak az elosztott alkalmazások fejlesztéséhez. Felfedeztük az elosztott tárgyakat, gyűjteményeket, zárakat és szolgáltatásokat. Megvizsgáltuk néhány egyéb funkcióját is, mint például a pipelining, a scripting és az alacsony szintű kliens.

A Redisson integrációt biztosít más keretekkel is mint például a JCache API, a Tavaszi gyorsítótár, a Hibernált gyorsítótár és a Tavaszi munkamenetek. Itt többet megtudhat más keretekkel való integrációjáról.

Kódmintákat a GitHub projektben találhat.