org.redisson.Redisson Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of redisson-all Show documentation
Redis based In-Memory Data Grid for Java
There is a newer version: 3.36.0
/**
 * Copyright 2016 Nikita Koksharov
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.redisson;

import java.util.UUID;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;

import org.redisson.api.ClusterNodesGroup;
import org.redisson.api.LocalCachedMapOptions;
import org.redisson.api.MapOptions;
import org.redisson.api.Node;
import org.redisson.api.NodesGroup;
import org.redisson.api.RAtomicDouble;
import org.redisson.api.RAtomicLong;
import org.redisson.api.RBatch;
import org.redisson.api.RBinaryStream;
import org.redisson.api.RBitSet;
import org.redisson.api.RBlockingDeque;
import org.redisson.api.RBlockingQueue;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RBoundedBlockingQueue;
import org.redisson.api.RBucket;
import org.redisson.api.RBuckets;
import org.redisson.api.RCountDownLatch;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RDeque;
import org.redisson.api.RGeo;
import org.redisson.api.RHyperLogLog;
import org.redisson.api.RKeys;
import org.redisson.api.RLexSortedSet;
import org.redisson.api.RList;
import org.redisson.api.RListMultimap;
import org.redisson.api.RListMultimapCache;
import org.redisson.api.RLiveObjectService;
import org.redisson.api.RLocalCachedMap;
import org.redisson.api.RLock;
import org.redisson.api.RMap;
import org.redisson.api.RMapCache;
import org.redisson.api.RPatternTopic;
import org.redisson.api.RPermitExpirableSemaphore;
import org.redisson.api.RPriorityDeque;
import org.redisson.api.RPriorityQueue;
import org.redisson.api.RQueue;
import org.redisson.api.RReadWriteLock;
import org.redisson.api.RRemoteService;
import org.redisson.api.RScheduledExecutorService;
import org.redisson.api.RScoredSortedSet;
import org.redisson.api.RScript;
import org.redisson.api.RSemaphore;
import org.redisson.api.RSet;
import org.redisson.api.RSetCache;
import org.redisson.api.RSetMultimap;
import org.redisson.api.RSetMultimapCache;
import org.redisson.api.RSortedSet;
import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
import org.redisson.api.RedissonReactiveClient;
import org.redisson.client.codec.Codec;
import org.redisson.codec.CodecProvider;
import org.redisson.command.CommandExecutor;
import org.redisson.config.Config;
import org.redisson.config.ConfigSupport;
import org.redisson.connection.ConnectionManager;
import org.redisson.eviction.EvictionScheduler;
import org.redisson.liveobject.provider.ResolverProvider;
import org.redisson.misc.RedissonObjectFactory;
import org.redisson.pubsub.SemaphorePubSub;

import io.netty.util.internal.PlatformDependent;

/**
 * Main infrastructure class allows to get access
 * to all Redisson objects on top of Redis server.
 *
 * @author Nikita Koksharov
 *
 */
public class Redisson implements RedissonClient {

    static {
        RedissonObjectFactory.warmUp();
        RedissonReference.warmUp();
    }
    
    protected final QueueTransferService queueTransferService = new QueueTransferService();
    protected final EvictionScheduler evictionScheduler;
    protected final ConnectionManager connectionManager;
    
    protected final ConcurrentMap, Class> liveObjectClassCache = PlatformDependent.newConcurrentHashMap();
    protected final CodecProvider codecProvider;
    protected final ResolverProvider resolverProvider;
    protected final Config config;
    protected final SemaphorePubSub semaphorePubSub = new SemaphorePubSub();

    protected final UUID id = UUID.randomUUID();

    protected Redisson(Config config) {
        this.config = config;
        Config configCopy = new Config(config);
        
        connectionManager = ConfigSupport.createConnectionManager(configCopy);
        evictionScheduler = new EvictionScheduler(connectionManager.getCommandExecutor());
        codecProvider = configCopy.getCodecProvider();
        resolverProvider = configCopy.getResolverProvider();
    }
    
    public EvictionScheduler getEvictionScheduler() {
        return evictionScheduler;
    }
    
    public CommandExecutor getCommandExecutor() {
        return connectionManager.getCommandExecutor();
    }
    
    public ConnectionManager getConnectionManager() {
        return connectionManager;
    }

    /**
     * Create sync/async Redisson instance with default config
     *
     * @return Redisson instance
     */
    public static RedissonClient create() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
//        config.useMasterSlaveConnection().setMasterAddress("127.0.0.1:6379").addSlaveAddress("127.0.0.1:6389").addSlaveAddress("127.0.0.1:6399");
//        config.useSentinelConnection().setMasterName("mymaster").addSentinelAddress("127.0.0.1:26389", "127.0.0.1:26379");
//        config.useClusterServers().addNodeAddress("127.0.0.1:7000");
        return create(config);
    }

    /**
     * Create sync/async Redisson instance with provided config
     *
     * @param config for Redisson
     * @return Redisson instance
     */
    public static RedissonClient create(Config config) {
        Redisson redisson = new Redisson(config);
        if (config.isRedissonReferenceEnabled()) {
            redisson.enableRedissonReferenceSupport();
        }
        return redisson;
    }

    /**
     * Create reactive Redisson instance with default config
     *
     * @return Redisson instance
     */
    public static RedissonReactiveClient createReactive() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
//        config.useMasterSlaveConnection().setMasterAddress("127.0.0.1:6379").addSlaveAddress("127.0.0.1:6389").addSlaveAddress("127.0.0.1:6399");
//        config.useSentinelConnection().setMasterName("mymaster").addSentinelAddress("127.0.0.1:26389", "127.0.0.1:26379");
//        config.useClusterServers().addNodeAddress("127.0.0.1:7000");
        return createReactive(config);
    }

    /**
     * Create reactive Redisson instance with provided config
     *
     * @param config for Redisson
     * @return Redisson instance
     */
    public static RedissonReactiveClient createReactive(Config config) {
        RedissonReactive react = new RedissonReactive(config);
        if (config.isRedissonReferenceEnabled()) {
            react.enableRedissonReferenceSupport();
        }
        return react;
    }
    
    @Override
    public RBinaryStream getBinaryStream(String name) {
        return new RedissonBinaryStream(connectionManager.getCommandExecutor(), name);
    }
    
    @Override
    public  RGeo getGeo(String name) {
        return new RedissonGeo(connectionManager.getCommandExecutor(), name, this);
    }
    
    @Override
    public  RGeo getGeo(String name, Codec codec) {
        return new RedissonGeo(codec, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RBucket getBucket(String name) {
        return new RedissonBucket(connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RBucket getBucket(String name, Codec codec) {
        return new RedissonBucket(codec, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public RBuckets getBuckets() {
        return new RedissonBuckets(this, connectionManager.getCommandExecutor());
    }
    
    @Override
    public RBuckets getBuckets(Codec codec) {
        return new RedissonBuckets(this, codec, connectionManager.getCommandExecutor());
    }
    
    @Override
    public  RHyperLogLog getHyperLogLog(String name) {
        return new RedissonHyperLogLog(connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RHyperLogLog getHyperLogLog(String name, Codec codec) {
        return new RedissonHyperLogLog(codec, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RList getList(String name) {
        return new RedissonList(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RList getList(String name, Codec codec) {
        return new RedissonList(codec, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RListMultimap getListMultimap(String name) {
        return new RedissonListMultimap(id, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RListMultimap getListMultimap(String name, Codec codec) {
        return new RedissonListMultimap(id, codec, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RLocalCachedMap getLocalCachedMap(String name, LocalCachedMapOptions options) {
        return new RedissonLocalCachedMap(connectionManager.getCommandExecutor(), name, options, evictionScheduler, this);
    }

    @Override
    public  RLocalCachedMap getLocalCachedMap(String name, Codec codec, LocalCachedMapOptions options) {
        return new RedissonLocalCachedMap(codec, connectionManager.getCommandExecutor(), name, options, evictionScheduler, this);
    }

    @Override
    public  RMap getMap(String name) {
        return new RedissonMap(connectionManager.getCommandExecutor(), name, this, null);
    }
    
    @Override
    public  RMap getMap(String name, MapOptions options) {
        return new RedissonMap(connectionManager.getCommandExecutor(), name, this, options);
    }

    @Override
    public  RSetMultimap getSetMultimap(String name) {
        return new RedissonSetMultimap(id, connectionManager.getCommandExecutor(), name);
    }
    
    @Override
    public  RSetMultimapCache getSetMultimapCache(String name) {
        return new RedissonSetMultimapCache(id, evictionScheduler, connectionManager.getCommandExecutor(), name);
    }
    
    @Override
    public  RSetMultimapCache getSetMultimapCache(String name, Codec codec) {
        return new RedissonSetMultimapCache(id, evictionScheduler, codec, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RListMultimapCache getListMultimapCache(String name) {
        return new RedissonListMultimapCache(id, evictionScheduler, connectionManager.getCommandExecutor(), name);
    }
    
    @Override
    public  RListMultimapCache getListMultimapCache(String name, Codec codec) {
        return new RedissonListMultimapCache(id, evictionScheduler, codec, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RSetMultimap getSetMultimap(String name, Codec codec) {
        return new RedissonSetMultimap(id, codec, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RSetCache getSetCache(String name) {
        return new RedissonSetCache(evictionScheduler, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RSetCache getSetCache(String name, Codec codec) {
        return new RedissonSetCache(codec, evictionScheduler, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RMapCache getMapCache(String name) {
        return new RedissonMapCache(evictionScheduler, connectionManager.getCommandExecutor(), name, this, null);
    }

    @Override
    public  RMapCache getMapCache(String name, MapOptions options) {
        return new RedissonMapCache(evictionScheduler, connectionManager.getCommandExecutor(), name, this, options);
    }
    
    @Override
    public  RMapCache getMapCache(String name, Codec codec) {
        return new RedissonMapCache(codec, evictionScheduler, connectionManager.getCommandExecutor(), name, this, null);
    }
    
    @Override
    public  RMapCache getMapCache(String name, Codec codec, MapOptions options) {
        return new RedissonMapCache(codec, evictionScheduler, connectionManager.getCommandExecutor(), name, this, options);
    }

    @Override
    public  RMap getMap(String name, Codec codec) {
        return new RedissonMap(codec, connectionManager.getCommandExecutor(), name, this, null);
    }
    
    @Override
    public  RMap getMap(String name, Codec codec, MapOptions options) {
        return new RedissonMap(codec, connectionManager.getCommandExecutor(), name, this, options);
    }

    @Override
    public RLock getLock(String name) {
        return new RedissonLock(connectionManager.getCommandExecutor(), name, id);
    }

    @Override
    public RLock getFairLock(String name) {
        return new RedissonFairLock(connectionManager.getCommandExecutor(), name, id);
    }
    
    @Override
    public RReadWriteLock getReadWriteLock(String name) {
        return new RedissonReadWriteLock(connectionManager.getCommandExecutor(), name, id);
    }

    @Override
    public  RSet getSet(String name) {
        return new RedissonSet(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RSet getSet(String name, Codec codec) {
        return new RedissonSet(codec, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public RScript getScript() {
        return new RedissonScript(connectionManager.getCommandExecutor());
    }

    @Override
    public RScheduledExecutorService getExecutorService(String name) {
        return new RedissonExecutorService(connectionManager.getCodec(), connectionManager.getCommandExecutor(), this, name, queueTransferService);
    }
    
    @Override
    @Deprecated
    public RScheduledExecutorService getExecutorService(Codec codec, String name) {
        return getExecutorService(name, codec);
    }

    @Override
    public RScheduledExecutorService getExecutorService(String name, Codec codec) {
        return new RedissonExecutorService(codec, connectionManager.getCommandExecutor(), this, name, queueTransferService);
    }
    
    @Override
    public RRemoteService getRemoteService() {
        return new RedissonRemoteService(this, connectionManager.getCommandExecutor());
    }

    @Override
    public RRemoteService getRemoteService(String name) {
        return new RedissonRemoteService(this, name, connectionManager.getCommandExecutor());
    }
    
    @Override
    public RRemoteService getRemoteService(Codec codec) {
        return new RedissonRemoteService(codec, this, connectionManager.getCommandExecutor());
    }
    
    @Override
    public RRemoteService getRemoteService(String name, Codec codec) {
        return new RedissonRemoteService(codec, this, name, connectionManager.getCommandExecutor());
    }

    @Override
    public  RSortedSet getSortedSet(String name) {
        return new RedissonSortedSet(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RSortedSet getSortedSet(String name, Codec codec) {
        return new RedissonSortedSet(codec, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RScoredSortedSet getScoredSortedSet(String name) {
        return new RedissonScoredSortedSet(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RScoredSortedSet getScoredSortedSet(String name, Codec codec) {
        return new RedissonScoredSortedSet(codec, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public RLexSortedSet getLexSortedSet(String name) {
        return new RedissonLexSortedSet(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RTopic getTopic(String name) {
        return new RedissonTopic(connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RTopic getTopic(String name, Codec codec) {
        return new RedissonTopic(codec, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RPatternTopic getPatternTopic(String pattern) {
        return new RedissonPatternTopic(connectionManager.getCommandExecutor(), pattern);
    }

    @Override
    public  RPatternTopic getPatternTopic(String pattern, Codec codec) {
        return new RedissonPatternTopic(codec, connectionManager.getCommandExecutor(), pattern);
    }

    @Override
    public  RDelayedQueue getDelayedQueue(RQueue destinationQueue) {
        if (destinationQueue == null) {
            throw new NullPointerException();
        }
        return new RedissonDelayedQueue(queueTransferService, destinationQueue.getCodec(), connectionManager.getCommandExecutor(), destinationQueue.getName());
    }
    
    @Override
    public  RQueue getQueue(String name) {
        return new RedissonQueue(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RQueue getQueue(String name, Codec codec) {
        return new RedissonQueue(codec, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RBlockingQueue getBlockingQueue(String name) {
        return new RedissonBlockingQueue(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RBlockingQueue getBlockingQueue(String name, Codec codec) {
        return new RedissonBlockingQueue(codec, connectionManager.getCommandExecutor(), name, this);
    }
    
    @Override
    public  RBoundedBlockingQueue getBoundedBlockingQueue(String name) {
        return new RedissonBoundedBlockingQueue(semaphorePubSub, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RBoundedBlockingQueue getBoundedBlockingQueue(String name, Codec codec) {
        return new RedissonBoundedBlockingQueue(semaphorePubSub, codec, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RDeque getDeque(String name) {
        return new RedissonDeque(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RDeque getDeque(String name, Codec codec) {
        return new RedissonDeque(codec, connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RBlockingDeque getBlockingDeque(String name) {
        return new RedissonBlockingDeque(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RBlockingDeque getBlockingDeque(String name, Codec codec) {
        return new RedissonBlockingDeque(codec, connectionManager.getCommandExecutor(), name, this);
    };

    @Override
    public RAtomicLong getAtomicLong(String name) {
        return new RedissonAtomicLong(connectionManager.getCommandExecutor(), name);
    }

    @Override
    public RAtomicDouble getAtomicDouble(String name) {
        return new RedissonAtomicDouble(connectionManager.getCommandExecutor(), name);
    }

    @Override
    public RCountDownLatch getCountDownLatch(String name) {
        return new RedissonCountDownLatch(connectionManager.getCommandExecutor(), name, id);
    }

    @Override
    public RBitSet getBitSet(String name) {
        return new RedissonBitSet(connectionManager.getCommandExecutor(), name);
    }

    @Override
    public RSemaphore getSemaphore(String name) {
        return new RedissonSemaphore(connectionManager.getCommandExecutor(), name, semaphorePubSub);
    }
    
    public RPermitExpirableSemaphore getPermitExpirableSemaphore(String name) {
        return new RedissonPermitExpirableSemaphore(connectionManager.getCommandExecutor(), name, semaphorePubSub);
    }


    @Override
    public  RBloomFilter getBloomFilter(String name) {
        return new RedissonBloomFilter(connectionManager.getCommandExecutor(), name);
    }

    @Override
    public  RBloomFilter getBloomFilter(String name, Codec codec) {
        return new RedissonBloomFilter(codec, connectionManager.getCommandExecutor(), name);
    }

    @Override
    public RKeys getKeys() {
        return new RedissonKeys(connectionManager.getCommandExecutor());
    }

    @Override
    public RBatch createBatch() {
        RedissonBatch batch = new RedissonBatch(id, evictionScheduler, connectionManager);
        if (config.isRedissonReferenceEnabled()) {
            batch.enableRedissonReferenceSupport(this);
        }
        return batch;
    }

    @Override
    public RLiveObjectService getLiveObjectService() {
        return new RedissonLiveObjectService(this, liveObjectClassCache, codecProvider, resolverProvider);
    }
    
    @Override
    public void shutdown() {
        connectionManager.shutdown();
    }
    
    
    @Override
    public void shutdown(long quietPeriod, long timeout, TimeUnit unit) {
        connectionManager.shutdown(quietPeriod, timeout, unit);
    }

    @Override
    public Config getConfig() {
        return config;
    }

    @Override
    public CodecProvider getCodecProvider() {
        return codecProvider;
    }
    
    @Override
    public ResolverProvider getResolverProvider() {
        return resolverProvider;
    }

    @Override
    public NodesGroup getNodesGroup() {
        return new RedisNodes(connectionManager);
    }

    @Override
    public ClusterNodesGroup getClusterNodesGroup() {
        if (!connectionManager.isClusterMode()) {
            throw new IllegalStateException("Redisson is not in cluster mode!");
        }
        return new RedisClusterNodes(connectionManager);
    }

    @Override
    public boolean isShutdown() {
        return connectionManager.isShutdown();
    }

    @Override
    public boolean isShuttingDown() {
        return connectionManager.isShuttingDown();
    }

    protected void enableRedissonReferenceSupport() {
        this.connectionManager.getCommandExecutor().enableRedissonReferenceSupport(this);
    }

    @Override
    public  RPriorityQueue getPriorityQueue(String name) {
        return new RedissonPriorityQueue(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RPriorityQueue getPriorityQueue(String name, Codec codec) {
        return new RedissonPriorityQueue(codec, connectionManager.getCommandExecutor(), name, this);
    }
    
    @Override
    public  RPriorityDeque getPriorityDeque(String name) {
        return new RedissonPriorityDeque(connectionManager.getCommandExecutor(), name, this);
    }

    @Override
    public  RPriorityDeque getPriorityDeque(String name, Codec codec) {
        return new RedissonPriorityDeque(codec, connectionManager.getCommandExecutor(), name, this);
    }
    

}