Java RedisChannelHandler类代码示例

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
private void reconnectToNearestProducer(DisqueConnection<K, V> disqueConnection, boolean forcedReconnect) {
    log.debug("reconnectToNearestProducer()");
    Set<Multiset.Entry<String>> stats = Multisets.copyHighestCountFirst(nodePrefixes).entrySet();
    nodePrefixes.clear();

    if (!isNodeSwitchNecessary(stats) && !forcedReconnect) {
        return;
    }

    String nodeIdPrefix = getNodeIdPrefix(stats);
    if (nodeIdPrefix != null) {
        log.debug("Set preferred node prefix to {}", nodeIdPrefix);
        socketAddressSupplier.setPreferredNodeIdPrefix(nodeIdPrefix);
    }

    if (disqueConnection.isOpen()) {
        if (nodeIdPrefix == null) {
            log.info("Initiating reconnect");
        } else {
            log.info("Initiating reconnect to preferred node with prefix {}", nodeIdPrefix);
        }
        disconnect((RedisChannelHandler<?, ?>) disqueConnection);
    }
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
/**
 * Disconnect the channel. Why {@link Channel#disconnect()} and not {@link DisqueCommands#quit()}? The quit command produces
 * an {@code OK} result which is read by the channel. Sometimes the pipeline is not finished with reading but the disconnect
 * is already initiated and this raises an {@link java.io.IOException}.
 *
 * The {@link Channel} is retrieved by reflection because it is not exposed.
 *
 * @param redisChannelHandler the channel handler.
 */
private void disconnect(RedisChannelHandler<?, ?> redisChannelHandler) {

    RedisChannelHandler<?, ?> rch = redisChannelHandler;
    RedisChannelWriter<?, ?> channelWriter = rch.getChannelWriter();

    try {
        Field field = CommandHandler.class.getDeclaredField("channel");
        field.setAccessible(true);
        Channel o = (Channel) field.get(channelWriter);
        if (o != null && o.isOpen()) {
            o.disconnect();
        }
    } catch (Exception e) {
        throw new IllegalStateException("Cannot look up/retrieve the channel from the " + CommandHandler.class.getName());
    }
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {

    logger.debug("{} channelInactive({})", logPrefix(), ctx);
    channel = null;

    if (listenOnChannelInactive && !reconnectionHandler.isReconnectSuspended()) {
        RedisChannelHandler<?, ?> channelHandler = ctx.pipeline().get(RedisChannelHandler.class);
        if (channelHandler != null) {
            reconnectionHandler.setTimeout(channelHandler.getTimeout());
            reconnectionHandler.setTimeoutUnit(channelHandler.getTimeoutUnit());
        }

        scheduleReconnect();
    } else {
        logger.debug("{} Reconnect scheduling disabled", logPrefix(), ctx);
    }

    super.channelInactive(ctx);
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
@Override
public void setRedisChannelHandler(RedisChannelHandler<K, V> redisChannelHandler) {
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
public static <K, V> RedisChannelHandler<K, V> getRedisChannelHandler(RedisConnection<K, V> sync) {

        InvocationHandler invocationHandler = Proxy.getInvocationHandler(sync);
        return (RedisChannelHandler<K, V>) ReflectionTestUtils.getField(invocationHandler, "connection");
    }
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
public static <T> T getHandler(Class<T> handlerType, RedisChannelHandler<?, ?> channelHandler) {
    Channel channel = getChannel(channelHandler);
    return (T) channel.pipeline().get((Class) handlerType);
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
public static Channel getChannel(RedisChannelHandler<?, ?> channelHandler) {
    return (Channel) ReflectionTestUtils.getField(channelHandler.getChannelWriter(), "channel");
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
public static Queue<?> getDisconnectedBuffer(RedisChannelHandler<?, ?> channelHandler) {
    return (Queue<?>) ReflectionTestUtils.getField(channelHandler.getChannelWriter(), "disconnectedBuffer");
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
public static Queue<?> getCommandBuffer(RedisChannelHandler<?, ?> channelHandler) {
    return (Queue<?>) ReflectionTestUtils.getField(channelHandler.getChannelWriter(), "commandBuffer");
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
public static Queue<Object> getStack(StatefulRedisConnection<?, ?> connection) {
    return getStack((RedisChannelHandler) connection);
}
 

import com.lambdaworks.redis.RedisChannelHandler; //导入依赖的package包/类
public static String getConnectionState(RedisChannelHandler<?, ?> channelHandler) {
    return ReflectionTestUtils.getField(channelHandler.getChannelWriter(), "lifecycleState").toString();
}