TOC

Ein Leitfaden für Redis mit Redisson

Ein Leitfaden für Redis mit Redisson

1. Überblick

Redisson is a Redis client for Java. In diesem Artikel werden einige seiner Funktionen erläutert und gezeigt, wie das Erstellen verteilter Geschäftsanwendungen erleichtert werden kann.

Redisson constitutes an in-memory data grid bietet verteilte Java-Objekte und -Dienste, die von Redis unterstützt werden. Das verteilte speicherinterne Datenmodell ermöglicht die gemeinsame Nutzung von Domänenobjekten und -diensten zwischen Anwendungen und Servern.

In diesem Artikel erfahren Sie, wie Sie Redisson einrichten, seine Funktionsweise verstehen und einige der Objekte und Dienste von Redisson untersuchen.

2. Maven-Abhängigkeiten

Beginnen wir mit dem Importieren vonRedisson in unser Projekt, indem wir den folgenden Abschnitt zu unserenpom.xml: hinzufügen 


    org.redisson
    redisson
    3.3.0

Die neueste Version dieser Abhängigkeit befindet sich inhere.

3. Aufbau

Bevor wir beginnen, müssen wir sicherstellen, dass die neueste Version von Redis installiert ist und ausgeführt wird. Wenn Sie kein Redis haben und Linux oder Macintosh verwenden, können Sie den Informationenhere folgen, um es einzurichten. Wenn Sie ein Windows-Benutzer sind, können Sie Redis mit diesen inoffiziellenport einrichten.

Wir müssen Redisson konfigurieren, um eine Verbindung zu Redis herzustellen. Redisson unterstützt Verbindungen zu folgenden Redis-Konfigurationen:

  • Einzelner Knoten

  • Master mit Slave-Knoten

  • Sentinel-Knoten

  • Clustered Nodes

  • Replizierte Knoten

Redisson supports Amazon Web Services (AWS) ElastiCache Cluster and Azure Redis Cache für gruppierte und replizierte Knoten.

Stellen Sie eine Verbindung zu einer einzelnen Knoteninstanz von Redis her. Diese Instanz wird lokal auf dem Standardport 6379 ausgeführt: 

RedissonClient client = Redisson.create();

Sie können verschiedene Konfigurationen an diecreate-Methode desRedisson-Objekts übergeben. Dies können Konfigurationen sein, um eine Verbindung zu einem anderen Port herzustellen, oder um eine Verbindung zu einem Redis-Cluster herzustellen. Dieseconfiguration could be in Java code or loaded from an external configuration file.

3.1. Java-Konfiguration

Konfigurieren wir Redisson in Java-Code: 

Config config = new Config();
config.useSingleServer()
  .setAddress("127.0.0.1:6379");

RedissonClient client = Redisson.create(config);

Wirspecify Redisson configurations in an instance of a Config object und übergeben es dann an diecreate-Methode. Oben haben wir Redisson angegeben, dass wir eine Verbindung zu einer einzelnen Knoteninstanz von Redis herstellen möchten. Dazu haben wir dieuseSingleServer-Methode desConfig-Objekts verwendet. Dies gibt einen Verweis auf einSingleServerConfig-Objekt zurück.

DasSingleServerConfig-Objekt verfügt über Einstellungen, mit denen Redisson eine Verbindung zu einer einzelnen Knoteninstanz von Redis herstellt. Hier verwenden wir die MethodesetAddress, um die Einstellungaddresszu konfigurieren. Hiermit wird die Adresse des Knotens festgelegt, mit dem wir eine Verbindung herstellen. Einige andere Einstellungen umfassenretryAttempts,connectionTimeout undclientName. Diese Einstellungen werden mit den entsprechenden Einstellmethoden konfiguriert.

Wir können Redisson für verschiedene Redis-Konfigurationen auf ähnliche Weise konfigurieren, indem wir die folgenden Methoden desConfig-Objekts verwenden:

  • useSingleServer - für Einzelknoteninstanz. Einzelknoteneinstellungenhere abrufen

  • useMasterSlaveServers - für Master mit Slave-Knoten. Holen Sie sich die Master-Slave-Knoteneinstellungenhere

  • useSentinelServers - für Sentinel-Knoten. Abrufen der Sentinel-Knoteneinstellungenhere

  • useClusterServers - für Clusterknoten. Holen Sie sich die Clustered Node-Einstellungenhere

  • useReplicatedServers - für replizierte Knoten. Replizierte Knoteneinstellungenhere abrufen

3.2. Dateikonfiguration

Redisson can load configurations from external JSON or YAML Dateien: 

Config config = Config.fromJSON(new File("singleNodeConfig.json"));
RedissonClient client = Redisson.create(config);

DiefromJSON-Methode desConfig-Objekts kann Konfigurationen aus einer Zeichenfolge, Datei, einem Eingabestream oder einer URL laden.

Hier ist die Beispielkonfiguration in dersingleNodeConfig.json-Datei: 

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

Hier ist eine entsprechende YAML-Konfigurationsdatei: 

singleServerConfig:
    idleConnectionTimeout: 10000
    pingTimeout: 1000
    connectTimeout: 10000
    timeout: 3000
    retryAttempts: 3
    retryInterval: 1500
    reconnectionTimeout: 3000
    failedAttempts: 3
    password: null
    subscriptionsPerConnection: 5
    clientName: null
    address: "redis://127.0.0.1:6379"
    subscriptionConnectionMinimumIdleSize: 1
    subscriptionConnectionPoolSize: 50
    connectionMinimumIdleSize: 10
    connectionPoolSize: 64
    database: 0
    dnsMonitoring: false
    dnsMonitoringInterval: 5000
threads: 0
nettyThreads: 0
codec: ! {}
useLinuxNativeEpoll: false

Wir können andere Redis-Konfigurationen aus einer Datei auf ähnliche Weise konfigurieren, indem wir Einstellungen verwenden, die für diese Konfiguration spezifisch sind. Zu Ihrer Information hier die JSON- und YAML-Dateiformate:

Um eine Java-Konfiguration im JSON- oder YAML-Format zu speichern, können Sie die MethodentoJSON odertoYAMLdes ObjektsConfigverwenden: 

Config config = new Config();
// ... we configure multiple settings here in Java
String jsonFormat = config.toJSON();
String yamlFormat = config.toYAML();

Nachdem wir nun wissen, wie Redisson konfiguriert wird, schauen wir uns an, wie Redisson Operationen ausführt.

4. Betrieb

Redisson supports synchronous, asynchronous and reactive interfaces. Operationen über dieseninterfaces are thread-safe.

Alle Entitäten (Objekte, Sammlungen, Sperren und Dienste), die vonRedissonClientgeneriert werden, verfügen über synchrone und asynchrone Methoden. Synchronous methods bear asynchronous variants. Diese Methoden tragen normalerweise den gleichen Methodennamen wie ihre synchronen Varianten, denen „Async“ angehängt ist. Schauen wir uns eine synchrone Methode desRAtomicLong-Objekts an: 

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

Die asynchrone Variante der synchronencompareAndSet-Methode wäre: 

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

Die asynchrone Variante der Methode gibt einRFuture-Objekt zurück. Wir können Listener für dieses Objekt festlegen, um das Ergebnis zurückzugewinnen, sobald es verfügbar ist: 

isSet.handle((result, exception) -> {
    // handle the result or exception here.
});

Um reaktive Objekte zu generieren, müssten wirRedissonReactiveClient: `++` verwenden 

RedissonReactiveClient client = Redisson.createReactive();
RAtomicLongReactive myLong = client.getAtomicLong("myLong");

Publisher isSetPublisher = myLong.compareAndSet(5, 28);

Diese Methode gibt reaktive Objekte zurück, die auf demReactive Streams Standard für Java 9 basieren.

Lassen Sie uns einige der verteilten Objekte untersuchen, die von Redisson bereitgestellt werden.

5. Objekte

Eine einzelne Instanz vonRedisson object is serialized and stored in any of the available Redis nodes backing Redisson. Diese Objekte können in einem Cluster auf mehrere Knoten verteilt sein und von einer einzelnen Anwendung oder mehreren Anwendungen / Servern aufgerufen werden.

Diese verteilten Objekte folgen den Spezifikationen vonjava.util.concurrent.atomic package.They support lock-free, thread-safe and atomic operations on objects stored in Redis. Die Datenkonsistenz zwischen Anwendungen / Servern wird sichergestellt, da die Werte nicht aktualisiert werden, während eine andere Anwendung das Objekt liest.

Redisson-Objekte sind an Redis-Schlüssel gebunden. Wir können diese Schlüssel über dieRKeys-Schnittstelle verwalten. Mit diesen Schlüsseln greifen wir auf unsere Redisson-Objekte zu.

Wir können alle Schlüssel bekommen: 

RKeys keys = client.getKeys();

Wir können alle Schlüsselnamen als iterierbare Zeichenfolgensammlungen extrahieren: 

Iterable allKeys = keys.getKeys();

Wir können Schlüssel erhalten, die einem Muster entsprechen: 

Iterable keysByPattern = keys.getKeysByPattern('key*')

Die RKeys-Oberfläche ermöglicht auch das Löschen von Schlüsseln, das Löschen von Schlüsseln nach Muster und andere nützliche schlüsselbasierte Vorgänge, mit denen wir unsere Schlüssel und Objekte verwalten können.

Zu den von Redisson bereitgestellten verteilten Objekten gehören:

  • Objekthalter

  • BinaryStreamHolder

  • GeospatialHolder

  • BitSet

  • AtomicLong

  • AtomicDouble

  • Thema

  • BloomFilter

  • HyperLogLog

Schauen wir uns drei dieser Objekte an:ObjectHolder, AtomicLong, undTopic.

5.1. Objekthalter

Dieses Objekt wird durch die KlasseRBucketdargestellt und kann jeden Objekttyp enthalten. Dieses Objekt hat eine maximale Größe von 512 MB: 

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

Das ObjektRBucketkann atomare Operationen wiecompareAndSet andgetAndSet an Objekten ausführen, die es enthält.

5.2. AtomicLong

Dieses Objekt, das durch die KlasseRAtomicLongdargestellt wird, ähnelt stark der Klassejava.util.concurrent.atomic.AtomicLongund stellt einen Wert vonlongdar, der atomar aktualisiert werden kann: 

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

5.3. Thema

DasTopic-Objekt unterstützt den Redis-Mechanismus "Publish and Subscribe". So warten Sie auf veröffentlichte Nachrichten: 

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

Oben istTopic registriert, um Nachrichten vom Beispielkanal abzuhören. Anschließend fügen wir dem Thema einen Listener hinzu, um eingehende Nachrichten von diesem Kanal zu verarbeiten. Wir können einem Kanal mehrere Listener hinzufügen.

Veröffentlichen wir Nachrichten auf dem "Beispiel" -Kanal: 

RTopic publishTopic = client.getTopic("example");
long clientsReceivedMessage
  = publishTopic.publish(new CustomMessage("This is a message"));

Dies kann von einer anderen Anwendung oder einem anderen Server veröffentlicht werden. DasCustomMessage-Objekt wird vom Listener empfangen und wie in deronMessage-Methode definiert verarbeitet.

Wir können mehr über andere Redisson-Objektehere erfahren.

6. Sammlungen

Wir behandeln Redisson-Sammlungen genauso wie Objekte.

Zu den von Redisson bereitgestellten verteilten Sammlungen gehören:

  • Map

  • Multimap

  • Set

  • SortedSet

  • ScoredSortedSet

  • LexSortedSet

  • List

  • Warteschlange

  • Deque

  • BlockingQueue

  • BoundedBlockingQueue

  • BlockingDeque

  • BlockingFairQueue

  • DelayedQueue

  • Prioritätswarteschlange

  • PriorityDeque

Schauen wir uns drei dieser Sammlungen an:Map, Set, undList.

6.1. Map

Redisson-basierte Karten implementieren die Schnittstellenjava.util.concurrent.ConcurrentMap undjava.util.Map. Redisson verfügt über vier Kartenimplementierungen. Dies sindRMap,RMapCache,RLocalCachedMap undRClusteredMap.

Erstellen wir mit Redisson eine Karte: 

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

RMapCache unterstützt die Räumung von Karteneinträgen. RLocalCachedMap ermöglicht das lokale Caching von Karteneinträgen. RClusteredMap ermöglicht die Aufteilung von Daten aus einer einzelnen Karte auf Redis-Cluster-Masterknoten.

Wir können mehr über Redisson Mapshere erfahren.

6.2. Set

Redisson-basiertesSet implementiert diejava.util.Set-Schnittstelle.

Redisson verfügt über dreiSet-Implementierungen,RSet,RSetCache undRClusteredSet mit ähnlichen Funktionen wie ihre Karten-Gegenstücke.

Erstellen wir mit Redisson einSet: 

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

Wir können mehr über Redisson-Mengenhere erfahren.

6.3. List

Redisson-basierteListsimplementieren diejava.util.List-Schnittstelle.

Erstellen wir mit Redisson einList: 

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

Wir können mehr über andere Redisson-Sammlungenhereerfahren.

7. Schlösser und Synchronisierer

distributed locks allow for thread synchronizationvon Redisson über Anwendungen / Server hinweg. Redissons Liste der Sperren und Synchronisierer umfasst:

  • Lock

  • FairLock

  • MultiLock

  • ReadWriteLock

  • Semaphor

  • PermitExpiringSemaphore

  • CountDownLatch

Schauen wir unsLock undMultiLock. an

7.1. Lock

RedissonsLockimplementiert diejava.util.concurrent.locks.Lock-Schnittstelle.

Implementieren wir eine Sperre, die durch die KlasseRLockdargestellt wird: 

RLock lock = client.getLock("lock");
lock.lock();
// perform some long operations...
lock.unlock();

7.2. MultiLock

RedissonMultiLockvon Redisson gruppiert mehrereRLock-Objekte und behandelt sie als eine einzige Sperre: 

RLock lock1 = clientInstance1.getLock("lock1");
RLock lock2 = clientInstance2.getLock("lock2");
RLock lock3 = clientInstance3.getLock("lock3");

RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
lock.lock();
// perform long running operation...
lock.unlock();

Wir können mehr über andere Sperrenhere erfahren.

8. Dienstleistungen

Redisson macht 4 Arten von verteilten Diensten verfügbar. Dies sind:Remote Service,Live Object Service,Executor Service undScheduled Executor Service. Schauen wir uns den Remote Service und den Live Object Service an.

8.1. Remote-Service

Dieser Service bietetJava remote method invocation facilitated by Redis. Ein Redisson-Remote-Service besteht aus einer serverseitigen (Worker-Instanz) und einer clientseitigen Implementierung. Die serverseitige Implementierung führt eine vom Client aufgerufene Remotemethode aus. Anrufe von einem entfernten Dienst können synchron oder asynchron sein.

Die Serverseite registriert eine Schnittstelle für den Remote-Aufruf: 

RRemoteService remoteService = client.getRemoteService();
LedgerServiceImpl ledgerServiceImpl = new LedgerServiceImpl();

remoteService.register(LedgerServiceInterface.class, ledgerServiceImpl);

Die Client-Seite ruft eine Methode der registrierten Remote-Schnittstelle auf: 

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

List entries = ledgerService.getEntries(10);

Wir können mehr über Remote Serviceshere erfahren.

8.2. Live Object Service

Redisson Live Objects erweitert das Konzept von Standard-Java-Objekten, auf die nur von einer einzelnen JVM aus zugegriffen werden kann, aufenhanced Java objects that could be shared between different JVMs in different machines. Dies wird erreicht, indem die Felder eines Objekts einem Redis-Hash zugeordnet werden. Diese Zuordnung erfolgt über eine zur Laufzeit erstellte Proxy-Klasse. Feld-Getter und Setter werden Redis-Hget / Hset-Befehlen zugeordnet.

Redisson Live Objects unterstützen den Zugriff auf Atomfelder aufgrund der Singlethreading-Funktion von Redis.

Das Erstellen eines Live-Objekts ist einfach: 

@REntity
public class LedgerLiveObject {
    @RId
    private String name;

    // getters and setters...
}

Wir kommentieren unsere Klasse mit@REntity und ein eindeutiges oder identifizierendes Feld mit@RId. Sobald wir dies getan haben, können wir unser Live-Objekt in unserer Anwendung verwenden: 

RLiveObjectService service = client.getLiveObjectService();

LedgerLiveObject ledger = new LedgerLiveObject();
ledger.setName("ledger1");

ledger = service.persist(ledger);

Wir erstellen unser Live-Objekt wie Standard-Java-Objekte mit dem Schlüsselwortnew. Wir verwenden dann eine Instanz vonRLiveObjectService, um das Objekt mit der Methodepersist in Redis zu speichern.

Wenn das Objekt zuvor in Redis beibehalten wurde, können wir das Objekt abrufen: 

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

Wir verwendenRLiveObjectService, um unser Live-Objekt mithilfe des mit@RId versehenen Felds abzurufen.

Wir können mehr über Redisson Live Objectshere erfahren.

Wir können auch mehr über andere Redisson-Dienstehereerfahren.

9. Pipelining

Redisson unterstützt Pipelining. Multiple operations can be batched as a single atomic operation. Dies wird durch die KlasseRBatcherleichtert. Mehrere Befehle werden vor ihrer Ausführung gegen die Objektinstanz einesRBatchaggregiert: 

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

List result = batch.execute();

10. Scripting

Redisson unterstützt LUA-Scripting. We can execute LUA scripts against Redis: 

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

11. Low-Level-Client

Möglicherweise möchten wir Redis-Operationen ausführen, die noch nicht von Redisson unterstützt werden. Redisson provides a low-level client that allows execution of native Redis commands: 

RedisClient client = new RedisClient("localhost", 6379);
RedisConnection conn = client.connect();
conn.sync(StringCodec.INSTANCE, RedisCommands.SET, "test", 0);

conn.closeAsync();
client.shutdown();

Der Low-Level-Client unterstützt auch asynchrone Vorgänge.

12. Fazit

In diesem Artikel wurden Redisson und einige der Funktionen vorgestellt, die es ideal für die Entwicklung verteilter Anwendungen machen. Wir haben die verteilten Objekte, Sammlungen, Schlösser und Dienste untersucht. Wir haben auch einige seiner anderen Funktionen wie Pipelining, Scripting und seinen Low-Level-Client untersucht.

Redisson also provides integration with other frameworks wie die JCache-API, Spring Cache, Hibernate Cache und Spring Sessions. Wir können mehr über die Integration mit anderen Frameworkshereerfahren.

Codebeispiele finden Sie inGitHub project.

Related