streamalism.org

1. Oversigt

Redisson er en Redis-klient til Java. I denne artikel undersøger vi nogle af dens funktioner og demonstrerer, hvordan det kan lette opbygning af distribuerede forretningsapplikationer.

Redisson udgør et datagitter i hukommelsen der tilbyder distribuerede Java-objekter og tjenester understøttet af Redis. Dens distribuerede hukommelsesdatamodel tillader deling af domæneobjekter og tjenester på tværs af applikationer og servere.

I denne artikel ser vi hot til opsætning af Redisson, forstå hvordan det fungerer og udforske nogle af Redissons objekter og tjenester.

2. Maven-afhængigheder

Lad os komme i gang ved at importere Redisson til vores projekt ved at tilføje nedenstående afsnit til vores pom.xml:

 org.redisson redisson 3.13.1 

Den seneste version af denne afhængighed kan findes her.

3. Konfiguration

Inden vi kommer i gang, skal vi sikre, at vi har den nyeste version af Redis opsætning og kører. Hvis du ikke har Redis, og du bruger Linux eller Macintosh, kan du følge oplysningerne her for at få det konfigureret. Hvis du er en Windows-bruger, kan du konfigurere Redis ved hjælp af denne uofficielle port.

Vi er nødt til at konfigurere Redisson til at oprette forbindelse til Redis. Redisson understøtter forbindelser til følgende Redis-konfigurationer:

• Enkelt knude
• Mester med slaveknudepunkter
• Sentinel noder
• Klyngede noder
• Replikerede noder

Redisson understøtter Amazon Web Services (AWS) ElastiCache Cluster og Azure Redis Cache til klyngede og replikerede noder.

Lad os oprette forbindelse til en enkelt node-forekomst af Redis. Denne forekomst kører lokalt på standardporten, 6379:

RedissonClient-klient = Redisson.create ();

Du kan videregive forskellige konfigurationer til Redisson objekt skab metode. Dette kan være konfigurationer, så den opretter forbindelse til en anden port eller måske til at oprette forbindelse til en Redis-klynge. Det her konfigurationen kan være i Java-kode eller indlæst fra en ekstern konfigurationsfil.

3.1. Java-konfiguration

Lad os konfigurere Redisson i Java-kode:

Config config = ny Config (); config.useSingleServer () .setAddress ("redis: //127.0.0.1: 6379"); RedissonClient-klient = Redisson.create (config);

Vi angiv Redisson-konfigurationer i en forekomst af en Konfig objekt og send det derefter til skab metode. Ovenfor specificerede vi til Redisson, at vi vil oprette forbindelse til en enkelt node-forekomst af Redis. For at gøre dette brugte vi Konfig objekt useSingleServer metode. Dette returnerer en henvisning til a SingleServerConfig objekt.

Det SingleServerConfig objekt har indstillinger, som Redisson bruger til at oprette forbindelse til en enkelt node-forekomst af Redis. Her bruger vi dens setAddress metode til at konfigurere adresse indstilling. Dette indstiller adressen på den node, vi opretter forbindelse til. Nogle andre indstillinger inkluderer forsøg på forsøg, forbindelseTimeout og Kundenavn. Disse indstillinger konfigureres ved hjælp af deres tilsvarende settermetoder.

Vi kan konfigurere Redisson til forskellige Redis-konfigurationer på en lignende måde ved hjælp af Konfig objektets følgende metoder:

• useSingleServer - for en enkelt node-instans. Få indstillinger for en enkelt knude her
• useMasterSlaveServers - til mester med slaveknudepunkter. Få master-slave node-indstillinger her
• useSentinelServers - for sentinel noder. Få indstillinger for sentinalknude her
• useClusterServers - for klyngede noder. Få klyngede nodeindstillinger her
• useReplicatedServers - til replikerede noder. Få replikerede nodeindstillinger her

3.2. Filkonfiguration

Redisson kan indlæse konfigurationer fra ekstern JSON eller YAML filer:

Config config = Config.fromJSON (ny fil ("singleNodeConfig.json")); RedissonClient-klient = Redisson.create (config);

Det Konfig objekt fraJSON metode kan indlæse konfigurationer fra en streng, fil, inputstrøm eller URL.

Her er eksempelkonfigurationen i singleNodeConfig.json fil:

{"singleServerConfig": {"idleConnectionTimeout": 10000, "connectTimeout": 10000, "timeout": 3000, "retryAttempt": 3, "retryInterval": 1500, "password": null, "subscriptionsPerConnection": 5, "clientName ": null," address ":" redis: //127.0.0.1: 6379 "," subscriptionConnectionMinimumIdleSize ": 1," subscriptionConnectionPoolSize ": 50," connectionMinimumIdleSize ": 10," connectionPoolSize ": 64," database ": 0, "dnsMonitoringInterval": 5000}, "threads": 0, "nettyThreads": 0, "codec": null}

Her er en tilsvarende YAML-konfigurationsfil:

singleServerConfig: idleConnectionTimeout: 10000 connectTimeout: 10000 timeout: 3000 retryAforsøg: 3 retryInterval: 1500 adgangskode: null abonnementerPerConnection: 5 klientnavn: null adresse: "redis: //127.0.0.1: 6379" abonnementConnectionMinimumIdleSize: 1 abonnementConnectionPoolSize: Max. 64 database: 0 dnsMonitoring Interval: 5000 tråde: 0 nettyTråde: 0 codec:! {} 

Vi kan konfigurere andre Redis-konfigurationer fra en fil på en lignende måde ved hjælp af indstillinger, der er særlige for denne konfiguration. Til din reference er her deres JSON- og YAML-filformater:

• Enkelt knudepunkt - format
• Master med slaveknudepunkter - format
• Sentinel noder - format
• Klyngede noder - format
• Replikerede noder - format

For at gemme en Java-konfiguration i JSON- eller YAML-format kan vi bruge tilJSON eller toYAML metoder til Konfig objekt:

Config config = ny Config (); // ... vi konfigurerer flere indstillinger her i Java String jsonFormat = config.toJSON (); Streng yamlFormat = config.toYAML ();

Nu hvor vi ved, hvordan vi konfigurerer Redisson, skal vi se på, hvordan Redisson udfører operationer.

4. Betjening

Redisson understøtter synkron, asynkron og reaktiv grænseflade. Operationer over disse grænseflader er trådsikre.

Alle enheder (objekter, samlinger, låse og tjenester) genereret af en Redisson klient har synkrone og asynkrone metoder. Synkrone metoder bærer asynkrone varianter. Disse metoder bærer normalt det samme navn på deres synkroniserede varianter tilføjet med "Async". Lad os se på en synkron metode til RAtomicLong objekt:

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

Den asynkrone variant af den synkrone sammenlignAndSet metoden ville være:

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

Den asynkrone variant af metoden returnerer en RFuture objekt. Vi kan indstille lyttere til dette objekt for at få resultatet tilbage, når det bliver tilgængeligt:

isSet.handle ((resultat, undtagelse) -> {// håndter resultatet eller undtagelsen her.});

For at generere reaktive objekter skal vi bruge RedissonReactiveClient:

RedissonReactiveClient-klient = Redisson.createReactive (); RAtomicLongReactive myLong = client.getAtomicLong ("myLong"); Udgiver isSetPublisher = myLong.compareAndSet (5, 28);

Denne metode returnerer reaktive objekter baseret på Reactive Streams Standard for Java 9.

Lad os undersøge nogle af de distribuerede objekter, der leveres af Redisson.

5. Objekter

En individuel forekomst af en Redisson-objektet serialiseres og gemmes i en hvilken som helst af de tilgængelige Redis-noder, der understøtter Redisson. Disse objekter kan distribueres i en klynge på tværs af flere noder og kan tilgås af et enkelt program eller flere applikationer / servere.

Disse distribuerede objekter følger specifikationerne fra java.util.concurrent.atomic pakke. De understøtter låsefri, trådsikker og atomoperation på genstande, der er gemt i Redis. Datakonsistens mellem applikationer / servere sikres, da værdier ikke opdateres, mens en anden applikation læser objektet.

Redisson-objekter er bundet til Redis-taster. Vi kan administrere disse nøgler gennem RKeys interface. Og så får vi adgang til vores Redisson-objekter ved hjælp af disse nøgler.

Der er flere muligheder, vi kan bruge til at hente Redis-tasterne.

Vi kan nemt få alle nøglerne:

RKeys-nøgler = client.getKeys ();

Alternativt kan vi kun udtrække navnene:

Iterable allKeys = keys.getKeys ();

Og endelig er vi i stand til at få nøglerne til at overholde et mønster:

Iterable keysByPattern = keys.getKeysByPattern ('nøgle *')

RKeys-grænsefladen tillader også sletning af nøgler, sletning af nøgler efter mønster og andre nyttige nøglebaserede operationer, som vi kunne bruge til at styre vores nøgler og objekter.

Distribuerede objekter leveret af Redisson inkluderer:

• ObjectHolder
• BinaryStreamHolder
• GeospatialHolder
• BitSet
• AtomicLong
• AtomicDouble
• Emne
• BloomFilter
• HyperLogLog

Lad os se på tre af disse objekter: ObjectHolder, AtomicLong, og Emne.

5.1. Objektholder

Repræsenteret af RBucket klasse, kan dette objekt indeholde enhver form for objekt. Dette objekt har en maksimal størrelse på 512MB:

RBucket bucket = client.getBucket ("ledger"); bucket.set (ny Ledger ()); Hovedbogsbog = bucket.get ();

Det RBucket objekt kan udføre atomoperationer såsom sammenlignAndSet oggetAndSet på genstande, den holder.

5.2. AtomicLong

Repræsenteret af RAtomicLong klasse, dette objekt ligner meget java.util.concurrent.atomic.AtomicLong klasse og repræsenterer en lang værdi, der kan opdateres atomisk:

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

5.3. Emne

Det Emne objekt understøtter Redis '"publish and subscribe" -mekanisme. Sådan lytter du efter offentliggjorte meddelelser:

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

Ovenfor Emne er registreret for at lytte til beskeder fra “baeldung” -kanalen. Vi tilføjer derefter en lytter til emnet for at håndtere indgående beskeder fra den kanal. Vi kan tilføje flere lyttere til en kanal.

Lad os offentliggøre beskeder til kanalen “baeldung”:

RTopic publishTopic = client.getTopic ("baeldung"); lange clientsReceivedMessage = publishTopic.publish (ny CustomMessage ("Dette er en besked"));

Dette kan blive offentliggjort fra en anden applikation eller server. Det CustomMessage objekt modtages af lytteren og behandles som defineret i onMessage metode.

Vi kan lære mere om andre Redisson-objekter her.

6. Samlinger

Vi håndterer Redisson-samlinger på samme måde som vi håndterer objekter.

Distribuerede samlinger leveret af Redisson inkluderer:

• Kort
• Multimap
• Sæt
• SortedSet
• ScoredSortedSet
• LexSortedSet
• Liste
• Kø
• Deque
• BlockingQueue
• BoundedBlockingQueue
• BlockingDeque
• BlockingFairQueue
• Forsinket kø
• PriorityQueue
• PriorityDeque

Lad os se på tre af disse samlinger: Kort, sæt, og Liste.

6.1. Kort

Redisson-baserede kort implementerer java.util.concurrent.ConcurrentMap og java.util.Kort grænseflader. Redisson har fire kortimplementeringer. Disse er RMap, RMapCache, RLocalCachedMap og RClusteredMap.

Lad os oprette et kort med Redisson:

RMap map = client.getMap ("ledger"); Ledger newLedger = map.put ("123", ny Ledger ()); kort

RMapCache understøtter udsendelse af kortindtastning. RLocalCachedMap tillader lokal caching af kortindgange. RClusteredMap gør det muligt at opdele data fra et enkelt kort på tværs af Redis-klyngemasternoder.

Vi kan lære mere om Redisson-kort her.

6.2. Sæt

Redisson-baseret Sæt implementerer java.util.Set interface.

Redisson har tre Sæt implementeringer, RSæt, RSetCacheog RClusteredSet med lignende funktionalitet som deres kortmodstykker.

Lad os oprette en Sæt med Redisson:

RSet ledgerSet = client.getSet ("ledgerSet"); ledgerSet.add (ny Ledger ());

Vi kan lære mere om Redisson-sæt her.

6.3. Liste

Redisson-baseret Lister implementere java.util.List interface.

Lad os oprette en Liste med Redisson:

RList ledgerList = client.getList ("ledgerList"); ledgerList.add (ny Ledger ());

Vi kan lære mere om andre Redisson-samlinger her.

7. Låse og synkronisering

Redissons distribuerede låse giver mulighed for trådsynkronisering på tværs af applikationer / servere. Redissons liste over låse og synkronisatorer inkluderer:

• Låse
• FairLock
• MultiLock
• ReadWriteLock
• Semafor
• PermitExpizableSemaphore
• CountDownLatch

Lad os se på Låse og MultiLock.

7.1. Låse

Redissons Låse redskaber java.util.concurrent.locks.Lock interface.

Lad os implementere en lås, repræsenteret af RLås klasse:

RLock-lås = client.getLock ("lås"); lock.lock (); // udføre nogle lange operationer ... lock.unlock ();

7.2. MultiLock

Redissons RedissonMultiLock grupper flere RLås genstande og behandler dem som en enkelt lås:

RLock lock1 = clientInstance1.getLock ("lock1"); RLock lock2 = clientInstance2.getLock ("lock2"); RLock lock3 = clientInstance3.getLock ("lock3"); RedissonMultiLock-lås = ny RedissonMultiLock (lås1, lås2, lås3); lock.lock (); // udfør langvarig operation ... lock.unlock ();

Vi kan lære mere om andre låse her.

8. Tjenester

Redisson udsætter 4 typer distribuerede tjenester. Disse er: Fjernbetjening, Live objekt service, Eksekutortjeneste og Planlagt eksekutortjeneste. Lad os se på Remote Service og Live Object Service.

8.1. Fjernbetjening

Denne service leverer Java-fjernbetjeningsmetode påkaldt af Redis. En Redisson-fjerntjeneste består af en serverside (arbejdstagerinstans) og implementering af klientsiden. Implementeringen på serversiden udfører en fjernmetode, der påberåbes af klienten. Opkald fra en fjerntjeneste kan være synkron eller asynkron.

Serversiden registrerer en grænseflade til fjernanvendelse:

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

Klientsiden kalder en metode til den registrerede eksterne grænseflade:

RRemoteService remoteService = client.getRemoteService (); LedgerServiceInterface ledgerService = remoteService.get (LedgerServiceInterface.class); Listeindgange = ledgerService.getEntries (10);

Vi kan lære mere om fjerntjenester her.

8.2. Live objekt service

Redisson Live Objects udvider konceptet med standard Java-objekter, der kun kunne tilgås fra en enkelt JVM til forbedrede Java-objekter, der kunne deles mellem forskellige JVM'er på forskellige maskiner. Dette opnås ved at kortlægge et objekts felter til en Redis-hash. Denne kortlægning foretages gennem en runtime-konstrueret proxy-klasse. Feltbestillere og -sættere kortlægges til Redis hget / hset-kommandoer.

Redisson Live Objects understøtter adgang til atomfelt som et resultat af Redis 'single-threaded natur.

Oprettelse af et levende objekt er enkelt:

@REntity offentlig klasse LedgerLiveObject {@RId privat strengnavn; // getters og setters ...}

Vi kommenterer vores klasse med @Rentity og et unikt eller identificerende felt med @RId. Når vi har gjort dette, kan vi bruge vores Live Object i vores applikation:

RLiveObjectService service = client.getLiveObjectService (); LedgerLiveObject ledger = ny LedgerLiveObject (); ledger.setName ("ledger1"); ledger = service.persist (ledger);

Vi opretter vores Live Object som standard Java-objekter ved hjælp af ny nøgleord. Vi bruger derefter en forekomst af RLiveObjectService for at gemme objektet til Redis ved hjælp af dets vedvarer metode.

Hvis objektet tidligere er vedvarende til Redis, kan vi hente objektet:

LedgerLiveObject returnLedger = service.get (LedgerLiveObject.class, "ledger1");

Vi bruger RLiveObjectService for at få vores Live Object ved hjælp af feltet kommenteret med @RId.

Her kan vi finde mere om Redisson Live Objects, og andre Redisson-tjenester er beskrevet her.

9. Rørledning

Redisson understøtter rørledning. Flere operationer kan batches som en enkelt atomoperation. Dette letter af RBatch klasse. Flere kommandoer aggregeres mod et RBatch objektinstans, før de udføres:

RBatch batch = client.createBatch (); batch.getMap ("ledgerMap"). fastPutAsync ("1", "2"); batch.getMap ("ledgerMap"). putAsync ("2", "5"); BatchResult batchResult = batch.execute ();

10. Scripting

Redisson understøtter LUA-scripting. Vi kan udføre LUA-scripts mod Redis:

client.getBucket ("foo"). sæt ("bar"); String result = client.getScript (). Eval (Mode.READ_ONLY, "return redis.call ('get', 'foo')", RScript.ReturnType.VALUE);

11. Lavt niveau klient

Det er muligt, at vi måske vil udføre Redis-operationer, der endnu ikke understøttes af Redisson. Redisson leverer en klient på lavt niveau, der tillader udførelse af native Redis-kommandoer:

RedisClientConfig redisClientConfig = ny RedisClientConfig (); redisClientConfig.setAddress ("localhost", 6379); RedisClient-klient = RedisClient.create (redisClientConfig); RedisConnection connect = client.connect (); conn.sync (StringCodec.INSTANCE, RedisCommands.SET, "test", 0); conn.closeAsync (); client.shutdown ();

Klienten på lavt niveau understøtter også asynkrone operationer.

12. Konklusion

Denne artikel viste Redisson og nogle af de funktioner, der gør den ideel til udvikling af distribuerede applikationer. Vi udforskede dets distribuerede objekter, samlinger, låse og tjenester. Vi udforskede også nogle af dens andre funktioner såsom pipelining, scripting og dens klient på lavt niveau.

Redisson giver også integration med andre rammer såsom JCache API, Spring Cache, Hibernate Cache og Spring Sessions. Vi kan lære mere om dets integration med andre rammer her.

Du kan finde kodeeksempler i GitHub-projektet.