import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
@Test
public void clientKillExtended() {

    RedisConnection<String, String> connection2 = client.connect().sync();
    connection2.clientSetname("killme");

    Pattern p = Pattern.compile("^.*addr=([^ ]+).*name=killme.*$", Pattern.MULTILINE | Pattern.DOTALL);
    String clients = redis.clientList();
    Matcher m = p.matcher(clients);

    assertThat(m.matches()).isTrue();
    String addr = m.group(1);
    assertThat(redis.clientKill(KillArgs.Builder.addr(addr).skipme())).isGreaterThan(0);

    assertThat(redis.clientKill(KillArgs.Builder.id(4234))).isEqualTo(0);
    assertThat(redis.clientKill(KillArgs.Builder.typeSlave().id(4234))).isEqualTo(0);
    assertThat(redis.clientKill(KillArgs.Builder.typeNormal().id(4234))).isEqualTo(0);
    assertThat(redis.clientKill(KillArgs.Builder.typePubsub().id(4234))).isEqualTo(0);

    connection2.close();
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
@Test
public void testCreate() throws Exception {

    RedisConnection<String, String> connection = PoolingProxyFactory.create(client.pool());

    connection.set("a", "b");
    connection.close();

    try {
        connection.set("x", "y");
        fail("missing exception");
    } catch (RedisException e) {
        assertThat(e.getMessage()).isEqualTo("Connection pool is closed");

    }
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
@POST
@Path("testLettuce")
public void testLettuce(String jsonString) {

    RedisClient redisClient = RedisClient.create("redis://localhost:6379/0");
    RedisConnection<String, String> conn1 = redisClient.connect();

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

    conn1.close();
    redisClient.shutdown();

    RedisClient client = RedisClient.create("redis://localhost:6379/0");
    RedisAsyncConnection<String, String> conn = client.connectAsync();
    conn.set("foo", "bar");

    conn.get("foo");

    conn.lpush("lll", "a");
    conn.lpush("lll", "b");
    conn.lpush("lll", "c");
    conn.lpop("lll");
    conn.lpop("lll");
    conn.lpop("lll");

    conn.hset("mmm", "abc", "123");
    conn.hset("mmm", "def", "456");
    conn.hgetall("mmm");

    conn.del("foo", "lll", "mmm");

    conn.close();
    client.shutdown();
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
@GET
@Path("lettucetest")
@Produces(MediaType.TEXT_HTML + ";charset=utf-8")
public String lettucetest() {

    System.out.println("TEST Lettuce sync ======================================================");
    RedisClient redisClient = RedisClient.create("redis://localhost:6379/0");
    RedisConnection<String, String> conn = redisClient.connect();

    conn.set("foo", "bar");

    conn.get("foo");

    conn.lpush("lll", "a");
    conn.lpush("lll", "b");
    conn.lpush("lll", "c");
    conn.lpop("lll");
    conn.lpop("lll");
    conn.lpop("lll");

    conn.hset("mmm", "abc", "123");
    conn.hset("mmm", "def", "456");
    conn.hgetall("mmm");

    conn.del("foo", "lll", "mmm");

    conn.close();
    redisClient.shutdown();
    return "lettucetest";
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
private static void testSync() {

        System.out.println("TEST Lettuce sync ======================================================");
        RedisClient redisClient = RedisClient.create("redis://localhost:6379/0");
        RedisConnection<String, String> conn = redisClient.connect();

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

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

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

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
private Factory<RedisConnection> getRedisConnectionFactory() {
    final ConnectionConfig.RedisConnectionConfig connectionConfig = (ConnectionConfig.RedisConnectionConfig) cacheConfig.getConnectionConfig();

    if (connectionConfig != null) {
        if (connectionConfig.getPool() != null) {
            return new RedisConnectionPoolFactory(RedisClient.create(getRedisUri()), getRedisCodec());
        } else {
            return new RedisConnectionFactory(RedisClient.create(getRedisUri()), getRedisCodec());
        }
    }
    return null;
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
@Test
public void watch() {
    assertThat(redis.watch(key)).isEqualTo("OK");

    RedisConnection<String, String> redis2 = client.connect().sync();
    redis2.set(key, value + "X");
    redis2.close();

    redis.multi();
    redis.append(key, "foo");
    assertThat(redis.exec()).isEqualTo(list());

}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
@Test
public void testCreateDefault() throws Exception {

    RedisConnectionPool<RedisCommands<String, String>> pool = client.pool();
    RedisConnection<String, String> connection = PoolingProxyFactory.create(pool);

    connection.set("a", "b");
    connection.set("x", "y");

    pool.close();
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
@Test
public void testCloseReturnsConnection() throws Exception {

    RedisConnectionPool<RedisCommands<String, String>> pool = client.pool();
    assertThat(pool.getNumActive()).isEqualTo(0);
    RedisConnection<String, String> connection = pool.allocateConnection();
    assertThat(pool.getNumActive()).isEqualTo(1);
    connection.close();
    assertThat(pool.getNumActive()).isEqualTo(0);
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
public Builder(String id, TypeConfig.Cache cacheType, Factory<RedisConnection<K,V>> connFactory) {
    super(id, cacheType);
    this.connFactory = connFactory;
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
public Factory<RedisConnection<K, V>> getConnFactory() {
    return connFactory;
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
public RedisAbstractCache(RedisConnection<K, V> redisConnection) {
    this(redisConnection, null);
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
public RedisStringsCache(RedisConnection<K, V> redisConnection) {
    this(redisConnection, null);
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
public RedisHashesCache(RedisConnection<K, V> redisConnection, K key) {
    this(redisConnection, key, null);
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
public RedisConnection<K, V> create() {
    return redisClient.pool(codec, MAX_IDLE, MAX_ACTIVE).allocateConnection();
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
@Override
public RedisConnection<K, V> create() {
    return redisClient.connect(codec);
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
public static RedisConnection<String, String> getConnection() {
    return connection;
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的package包/类
public static RedisConnection<String, String> getConnection1() {
    return connection1;
}
 

import com.lambdaworks.redis.RedisConnection; //导入依赖的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.RedisConnection; //导入依赖的package包/类
public RedisConnection<String, String> getRedis() {
	return redis;
}