Java RedisAsyncCommands.close方法代码示例

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test(timeout = 2000)
public void pipelinedMessage() throws Exception {
    pubsub.subscribe(channel);
    assertThat(channels.take()).isEqualTo(channel);
    RedisAsyncCommands<String, String> connection = client.connectAsync();

    connection.setAutoFlushCommands(false);
    connection.publish(channel, message);
    Thread.sleep(100);

    assertThat(channels).isEmpty();
    connection.flushCommands();

    assertThat(channels.take()).isEqualTo(channel);
    assertThat(messages.take()).isEqualTo(message);

    connection.close();
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test
public void requestQueueSize() {

    client.setOptions(ClientOptions.builder().requestQueueSize(10).build());

    RedisAsyncCommands<String, String> connection = client.connect().async();
    getConnectionWatchdog(connection.getStatefulConnection()).setListenOnChannelInactive(false);

    connection.quit();

    Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();

    for (int i = 0; i < 10; i++) {
        connection.ping();
    }

    try {
        connection.ping();
        fail("missing RedisException");
    } catch (RedisException e) {
        assertThat(e).hasMessageContaining("Request queue size exceeded");
    }

    connection.close();
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test
public void disconnectedWithoutReconnect() {

    client.setOptions(ClientOptions.builder().autoReconnect(false).build());

    RedisAsyncCommands<String, String> connection = client.connect().async();

    connection.quit();
    Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();
    try {
        connection.get(key);
    } catch (Exception e) {
        assertThat(e).isInstanceOf(RedisException.class).hasMessageContaining("not connected");
    } finally {
        connection.close();
    }
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test
public void disconnectedRejectCommands() {

    client.setOptions(ClientOptions.builder().disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
            .build());

    RedisAsyncCommands<String, String> connection = client.connect().async();

    getConnectionWatchdog(connection.getStatefulConnection()).setListenOnChannelInactive(false);
    connection.quit();
    Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();
    try {
        connection.get(key);
    } catch (Exception e) {
        assertThat(e).isInstanceOf(RedisException.class).hasMessageContaining("not connected");
    } finally {
        connection.close();
    }
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test
public void disconnectedAcceptCommands() {

    client.setOptions(ClientOptions.builder().autoReconnect(false)
            .disconnectedBehavior(ClientOptions.DisconnectedBehavior.ACCEPT_COMMANDS).build());

    RedisAsyncCommands<String, String> connection = client.connect().async();

    connection.quit();
    Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();
    connection.get(key);
    connection.close();
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test
public void statefulConnectionFromAsync() throws Exception {
    RedisAsyncCommands<String, String> async = client.connect().async();
    assertThat(async.getStatefulConnection().async()).isSameAs(async);
    async.close();
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test
public void statefulConnectionFromReactive() throws Exception {
    RedisAsyncCommands<String, String> async = client.connect().async();
    assertThat(async.getStatefulConnection().reactive().getStatefulConnection()).isSameAs(async.getStatefulConnection());
    async.close();
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
/**
 * Simulates a failure on reconnect by changing the port to a invalid server and triggering a reconnect.
 *
 * Expectation: {@link com.lambdaworks.redis.ConnectionEvents.Reconnect} events are sent.
 *
 * @throws Exception
 */
@Test(timeout = 120000)
public void pingBeforeConnectFailOnReconnectShouldSendEvents() throws Exception {

    client.setOptions(ClientOptions.builder().pingBeforeActivateConnection(true).suspendReconnectOnProtocolFailure(false)
            .build());

    RandomResponseServer ts = getRandomResponseServer();

    RedisURI redisUri = RedisURI.create(defaultRedisUri.toURI());
    redisUri.setTimeout(5);
    redisUri.setUnit(TimeUnit.SECONDS);

    try {
        final BlockingQueue<ConnectionEvents.Reconnect> events = new LinkedBlockingDeque<>();

        RedisAsyncCommands<String, String> connection = client.connectAsync(redisUri);
        ConnectionWatchdog connectionWatchdog = Connections.getConnectionWatchdog(connection.getStatefulConnection());

        ReconnectionListener reconnectionListener = new ReconnectionListener() {
            @Override
            public void onReconnect(ConnectionEvents.Reconnect reconnect) {
                events.add(reconnect);
            }
        };

        ReflectionTestUtils.setField(connectionWatchdog, "reconnectionListener", reconnectionListener);

        redisUri.setPort(TestSettings.nonexistentPort());

        connection.quit();
        Wait.untilTrue(() -> events.size() > 1).waitOrTimeout();
        connection.close();

        ConnectionEvents.Reconnect event1 = events.take();
        assertThat(event1.getAttempt()).isEqualTo(1);

        ConnectionEvents.Reconnect event2 = events.take();
        assertThat(event2.getAttempt()).isEqualTo(2);

    } finally {
        ts.shutdown();
    }
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test
public void variousClientOptions() {

    RedisAsyncCommands<String, String> plain = client.connect().async();

    assertThat(getStatefulConnection(plain).getOptions().isAutoReconnect()).isTrue();

    client.setOptions(ClientOptions.builder().autoReconnect(false).build());
    RedisAsyncCommands<String, String> connection = client.connect().async();
    assertThat(getStatefulConnection(connection).getOptions().isAutoReconnect()).isFalse();

    assertThat(getStatefulConnection(plain).getOptions().isAutoReconnect()).isTrue();

    plain.close();
    connection.close();
}
 

import com.lambdaworks.redis.api.async.RedisAsyncCommands; //导入方法依赖的package包/类
@Test
public void shouldNotifyListener() throws Exception {

    final TestConnectionListener listener = new TestConnectionListener();

    RedisClient client = RedisClient.create(DEFAULT_RESOURCES, RedisURI.Builder.redis(host, port).build());

    client.addListener(listener);

    assertThat(listener.onConnected).isNull();
    assertThat(listener.onDisconnected).isNull();
    assertThat(listener.onException).isNull();

    RedisAsyncCommands<String, String> connection = client.connect().async();

    StatefulRedisConnection<String, String> statefulRedisConnection = getStatefulConnection(connection);

    Wait.untilTrue(() -> listener.onConnected != null).waitOrTimeout();
    assertThat(listener.onConnectedSocketAddress).isNotNull();

    assertThat(listener.onConnected).isEqualTo(statefulRedisConnection);
    assertThat(listener.onDisconnected).isNull();

    connection.set(key, value).get();
    connection.close();

    Wait.untilTrue(() -> listener.onDisconnected != null).waitOrTimeout();

    assertThat(listener.onConnected).isEqualTo(statefulRedisConnection);
    assertThat(listener.onDisconnected).isEqualTo(statefulRedisConnection);

    FastShutdown.shutdown(client);
}