Java StatefulRedisConnection.sync方法代码示例

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
/**
 * Connects to the Redis server.
 * @param configuration The configuration object.
 * @throws Exception If an error occurs.
 */
public void connect(Configuration configuration) throws Exception {
    if(sync != null) {
        return;
    }
    RedisURI.Builder uri = RedisURI.Builder.redis(configuration.getRedisHost(), configuration.getRedisPort())
            .withDatabase(configuration.getRedisIndex());
    if(!configuration.getRedisAuth().isEmpty()) {
        uri.withPassword(configuration.getRedisAuth());
    }
    RedisClient client = RedisClient.create(uri.build());
    StatefulRedisConnection<String, String> connection = client.connect();
    sync = connection.sync();
    for(Category category : Category.values()) {
        logger.info("Registered the category {} with the type {}.", category, category.getEntry().getType());
        category.getEntry().setCategory(category);
    }
}
 

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

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport.createGenericObjectPool(
            () -> client.connect(), new GenericObjectPoolConfig());

    StatefulRedisConnection<String, String> connection = pool.borrowObject();
    RedisCommands<String, String> sync = connection.sync();
    sync.set(key, value);

    try {
        sync.hgetall(key);
        fail("Missing RedisCommandExecutionException");
    } catch (RedisCommandExecutionException e) {
        assertThat(e).hasMessageContaining("WRONGTYPE");
    }

    sync.close();
    pool.close();
}
 

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

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport.createGenericObjectPool(
            () -> client.connect(), new GenericObjectPoolConfig());

    StatefulRedisConnection<String, String> connection = pool.borrowObject();
    RedisCommands<String, String> sync = connection.sync();

    assertThat(connection).isInstanceOf(StatefulRedisConnection.class).isNotInstanceOf(
            StatefulRedisClusterConnectionImpl.class);
    assertThat(Proxy.isProxyClass(connection.getClass())).isTrue();

    assertThat(sync).isInstanceOf(RedisCommands.class);
    assertThat(connection.async()).isInstanceOf(RedisAsyncCommands.class).isNotInstanceOf(RedisAsyncCommandsImpl.class);
    assertThat(connection.reactive()).isInstanceOf(RedisReactiveCommands.class).isNotInstanceOf(
            RedisReactiveCommandsImpl.class);
    assertThat(sync.getStatefulConnection()).isInstanceOf(StatefulRedisConnection.class)
            .isNotInstanceOf(StatefulRedisConnectionImpl.class).isSameAs(connection);

    sync.close();
    pool.close();
}
 

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

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport.createGenericObjectPool(
            () -> client.connect(), new GenericObjectPoolConfig(), false);

    StatefulRedisConnection<String, String> connection = pool.borrowObject();
    RedisCommands<String, String> sync = connection.sync();

    assertThat(connection).isInstanceOf(StatefulRedisConnection.class).isNotInstanceOf(
            StatefulRedisClusterConnectionImpl.class);
    assertThat(Proxy.isProxyClass(connection.getClass())).isFalse();

    assertThat(sync).isInstanceOf(RedisCommands.class);
    assertThat(connection.async()).isInstanceOf(RedisAsyncCommands.class).isInstanceOf(RedisAsyncCommandsImpl.class);
    assertThat(connection.reactive()).isInstanceOf(RedisReactiveCommands.class).isInstanceOf(
            RedisReactiveCommandsImpl.class);
    assertThat(sync.getStatefulConnection()).isInstanceOf(StatefulRedisConnection.class).isInstanceOf(
            StatefulRedisConnectionImpl.class);

    pool.returnObject(connection);
    pool.close();
}
 

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

    GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport.createGenericObjectPool(
            () -> client.connect(), new GenericObjectPoolConfig(), true);

    StatefulRedisConnection<String, String> connection = pool.borrowObject();
    RedisCommands<String, String> sync = connection.sync();
    sync.ping();
    sync.close();

    try {
        connection.isMulti();
        fail("Missing RedisException");
    } catch (RedisException e) {
        assertThat(e).hasMessageContaining("deallocated");
    }

    pool.close();
}
 

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

    sync.set(KEY_A, value);
    sync.set(KEY_B, "d");

    StatefulRedisConnection<String, String> statefulRedisConnection = sync.getStatefulConnection().getConnection(
            TestSettings.hostAddr(), port2);

    RedisClusterCommands<String, String> connection = statefulRedisConnection.sync();

    assertThat(connection.get(KEY_A)).isEqualTo(value);
    try {
        connection.get(KEY_B);
        fail("missing RedisCommandExecutionException: MOVED");
    } catch (RedisException e) {
        assertThat(e).hasMessageContaining("MOVED");
    }
}
 

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
public String ping() {

        StatefulRedisConnection<String, String> connection = redisClient.connect();

        RedisCommands<String, String> sync = connection.sync();
        String result = sync.ping();
        connection.close();
        return result;
    }
 

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
/**
 * Create a transactional wrapper proxy for {@link RedisCommands}.
 *
 * @param connection the connection
 * @return the wrapper proxy.
 */
@SuppressWarnings("unchecked")
public static <K, V> RedisCommands<K, V> sync(StatefulRedisConnection<K, V> connection) {

    try {
        TxSyncInvocationHandler<K, V> handler = new TxSyncInvocationHandler<>(connection.sync());
        return (RedisCommands<K, V>) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
                new Class<?>[] { RedisCommands.class }, handler);
    } catch (Exception e) {
        throw new IllegalStateException(e);
    }
}
 

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
@Test
public void testJavaSerializer() throws Exception {
    StatefulRedisConnection<String, Object> redisConnection = client.connect(new SerializedObjectCodec());
    RedisCommands<String, Object> sync = redisConnection.sync();
    List<String> list = list("one", "two");
    sync.set(key, list);

    assertThat(sync.get(key)).isEqualTo(list);
    assertThat(sync.set(key, list)).isEqualTo("OK");
    assertThat(sync.set(key, list, SetArgs.Builder.ex(1))).isEqualTo("OK");

    redisConnection.close();
}
 

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
private void borrowAndReturn(ObjectPool<StatefulRedisConnection<String, String>> pool) throws Exception {

        for (int i = 0; i < 10; i++) {
            StatefulRedisConnection<String, String> connection = pool.borrowObject();
            RedisCommands<String, String> sync = connection.sync();
            sync.ping();
            pool.returnObject(connection);
        }
    }
 

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
private void borrowAndClose(ObjectPool<StatefulRedisConnection<String, String>> pool) throws Exception {

        for (int i = 0; i < 10; i++) {
            StatefulRedisConnection<String, String> connection = pool.borrowObject();
            RedisCommands<String, String> sync = connection.sync();
            sync.ping();
            sync.close();
        }
    }
 

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
public static void main(String[] args) {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
                "com/lambdaworks/examples/SpringTest-context.xml");

        RedisClient client = context.getBean(RedisClient.class);

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

        RedisCommands<String, String> sync = connection.sync();
        System.out.println("PING: " + sync.ping());
        connection.close();

        MySpringBean mySpringBean = context.getBean(MySpringBean.class);
        System.out.println("PING: " + mySpringBean.ping());

        context.close();
    }
 

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
public static void main(String[] args) {

        // Syntax: redis://[[email protected]]host[:port][/databaseNumber]
        RedisClient redisClient = RedisClient.create(RedisURI.create("redis://[email protected]:6379/0"));

        StatefulRedisConnection<String, String> connection = redisClient.connect();

        System.out.println("Connected to Redis");

        RedisCommands<String, String> sync = connection.sync();

        sync.set("foo", "bar");
        String value = sync.get("foo");
        System.out.println(value);

        connection.close();
        redisClient.shutdown();
    }
 

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

    SoftReferenceObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport
            .createSoftReferenceObjectPool(() -> client.connect());

    StatefulRedisConnection<String, String> connection = pool.borrowObject();

    assertThat(channels).hasSize(1);

    RedisCommands<String, String> sync = connection.sync();
    sync.ping();
    sync.close();

    pool.close();

    Wait.untilTrue(channels::isEmpty).waitOrTimeout();

    assertThat(channels).isEmpty();
}
 

import com.lambdaworks.redis.api.StatefulRedisConnection; //导入方法依赖的package包/类
/**
 * Create {@link RedisCommands} given {@link StatefulRedisConnection}.
 *
 * @param connection must not be {@literal null}.
 * @return
 */
public static RedisConditions of(StatefulRedisConnection<String, String> connection) {
    return new RedisConditions(connection.sync());
}