org.hibernate.cache.spi.CacheKeysFactory#org.redisson.connection.ConnectionManager源码实例Demo

public LiveObjectInterceptor(CommandAsyncExecutor commandExecutor, ConnectionManager connectionManager,
                             RedissonLiveObjectService service, Class<?> entityClass, String idFieldName) {
    this.service = service;
    this.commandExecutor = commandExecutor;
    this.connectionManager = connectionManager;
    this.originalClass = entityClass;
    this.idFieldName = idFieldName;

    namingScheme = connectionManager.getCommandExecutor().getObjectBuilder().getNamingScheme(entityClass);

    try {
        this.idFieldType = ClassUtils.getDeclaredField(originalClass, idFieldName).getType();
    } catch (Exception e) {
        throw new IllegalArgumentException(e);
    }
}
 

public static ConnectionManager createConnectionManager(Config configCopy) {
    UUID id = UUID.randomUUID();
    
    if (configCopy.getMasterSlaveServersConfig() != null) {
        validate(configCopy.getMasterSlaveServersConfig());
        return new MasterSlaveConnectionManager(configCopy.getMasterSlaveServersConfig(), configCopy, id);
    } else if (configCopy.getSingleServerConfig() != null) {
        validate(configCopy.getSingleServerConfig());
        return new SingleConnectionManager(configCopy.getSingleServerConfig(), configCopy, id);
    } else if (configCopy.getSentinelServersConfig() != null) {
        validate(configCopy.getSentinelServersConfig());
        return new SentinelConnectionManager(configCopy.getSentinelServersConfig(), configCopy, id);
    } else if (configCopy.getClusterServersConfig() != null) {
        validate(configCopy.getClusterServersConfig());
        return new ClusterConnectionManager(configCopy.getClusterServersConfig(), configCopy, id);
    } else if (configCopy.getReplicatedServersConfig() != null) {
        validate(configCopy.getReplicatedServersConfig());
        return new ReplicatedConnectionManager(configCopy.getReplicatedServersConfig(), configCopy, id);
    } else if (configCopy.getConnectionManager() != null) {
        return configCopy.getConnectionManager();
    }else {
        throw new IllegalArgumentException("server(s) address(es) not defined!");
    }
}
 

public RedisExecutor(boolean readOnlyMode, NodeSource source, Codec codec, RedisCommand<V> command,
        Object[] params, RPromise<R> mainPromise, boolean ignoreRedirect, 
        ConnectionManager connectionManager, RedissonObjectBuilder objectBuilder) {
    super();
    this.readOnlyMode = readOnlyMode;
    this.source = source;
    this.codec = codec;
    this.command = command;
    this.params = params;
    this.mainPromise = mainPromise;
    this.ignoreRedirect = ignoreRedirect;
    this.connectionManager = connectionManager;
    this.objectBuilder = objectBuilder;
    
    this.attempts = connectionManager.getConfig().getRetryAttempts();
    this.retryInterval = connectionManager.getConfig().getRetryInterval();
    this.responseTimeout = connectionManager.getConfig().getTimeout();
}
 

public RedisCommonBatchExecutor(NodeSource source, RPromise<Void> mainPromise, 
        ConnectionManager connectionManager, BatchOptions options, Entry entry, AtomicInteger slots) {
    super(entry.isReadOnlyMode(), source, null, null, null, mainPromise, true, connectionManager, null);
    this.options = options;
    this.entry = entry;
    this.slots = slots;
    
    if (options.getRetryAttempts() > 0) {
        this.attempts = options.getRetryAttempts();
    }
    if (options.getRetryInterval() > 0) {
        this.retryInterval  = options.getRetryInterval();
    }
    if (options.getResponseTimeout() > 0) {
        this.responseTimeout = options.getResponseTimeout();
    }
    
}
 

public BaseRegion(RMapCache<Object, Object> mapCache, ConnectionManager connectionManager, RegionFactory regionFactory, CacheDataDescription metadata, Properties properties, String defaultKey) {
    super();
    this.mapCache = mapCache;
    this.regionFactory = regionFactory;
    this.metadata = metadata;
    this.connectionManager = connectionManager;
    
    String maxEntries = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.MAX_ENTRIES_SUFFIX);
    if (maxEntries != null) {
        mapCache.setMaxSize(Integer.valueOf(maxEntries));
    }
    String timeToLive = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.TTL_SUFFIX);
    if (timeToLive != null) {
        ttl = Integer.valueOf(timeToLive);
    }
    String maxIdleTime = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.MAX_IDLE_SUFFIX);
    if (maxIdleTime != null) {
        maxIdle = Integer.valueOf(maxIdleTime);
    }

    String fallbackValue = (String) properties.getOrDefault(RedissonRegionFactory.FALLBACK, "false");
    fallback = Boolean.valueOf(fallbackValue);
}
 

public BaseRegion(RMapCache<Object, Object> mapCache, ConnectionManager connectionManager, RegionFactory regionFactory, CacheDataDescription metadata, Properties properties, String defaultKey) {
    super();
    this.mapCache = mapCache;
    this.regionFactory = regionFactory;
    this.metadata = metadata;
    this.connectionManager = connectionManager;
    
    String maxEntries = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.MAX_ENTRIES_SUFFIX);
    if (maxEntries != null) {
        mapCache.setMaxSize(Integer.valueOf(maxEntries));
    }
    String timeToLive = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.TTL_SUFFIX);
    if (timeToLive != null) {
        ttl = Integer.valueOf(timeToLive);
    }
    String maxIdleTime = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.MAX_IDLE_SUFFIX);
    if (maxIdleTime != null) {
        maxIdle = Integer.valueOf(maxIdleTime);
    }

    String fallbackValue = (String) properties.getOrDefault(RedissonRegionFactory.FALLBACK, "false");
    fallback = Boolean.valueOf(fallbackValue);
}
 

public RedissonStorage(RMapCache<Object, Object> mapCache, ConnectionManager connectionManager, Map<String, Object> properties, String defaultKey) {
    super();
    this.mapCache = mapCache;
    this.connectionManager = connectionManager;
    
    String maxEntries = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.MAX_ENTRIES_SUFFIX);
    if (maxEntries != null) {
        mapCache.setMaxSize(Integer.valueOf(maxEntries));
    }
    String timeToLive = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.TTL_SUFFIX);
    if (timeToLive != null) {
        ttl = Integer.valueOf(timeToLive);
    }
    String maxIdleTime = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.MAX_IDLE_SUFFIX);
    if (maxIdleTime != null) {
        maxIdle = Integer.valueOf(maxIdleTime);
    }

    String fallbackValue = (String) properties.getOrDefault(RedissonRegionFactory.FALLBACK, "false");
    fallback = Boolean.valueOf(fallbackValue);
}
 

public BaseRegion(RMapCache<Object, Object> mapCache, ConnectionManager connectionManager, RegionFactory regionFactory, CacheDataDescription metadata, Properties properties, String defaultKey) {
    super();
    this.mapCache = mapCache;
    this.regionFactory = regionFactory;
    this.metadata = metadata;
    this.connectionManager = connectionManager;
    
    String maxEntries = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.MAX_ENTRIES_SUFFIX);
    if (maxEntries != null) {
        mapCache.setMaxSize(Integer.valueOf(maxEntries));
    }
    String timeToLive = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.TTL_SUFFIX);
    if (timeToLive != null) {
        ttl = Integer.valueOf(timeToLive);
    }
    String maxIdleTime = getProperty(properties, mapCache.getName(), defaultKey, RedissonRegionFactory.MAX_IDLE_SUFFIX);
    if (maxIdleTime != null) {
        maxIdle = Integer.valueOf(maxIdleTime);
    }

    String fallbackValue = (String) properties.getOrDefault(RedissonRegionFactory.FALLBACK, "false");
    fallback = Boolean.valueOf(fallbackValue);
}
 

public PublishSubscribeService(ConnectionManager connectionManager, MasterSlaveServersConfig config) {
    super();
    this.connectionManager = connectionManager;
    this.config = config;
    for (int i = 0; i < locks.length; i++) {
        locks[i] = new AsyncSemaphore(1);
    }
}
 

RedissonSubSortedSet(RedissonSortedSet<V> redissonSortedSet, ConnectionManager connectionManager, V headValue, V tailValue) {
    super();
    this.headValue = headValue;
    this.tailValue = tailValue;

    this.connectionManager = connectionManager;
    this.redissonSortedSet = redissonSortedSet;
}
 

MapReduceExecutor(RObject object, RedissonClient redisson, ConnectionManager connectionManager) {
    this.objectName = object.getName();
    this.objectCodec = object.getCodec();
    this.objectClass = object.getClass();

    this.redisson = redisson;
    UUID id = UUID.randomUUID();
    this.resultMapName = object.getName() + ":result:" + id;
    this.executorService = redisson.getExecutorService(RExecutorService.MAPREDUCE_NAME);
    this.connectionManager = connectionManager;
}
 

@SuppressWarnings("ParameterNumber")
public BaseRedisBatchExecutor(boolean readOnlyMode, NodeSource source, Codec codec, RedisCommand<V> command,
        Object[] params, RPromise<R> mainPromise, boolean ignoreRedirect,
        ConnectionManager connectionManager, RedissonObjectBuilder objectBuilder, 
        ConcurrentMap<MasterSlaveEntry, Entry> commands,
        BatchOptions options, AtomicInteger index, AtomicBoolean executed) {
    
    super(readOnlyMode, source, codec, command, params, mainPromise, ignoreRedirect, connectionManager,
            objectBuilder);
    this.commands = commands;
    this.options = options;
    this.index = index;
    this.executed = executed;
}
 

@SuppressWarnings("ParameterNumber")
public RedisBatchExecutor(boolean readOnlyMode, NodeSource source, Codec codec, RedisCommand<V> command,
        Object[] params, RPromise<R> mainPromise, boolean ignoreRedirect, ConnectionManager connectionManager,
        RedissonObjectBuilder objectBuilder, ConcurrentMap<MasterSlaveEntry, Entry> commands,
        BatchOptions options, AtomicInteger index,
        AtomicBoolean executed) {
    super(readOnlyMode, source, codec, command, params, mainPromise, ignoreRedirect, connectionManager, objectBuilder,
            commands, options, index, executed);
}
 

@SuppressWarnings("ParameterNumber")
public RedisQueuedBatchExecutor(boolean readOnlyMode, NodeSource source, Codec codec, RedisCommand<V> command,
        Object[] params, RPromise<R> mainPromise, boolean ignoreRedirect, ConnectionManager connectionManager,
        RedissonObjectBuilder objectBuilder, ConcurrentMap<MasterSlaveEntry, Entry> commands,
        ConcurrentMap<MasterSlaveEntry, ConnectionEntry> connections, BatchOptions options, AtomicInteger index,
        AtomicBoolean executed, AsyncSemaphore semaphore) {
    super(readOnlyMode, source, codec, command, params, mainPromise, ignoreRedirect, connectionManager, objectBuilder,
            commands, options, index, executed);
    
    this.connections = connections;
    this.semaphore = semaphore;
}
 

@Override
public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
                          Object ret) throws Throwable {
    try {
        ConnectionManager connectionManager = (ConnectionManager) objInst;
        Config config = connectionManager.getCfg();

        Object singleServerConfig = ClassUtil.getObjectField(config, "singleServerConfig");
        Object sentinelServersConfig = ClassUtil.getObjectField(config, "sentinelServersConfig");
        Object masterSlaveServersConfig = ClassUtil.getObjectField(config, "masterSlaveServersConfig");
        Object clusterServersConfig = ClassUtil.getObjectField(config, "clusterServersConfig");
        Object replicatedServersConfig = ClassUtil.getObjectField(config, "replicatedServersConfig");

        StringBuilder peer = new StringBuilder();
        EnhancedInstance retInst = (EnhancedInstance) ret;

        if (singleServerConfig != null) {
            Object singleAddress = ClassUtil.getObjectField(singleServerConfig, "address");
            peer.append(getPeer(singleAddress));
            retInst.setSkyWalkingDynamicField(PeerFormat.shorten(peer.toString()));
            return ret;
        }
        if (sentinelServersConfig != null) {
            appendAddresses(peer, (Collection) ClassUtil.getObjectField(sentinelServersConfig, "sentinelAddresses"));
            retInst.setSkyWalkingDynamicField(PeerFormat.shorten(peer.toString()));
            return ret;
        }
        if (masterSlaveServersConfig != null) {
            Object masterAddress = ClassUtil.getObjectField(masterSlaveServersConfig, "masterAddress");
            peer.append(getPeer(masterAddress));
            appendAddresses(peer, (Collection) ClassUtil.getObjectField(masterSlaveServersConfig, "slaveAddresses"));
            retInst.setSkyWalkingDynamicField(PeerFormat.shorten(peer.toString()));
            return ret;
        }
        if (clusterServersConfig != null) {
            appendAddresses(peer, (Collection) ClassUtil.getObjectField(clusterServersConfig, "nodeAddresses"));
            retInst.setSkyWalkingDynamicField(PeerFormat.shorten(peer.toString()));
            return ret;
        }
        if (replicatedServersConfig != null) {
            appendAddresses(peer, (Collection) ClassUtil.getObjectField(replicatedServersConfig, "nodeAddresses"));
            retInst.setSkyWalkingDynamicField(PeerFormat.shorten(peer.toString()));
            return ret;
        }
    } catch (Exception e) {
        logger.warn("redisClient set peer error: ", e);
    }
    return ret;
}
 

public RedissonReactiveSubscription(ConnectionManager connectionManager) {
    this.subscribeService = connectionManager.getSubscribeService();
}
 

public RedissonSubscription(ConnectionManager connectionManager, PublishSubscribeService subscribeService, MessageListener listener) {
    super(listener, null, null);
    this.connectionManager = connectionManager;
    this.subscribeService = subscribeService;
}
 

public RedissonSubscription(ConnectionManager connectionManager, PublishSubscribeService subscribeService, MessageListener listener) {
    super(listener, null, null);
    this.connectionManager = connectionManager;
    this.subscribeService = subscribeService;
}
 

public RedissonReactiveSubscription(ConnectionManager connectionManager) {
    this.subscribeService = connectionManager.getSubscribeService();
}
 

public RedissonSubscription(ConnectionManager connectionManager, PublishSubscribeService subscribeService, MessageListener listener) {
    super(listener, null, null);
    this.connectionManager = connectionManager;
    this.subscribeService = subscribeService;
}
 

public RedissonSubscription(ConnectionManager connectionManager, PublishSubscribeService subscribeService, MessageListener listener) {
    super(listener, null, null);
    this.connectionManager = connectionManager;
    this.subscribeService = subscribeService;
}
 

public RedissonReactiveSubscription(ConnectionManager connectionManager) {
    this.subscribeService = connectionManager.getSubscribeService();
}
 

public RedissonSubscription(ConnectionManager connectionManager, PublishSubscribeService subscribeService, MessageListener listener) {
    super(listener, null, null);
    this.connectionManager = connectionManager;
    this.subscribeService = subscribeService;
}
 

public RedissonSubscription(ConnectionManager connectionManager, PublishSubscribeService subscribeService, MessageListener listener) {
    super(listener, null, null);
    this.connectionManager = connectionManager;
    this.subscribeService = subscribeService;
}
 

public RedissonSubscription(ConnectionManager connectionManager, PublishSubscribeService subscribeService, MessageListener listener) {
    super(listener, null, null);
    this.connectionManager = connectionManager;
    this.subscribeService = subscribeService;
}
 

public RedissonBaseNodes(ConnectionManager connectionManager) {
    this.connectionManager = connectionManager;
}
 

public RedissonSentinelMasterSlaveNodes(ConnectionManager connectionManager) {
    super(connectionManager);
}
 

public RedissonClusterNodes(ConnectionManager connectionManager) {
    super(connectionManager);
}
 

public RedissonMasterSlaveNodes(ConnectionManager connectionManager) {
    super(connectionManager);
}
 

public RedissonSingleNode(ConnectionManager connectionManager) {
    super(connectionManager);
}