streamalism.org

1. Oversikt

Redisson er en Redis-klient for Java. I denne artikkelen vil vi utforske noen av funksjonene, og demonstrere hvordan det kan legge til rette for å bygge distribuerte forretningsapplikasjoner.

Redisson utgjør et datarutenett i minnet som tilbyr distribuerte Java-objekter og tjenester støttet av Redis. Den distribuerte dataminnemodellen tillater deling av domeneobjekter og tjenester på tvers av applikasjoner og servere.

I denne artikkelen ser vi varmt å sette opp Redisson, forstå hvordan det fungerer, og utforske noen av Redissons objekter og tjenester.

2. Maven-avhengigheter

La oss komme i gang med å importere Redisson til prosjektet vårt ved å legge til delen nedenfor i vår pom.xml:

 org.redisson redisson 3.13.1 

Den siste versjonen av denne avhengigheten finner du her.

3. Konfigurasjon

Før vi setter i gang, må vi sørge for at vi har den nyeste versjonen av Redis oppsett og kjører. Hvis du ikke har Redis og bruker Linux eller Macintosh, kan du følge informasjonen her for å få den konfigurert. Hvis du er Windows-bruker, kan du konfigurere Redis ved hjelp av denne uoffisielle porten.

Vi må konfigurere Redisson for å koble til Redis. Redisson støtter tilkoblinger til følgende Redis-konfigurasjoner:

• Enkelt node
• Mester med slaveknuter
• Sentinel noder
• Klyngede noder
• Replikerte noder

Redisson støtter Amazon Web Services (AWS) ElastiCache Cluster og Azure Redis Cache for klyngede og replikerte noder.

La oss koble til en enkelt node-forekomst av Redis. Denne forekomsten kjører lokalt på standardporten, 6379:

RedissonClient-klient = Redisson.create ();

Du kan sende forskjellige konfigurasjoner til Redisson objektets skape metode. Dette kan være konfigurasjoner for å koble den til en annen port, eller kanskje for å koble til en Redis-klynge. Dette konfigurasjonen kan være i Java-kode eller lastet fra en ekstern konfigurasjonsfil.

3.1. Java-konfigurasjon

La oss konfigurere Redisson i Java-kode:

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

Vi spesifiser Redisson-konfigurasjoner i en forekomst av en Konfig gjenstand og send den deretter til skape metode. Ovenfor spesifiserte vi til Redisson at vi vil koble til en enkelt node-forekomst av Redis. For å gjøre dette brukte vi Konfig objektets brukSingleServer metode. Dette returnerer en referanse til a SingleServerConfig gjenstand.

De SingleServerConfig objektet har innstillinger som Redisson bruker for å koble til en enkelt node-forekomst av Redis. Her bruker vi dens setAddress metoden for å konfigurere adresse omgivelser. Dette angir adressen til noden vi kobler til. Noen andre innstillinger inkluderer prøv på nytt, connectionTimeout og Klientens navn. Disse innstillingene konfigureres ved hjelp av deres tilsvarende settermetoder.

Vi kan konfigurere Redisson for forskjellige Redis-konfigurasjoner på en lignende måte ved hjelp av Konfig objektets følgende metoder:

• brukSingleServer - for forekomst av en enkelt node. Få innstillinger for enkeltnoder her
• useMasterSlaveServers - for mester med slaveknuter. Få master-slave node-innstillinger her
• useSentinelServers - for sentinel noder. Få innstillinger for sentinalknuter her
• useClusterServers - for klyngede noder. Få klyngede nodeinnstillinger her
• useReplicatedServers - for replikerte noder. Få replikerte nodeinnstillinger her

3.2. Filkonfigurasjon

Redisson kan laste konfigurasjoner fra ekstern JSON eller YAML filer:

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

De Konfig objektets fraJSON metoden kan laste konfigurasjoner fra en streng, fil, inngangsstrøm eller URL.

Her er eksempelkonfigurasjonen 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-konfigurasjonsfil:

singleServerConfig: idleConnectionTimeout: 10000 connectTimeout: 10000 timeout: 3000 retryAttfors: 3 retryInterval: 1500 password: null subscribersPerConnection: 5 clientName: null address: "redis: //127.0.0.1: 6379" subscriptionConnectionMinimumIdleSize: 1 abonnementConnectionPoolSize: Minimum 64 database: 0 dnsMonitoringInterval: 5000 tråder: 0 nettyTråder: 0 codec:! {} 

Vi kan konfigurere andre Redis-konfigurasjoner fra en fil på en lignende måte ved hjelp av innstillinger som er spesielle for den konfigurasjonen. For din referanse, her er deres JSON og YAML filformater:

• Enkelt node - format
• Master med slave noder - format
• Sentinel noder - format
• Klyngede noder - format
• Replikerte noder - format

For å lagre en Java-konfigurasjon i JSON- eller YAML-format, kan vi bruke toJSON eller toYAML metoder for Konfig gjenstand:

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

Nå som vi vet hvordan vi skal konfigurere Redisson, la oss se på hvordan Redisson utfører operasjoner.

4. Drift

Redisson støtter synkrone, asynkrone og reaktive grensesnitt. Operasjoner over disse grensesnitt er trådsikre.

Alle enheter (objekter, samlinger, låser og tjenester) generert av en Redisson klient har synkrone og asynkrone metoder. Synkrone metoder har asynkrone varianter. Disse metodene bærer normalt samme metodenavn på deres synkrone varianter som er lagt til med "Async". La oss se på en synkron metode for RAtomicLong gjenstand:

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

Den asynkrone varianten av den synkrone sammenlignAndSet metoden vil være:

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

Den asynkrone varianten av metoden returnerer en RFutur gjenstand. Vi kan stille lyttere til dette objektet for å få tilbake resultatet når det blir tilgjengelig:

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

For å generere reaktive objekter, må vi bruke RedissonReactiveClient:

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

Denne metoden returnerer reaktive objekter basert på Reactive Streams Standard for Java 9.

La oss utforske noen av de distribuerte objektene som Redisson tilbyr.

5. Objekter

En individuell forekomst av en Redisson-objektet serialiseres og lagres i en hvilken som helst av de tilgjengelige Redis-noder som støtter Redisson. Disse objektene kan distribueres i en klynge over flere noder og kan nås av et enkelt program eller flere applikasjoner / servere.

Disse distribuerte objektene følger spesifikasjonene fra java.util.concurrent.atomic-pakke. De støtter låsfrie, trådsikre og atomoperasjoner på gjenstander lagret i Redis. Datakonsistens mellom applikasjoner / servere sikres ettersom verdiene ikke oppdateres mens et annet program leser objektet.

Redisson-objekter er bundet til Redis-tastene. Vi kan administrere disse nøklene gjennom RKeys grensesnitt. Og så får vi tilgang til Redisson-objektene våre ved hjelp av disse tastene.

Det er flere alternativer vi kan bruke for å få Redis-tastene.

Vi kan enkelt få alle nøklene:

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

Alternativt kan vi bare trekke ut navnene:

Iterable allKeys = keys.getKeys ();

Og til slutt kan vi få nøklene til å være i samsvar med et mønster:

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

RKeys-grensesnittet tillater også sletting av nøkler, sletting av nøkler etter mønster og andre nyttige nøkkelbaserte operasjoner som vi kan bruke til å administrere nøklene og objektene våre.

Distribuerte objekter levert av Redisson inkluderer:

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

La oss ta en titt på tre av disse objektene: ObjectHolder, AtomicLong, og Emne.

5.1. Objektholder

Representert av RBucket klasse, kan dette objektet inneholde alle typer objekter. Dette objektet har en maksimal størrelse på 512 MB:

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

De RBucket objekt kan utføre atomoperasjoner som sammenlignAndSet oggetAndSet på gjenstander den holder.

5.2. AtomicLong

Representert av RAtomicLong klasse, ligner dette objektet tett på java.util.concurrent.atomic.AtomicLong klasse og representerer en lang verdi som kan oppdateres atomisk:

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

5.3. Emne

De Emne objekt støtter Redis 'publiser og abonner-mekanisme. For å lytte etter publiserte meldinger:

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

Over Emne er registrert for å lytte til meldinger fra “baeldung” -kanalen. Deretter legger vi til en lytter til emnet for å håndtere innkommende meldinger fra den kanalen. Vi kan legge til flere lyttere til en kanal.

La oss publisere meldinger til "baeldung" -kanalen:

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

Dette kan publiseres fra et annet program eller en annen server. De CustomMessage objektet vil bli mottatt av lytteren og behandlet som definert i onMessage metode.

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

6. Samlinger

Vi håndterer Redisson-samlinger på samme måte som vi håndterer gjenstander.

Distribuerte samlinger levert av Redisson inkluderer:

• Kart
• Multikart
• Sett
• SortedSet
• ScoredSortedSet
• LexSortedSet
• Liste
• Kø
• Deque
• BlockingQueue
• BoundedBlockingQueue
• BlokkeringDeque
• BlokkererFairQueue
• Forsinket kø
• PriorityQueue
• PriorityDeque

La oss ta en titt på tre av disse samlingene: Kart, sett, og Liste.

6.1. Kart

Redisson-baserte kart implementerer java.util.concurrent.ConcurrentMap og java.util.Kart grensesnitt. Redisson har fire kartimplementeringer. Disse er RMap, RMapCache, RLocalCachedMap og RClusteredMap.

La oss lage et kart med Redisson:

RMap map = client.getMap ("reskontro"); Ledger newLedger = map.put ("123", new Ledger ()); kart

RMapCache støtter bortføring av kart. RLocalCachedMap tillater lokal caching av kartoppføringer. RClusteredMap tillater at data fra et enkelt kart blir delt over Redis-klyngemasternoder.

Vi kan lære mer om Redisson-kart her.

6.2. Sett

Redisson basert Sett implementerer java.util.Sett grensesnitt.

Redisson har tre Sett implementeringer, RSett, RSetCache, og RClusteredSet med lignende funksjonalitet som deres kolleger.

La oss lage en Sett med Redisson:

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

Vi kan lære mer om Redisson-sett her.

6.3. Liste

Redisson-basert Lister implementere java.util.Liste grensesnitt.

La oss lage en Liste med Redisson:

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

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

7. Låser og synkroniserer

Redissons distribuerte låser tillater trådsynkronisering på tvers av applikasjoner / servere. Redissons liste over låser og synkroniseringer inkluderer:

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

La oss ta en titt på Låse og MultiLock.

7.1. Låse

Redissons Låse redskaper java.util.concurrent.locks.Lock grensesnitt.

La oss implementere en lås, representert av RLås klasse:

RLock-lås = client.getLock ("lås"); lock.lock (); // utføre noen lange operasjoner ... lock.unlock ();

7.2. MultiLock

Redissons RedissonMultiLock grupper flere RLås gjenstander 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 (); // utføre langvarig operasjon ... lock.unlock ();

Vi kan lære mer om andre låser her.

8. Tjenester

Redisson eksponerer 4 typer distribuerte tjenester. Disse er: Fjerntjeneste, Live Object Service, Eksekutortjeneste og Planlagt eksekutortjeneste. La oss se på tjenesten Remote Service og Live Object.

8.1. Fjerntjeneste

Denne tjenesten gir Java ekstern metodeinnkalling tilrettelagt av Redis. En ekstern Redisson-tjeneste består av en server-side (arbeiderinstans) og implementering av klientsiden. Implementeringen på serversiden utfører en ekstern metode som påkalles av klienten. Anrop fra en ekstern tjeneste kan være synkrone eller asynkrone.

Server-siden registrerer et grensesnitt for ekstern påkallelse:

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

Klientsiden kaller en metode for det registrerte eksterne grensesnittet:

RRemoteService remoteService = client.getRemoteService (); LedgerServiceInterface ledgerService = remoteService.get (LedgerServiceInterface.class); Listeoppføringer = ledgerService.getEntries (10);

Vi kan lære mer om eksterne tjenester her.

8.2. Live Object Service

Redisson Live Objects utvider konseptet med standard Java-objekter som bare kan nås fra en enkelt JVM til forbedrede Java-objekter som kan deles mellom forskjellige JVM-er i forskjellige maskiner. Dette oppnås ved å kartlegge et objekts felt til en Redis-hash. Denne kartleggingen gjøres gjennom en runtime-konstruert proxy-klasse. Feltopptakere og settere blir kartlagt til Redis hget / hset-kommandoer.

Redisson Live Objects støtter tilgang til atomfelt som et resultat av Redis 'single-threaded nature.

Å lage et levende objekt er enkelt:

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

Vi kommenterer klassen vår med @Rentity og et unikt eller identifiserende felt med @Kvitt. Når vi har gjort dette, kan vi bruke vårt Live Object i applikasjonen vår:

RLiveObjectService-tjeneste = client.getLiveObjectService (); LedgerLiveObject ledger = new LedgerLiveObject (); ledger.setName ("ledger1"); reskontro = service.persist (reskontro);

Vi lager vårt Live Object som standard Java-objekter ved hjelp av ny nøkkelord. Vi bruker deretter en forekomst av RLiveObjectService for å lagre objektet til Redis ved hjelp av fortsette metode.

Hvis objektet tidligere har blitt vedvaret til Redis, kan vi hente objektet:

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

Vi bruker RLiveObjectService for å få vårt Live Object ved hjelp av feltet kommentert med @Kvitt.

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

9. Rørledning

Redisson støtter rørledninger. Flere operasjoner kan batches som en enkelt atomoperasjon. Dette blir lettere av RBatch klasse. Flere kommandoer blir samlet mot en RBatch objektforekomst før de kjøres:

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

10. Skripting

Redisson støtter LUA-skripting. Vi kan utføre LUA-skript mot Redis:

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

11. Lavnivåklient

Det er mulig at vi kanskje vil utføre Redis-operasjoner som ennå ikke støttes av Redisson. Redisson tilbyr en klient på lavt nivå som tillater kjøring av innfødte Redis-kommandoer:

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

Klienten på lavt nivå støtter også asynkrone operasjoner.

12. Konklusjon

Denne artikkelen viste Redisson og noen av funksjonene som gjør den ideell for utvikling av distribuerte applikasjoner. Vi utforsket distribuerte objekter, samlinger, låser og tjenester. Vi utforsket også noen av de andre funksjonene som rørledning, skripting og klienten på lavt nivå.

Redisson gir også integrasjon med andre rammer som JCache API, Spring Cache, Hibernate Cache og Spring Sessions. Vi kan lære mer om integrasjonen med andre rammer her.

Du kan finne kodeeksempler i GitHub-prosjektet.