Обзор Redisson: клиент Redis Java

Почему Редиссон?

Redis — это хранилище структуры данных с открытым исходным кодом в памяти, которое можно использовать как базу данных ключей NoSQL, а также как кеш и брокер сообщений.

С молниеносной скоростью, высокой доступностью и масштабируемостью и поддержкой широкого спектра структур данных неудивительно, что разработчики используют Redis для создания отказоустойчивых и высокопроизводительных нереляционных баз данных.

Согласно опросу 2019 года, посвященному программированию веб-сайта Stack Overflow, Redis является «самой любимой» технологией баз данных , опережая более устоявшиеся альтернативы, такие как Oracle, MySQL, Microsoft SQL Server и MongoDB.

Вам также может понравиться:
Распределенные коллекции Java в Redis с Redisson

Хотя Redis обладает множеством функций и преимуществ, пользователи должны знать, что Redis не совместим с такими языками программирования, как Java, из коробки. Скорее, пользователи, которые хотят использовать Redis с Java, должны использовать стороннюю клиентскую библиотеку Java для Redis, такую ​​как Redisson.

Redisson — это клиент Redis для Java, который предлагает сетку данных в памяти с поддержкой многих знакомых коллекций, объектов и сервисов Java. Этот богатый набор функций позволяет разработчикам Java быстро и легко приступить к работе с Redis, используя соглашения, с которыми они знакомы.

Redisson позволяет разработчикам уделять меньше времени программному аспекту Redis и уделять больше времени таким важным задачам, как моделирование данных и логика приложения.

Основанный на асинхронной управляемой событиями среде клиент-сервер Netty , Redisson совместим с Redis 2.8+ и JDK 1.8+. Redisson поставляется в двух версиях: проект Redisson с открытым исходным кодом и Redisson PRO , который имеет большую скорость и дополнительную функциональность.

В этой статье будет представлен полный обзор всего, что вам нужно знать о работе с Redisson: настройка Redisson, настройка Redis с Redisson, использование объектов Java и коллекций в Redis с Redisson, другие функции Redisson.

Maven Dependency

Большие, сложные Java-проекты часто используют инструменты автоматизации сборки, такие как Apache Maven . Если вы используете Maven для создания своего Java-проекта, включить поддержку Redisson очень просто. Просто включите следующие строки в ваш файл pom.xml :

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.11.5</version>
</dependency>

compile 'org.redisson:redisson:3.11.5'

RedissonClient client = Redisson.create();

Config config = new Config();
config.useSingleServer()
.setAddress("127.0.0.1:6379");
RedissonClient client = Redisson.create(config);

Config config = Config.fromYAML(new File("redisson.yaml"));  
RedissonClient client = Redisson.create(config);

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: !<org.redisson.codec.FstCodec> {}
useLinuxNativeEpoll: false

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

RBinaryStream stream = redisson.getBinaryStream("anyStream");
byte[] content = ...
stream.set(content);

InputStream is = stream.getInputStream();
byte[] readBuffer = new byte[512];
is.read(readBuffer);

OutputStream os = stream.getOuputStream();
byte[] contentToWrite = ...
os.write(contentToWrite);

RGeo<String> geo = redisson.getGeo("test");
geo.add(new GeoEntry(13.361389, 38.115556, "Palermo"), 
new GeoEntry(15.087269, 37.502669, "Catania"));
geo.addAsync(37.618423, 55.751244, "Moscow");

RBitSet set = redisson.getBitSet("simpleBitset");
set.set(0, true);
set.set(1812, false);
set.clear(0);

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

RAtomicDouble atomicDouble = redisson.getAtomicDouble("myAtomicDouble");
atomicDouble.set(2.81);
atomicDouble.addAndGet(4.11);

RTopic topic = redisson.getTopic("anyTopic");
topic.addListener(SomeObject.class, new MessageListener<SomeObject>() {
    @Override
    public void onMessage(String channel, SomeObject message) {
        //...
    }
});

RBloomFilter<SomeObject> bloomFilter = redisson.getBloomFilter("sample");
// initialize bloom filter with 
// expectedInsertions = 55000000
// falseProbability = 0.03
bloomFilter.tryInit(55000000L, 0.03);
bloomFilter.add(new SomeObject("field1Value", "field2Value"));
bloomFilter.add(new SomeObject("field5Value", "field8Value"));
bloomFilter.contains(new SomeObject("field1Value", "field8Value"));

RHyperLogLog<Integer> log = redisson.getHyperLogLog("log");
log.add(1);
log.add(2);
log.add(3);
log.count();

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

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();

RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.acquire();
// or
semaphore.acquireAsync();
semaphore.acquire(23);
semaphore.tryAcquire();

semaphore.releaseAsync();

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

remoteService.register(LedgerServiceInterface.class, ledgerServiceImpl);

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

List<String> entries = ledgerService.getEntries(10);

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

    // getters and setters...
}

RLiveObjectService service = client.getLiveObjectService();

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

ledger = service.persist(ledger);

RTransaction transaction = redisson.createTransaction(TransactionOptions.defaults());

RMap<String, String> map = transaction.getMap("myMap");
map.put("1", "2");
String value = map.get("3");
RSet<String> set = transaction.getSet("mySet")
set.add(value);

try {
   transaction.commit();
} catch(TransactionException e) {
   transaction.rollback();
}

RBatch batch = client.createBatch();
batch.getMap("ledgerMap").fastPutAsync("1", "2");
batch.getMap("ledgerMap").putAsync("2", "5");
List<?> result = batch.execute();

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

RTopic publishTopic = client.getTopic("redisson");
long clientsReceivedMessage = publishTopic.publish(new CustomMessage("Hello world"));

package redis.demo;
import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;

public class Application 
{
    public static void main( String[] args )
    {
        Config config = new Config();
        config.useClusterServers()
              .addNodeAddress("redis://127.0.0.1:6379", "redis://127.0.0.1:6380");
        RedissonClient redisson = Redisson.create(config);
        // operations with Redis based Lock
        // implements java.util.concurrent.locks.Lock
        RLock lock = redisson.getLock("simpleLock");
        lock.lock();
        try {
           // do some actions
        } finally {
           lock.unlock();
        }
        // operations with Redis based Map
        // implements java.util.concurrent.ConcurrentMap
        RMap<String, String> map = redisson.getMap("simpleMap");
        map.put("mapKey", "This is a map value");
        String mapValue = map.get("mapKey");
        System.out.println("stored map value: " + mapValue);
        redisson.shutdown();
    }
}

package redis.demo;
import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
/**
 * Redis Sentinel Java example
 *
 */
public class Application 
{
    public static void main( String[] args )
    {
        Config config = new Config();
        config.useSentinelServers()
              .addSentinelAddress("redis://127.0.0.1:6379")
              .setMasterName("myMaster");
        RedissonClient redisson = Redisson.create(config);
        // perform operations
        // implements java.util.concurrent.ConcurrentMap
        RMap<String, String> map = redisson.getMap("simpleMap");
        map.put("mapKey", "This is a map value");
        String mapValue = map.get("mapKey");
        System.out.println("stored map value: " + mapValue);
        // implements java.util.concurrent.locks.Lock
        RLock lock = redisson.getLock("simpleLock");
        lock.lock();
        try {
           // do some actions
        } finally {
           lock.unlock();
        }
        redisson.shutdown();
    }
}