redis.clients.jedis.util.Pool Java Examples

public Pool<Jedis> build(
    String name, JedisDriverProperties properties, GenericObjectPoolConfig objectPoolConfig) {
  if (properties.connection == null || "".equals(properties.connection)) {
    throw new MissingRequiredConfiguration("Jedis client must have a connection defined");
  }

  URI redisConnection = URI.create(properties.connection);

  String host = redisConnection.getHost();
  int port = redisConnection.getPort() == -1 ? Protocol.DEFAULT_PORT : redisConnection.getPort();
  int database = parseDatabase(redisConnection.getPath());
  String password = parsePassword(redisConnection.getUserInfo());
  GenericObjectPoolConfig poolConfig =
      Optional.ofNullable(properties.poolConfig).orElse(objectPoolConfig);
  boolean isSSL = redisConnection.getScheme().equals("rediss");

  return new InstrumentedJedisPool(
      registry,
      // Pool name should always be "null", as setting this is incompat with some SaaS Redis
      // offerings
      new JedisPool(
          poolConfig, host, port, properties.timeoutMs, password, database, null, isSSL),
      name);
}
 

@Override
public Pool<Jedis> getObject() throws Exception {
    if (!inited) {
        jedisPool = (Pool<Jedis>) autoConfigureBeans.getCustomContainer().get("jedisPool." + key);
        inited = true;
    }
    return jedisPool;
}
 

@Override
protected CacheBuilder initCache(ConfigTree ct, String cacheAreaWithPrefix) {
    Pool jedisPool = parsePool(ct);
    Pool[] slavesPool = null;
    int[] slavesPoolWeights = null;
    boolean readFromSlave = Boolean.parseBoolean(ct.getProperty("readFromSlave", "False"));
    ConfigTree slaves = ct.subTree("slaves.");
    Set<String> slaveNames = slaves.directChildrenKeys();
    if (slaveNames.size() > 0) {
        slavesPool = new Pool[slaveNames.size()];
        slavesPoolWeights = new int[slaveNames.size()];
        int i = 0;
        for (String slaveName: slaveNames) {
            ConfigTree slaveConfig = slaves.subTree(slaveName + ".");
            slavesPool[i] = parsePool(slaveConfig);
            slavesPoolWeights[i] = Integer.parseInt(slaveConfig.getProperty("weight","100"));
            i++;
        }
    }

    ExternalCacheBuilder externalCacheBuilder = RedisCacheBuilder.createRedisCacheBuilder()
            .jedisPool(jedisPool)
            .readFromSlave(readFromSlave)
            .jedisSlavePools(slavesPool)
            .slaveReadWeights(slavesPoolWeights);

    parseGeneralConfig(externalCacheBuilder, ct);

    // eg: "jedisPool.remote.default"
    autoConfigureBeans.getCustomContainer().put("jedisPool." + cacheAreaWithPrefix, jedisPool);

    return externalCacheBuilder;
}
 

public void test() {
    Assert.assertNotNull(c1.unwrap(com.github.benmanes.caffeine.cache.Cache.class));
    EmbeddedCacheConfig cc1 = (EmbeddedCacheConfig) c1.config();
    Assert.assertEquals(200, cc1.getLimit());
    Assert.assertEquals(10000, cc1.getExpireAfterWriteInMillis());
    Assert.assertFalse(cc1.isExpireAfterAccess());
    Assert.assertSame(FastjsonKeyConvertor.INSTANCE, cc1.getKeyConvertor());

    RedisCacheConfig c = (RedisCacheConfig) c2.config();
    Assert.assertFalse(c.isReadFromSlave());
    Pool[] slavePools = c.getJedisSlavePools();
    Assert.assertEquals(2, slavePools.length);
    int[] ws = c.getSlaveReadWeights();
    Assert.assertTrue(Arrays.equals(new int[]{30, 100}, ws) || Arrays.equals(new int[]{100, 30}, ws));
}
 

@Test
public void tests() throws Exception {
    System.setProperty("spring.profiles.active", "redis");
    context = SpringApplication.run(RedisStarterTest.class);
    doTest();
    A bean = context.getBean(A.class);
    bean.test();

    Pool<Jedis> t1 = (Pool<Jedis>) context.getBean("defaultPool");
    Pool<Jedis> t2 = (Pool<Jedis>) context.getBean("A1Pool");
    Assert.assertNotNull(t1);
    Assert.assertNotNull(t2);
    Assert.assertNotSame(t1, t2);
}
 

public Pool<Jedis> createPool(RedisConnectionConfig connectionConfig) {
    final RedisConnectionConfig.RedisScheme scheme = connectionConfig.getScheme();
    if (scheme == null) {
        throw getUnsupportedSchemeException();
    }
    switch (scheme) {
        case NODE:
            return poolCreator.createJedisPool(connectionConfig);
        case SENTINEL:
            return poolCreator.createJedisSentinelPool(connectionConfig);
        default:
            throw getUnsupportedSchemeException();
    }
}
 

Pool<Jedis> getReadPool() {
    if (!config.isReadFromSlave()) {
        return config.getJedisPool();
    }
    int[] weights = config.getSlaveReadWeights();
    int index = randomIndex(weights);
    return config.getJedisSlavePools()[index];
}
 

@Override
public <T> T unwrap(Class<T> clazz) {
    if (Pool.class.isAssignableFrom(clazz)) {
        return (T) config.getJedisPool();
    }
    throw new IllegalArgumentException(clazz.getName());
}
 

public static HealthIndicator build(JedisClientDelegate client) {
  try {
    final JedisClientDelegate src = client;
    final Field clientAccess = JedisClientDelegate.class.getDeclaredField("jedisPool");
    clientAccess.setAccessible(true);

    return build((Pool<Jedis>) clientAccess.get(src));
  } catch (IllegalAccessException | NoSuchFieldException e) {
    throw new BeanCreationException("Error creating Redis health indicator", e);
  }
}
 

public static HealthIndicator build(Pool<Jedis> jedisPool) {
  try {
    final Pool<Jedis> src = jedisPool;
    final Field poolAccess = Pool.class.getDeclaredField("internalPool");
    poolAccess.setAccessible(true);
    GenericObjectPool<Jedis> internal = (GenericObjectPool<Jedis>) poolAccess.get(jedisPool);
    return () -> {
      Jedis jedis = null;
      Health.Builder health;
      try {
        jedis = src.getResource();
        if ("PONG".equals(jedis.ping())) {
          health = Health.up();
        } else {
          health = Health.down();
        }
      } catch (Exception ex) {
        health = Health.down(ex);
      } finally {
        if (jedis != null) jedis.close();
      }
      health.withDetail("maxIdle", internal.getMaxIdle());
      health.withDetail("minIdle", internal.getMinIdle());
      health.withDetail("numActive", internal.getNumActive());
      health.withDetail("numIdle", internal.getNumIdle());
      health.withDetail("numWaiters", internal.getNumWaiters());

      return health.build();
    };
  } catch (IllegalAccessException | NoSuchFieldException e) {
    throw new BeanCreationException("Error creating Redis health indicator", e);
  }
}
 

/**
 * Create a new client to a RediSearch index
 *
 * @param indexName the name of the index we are connecting to or creating
 * @param pool jedis connection pool to be used
 */
public Client(String indexName, Pool<Jedis> pool) {
  this.indexName = indexName;
  this.endocdedIndexName = SafeEncoder.encode(indexName);
  this.pool = pool;
  this.commands = new Commands.SingleNodeCommands();
}
 

public JedisClientDelegate(Pool<Jedis> jedisPool) {
  this("default", jedisPool);
}
 

public void setJedisPool(Pool<Jedis> jedisPool) {
    this.jedisPool = jedisPool;
}
 

public RedisJobStore setJedisPool(Pool<Jedis> jedisPool) {
    this.jedisPool = jedisPool;
    return this;
}
 

public JedisClientDelegate(String name, Pool<Jedis> jedisPool) {
  this.name = name;
  this.jedisPool = jedisPool;
}
 

private synchronized Pool<Jedis> getPool() {
    if (pool == null) {
        pool = poolFactory.createPool(connectionConfig);
    }
    return pool;
}
 

private JedisPoolTemplate(Pool<Jedis> jedisPool) {
    this.jedisPool = jedisPool;
}
 

public JedisLockProvider(@NonNull Pool<Jedis> jedisPool) {
    this(jedisPool, ENV_DEFAULT);
}
 

public JedisPoolFactory(String key, Class<? extends Pool<Jedis>> poolClass){
    this.key = key;
    this.poolClass = poolClass;
}
 

private void testWithPool(Pool<Jedis> pool) throws Exception {
    cache = RedisCacheBuilder.createRedisCacheBuilder()
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .valueEncoder(JavaValueEncoder.INSTANCE)
            .valueDecoder(JavaValueDecoder.INSTANCE)
            .jedisPool(pool)
            .keyPrefix(new Random().nextInt() + "")
            .expireAfterWrite(500, TimeUnit.MILLISECONDS)
            .buildCache();

    Assert.assertSame(pool, cache.unwrap(Pool.class));
    if (pool instanceof JedisPool) {
        Assert.assertSame(pool, cache.unwrap(JedisPool.class));
    } else {
        Assert.assertSame(pool, cache.unwrap(JedisSentinelPool.class));
    }

    baseTest();
    fastjsonKeyCoverterTest();
    expireAfterWriteTest(cache.config().getExpireAfterWriteInMillis());

    LoadingCacheTest.loadingCacheTest(RedisCacheBuilder.createRedisCacheBuilder()
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .valueEncoder(JavaValueEncoder.INSTANCE)
            .valueDecoder(JavaValueDecoder.INSTANCE)
            .jedisPool(pool)
            .keyPrefix(new Random().nextInt() + ""), 0);
    RefreshCacheTest.refreshCacheTest(RedisCacheBuilder.createRedisCacheBuilder()
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .valueEncoder(JavaValueEncoder.INSTANCE)
            .valueDecoder(JavaValueDecoder.INSTANCE)
            .jedisPool(pool)
            .keyPrefix(new Random().nextInt() + ""), 200, 100);


    cache = RedisCacheBuilder.createRedisCacheBuilder()
            .keyConvertor(null)
            .valueEncoder(KryoValueEncoder.INSTANCE)
            .valueDecoder(KryoValueDecoder.INSTANCE)
            .jedisPool(pool)
            .keyPrefix(new Random().nextInt() + "")
            .buildCache();
    nullKeyConvertorTest();

    int thread = 10;
    int time = 3000;
    cache = RedisCacheBuilder.createRedisCacheBuilder()
            .keyConvertor(FastjsonKeyConvertor.INSTANCE)
            .valueEncoder(KryoValueEncoder.INSTANCE)
            .valueDecoder(KryoValueDecoder.INSTANCE)
            .jedisPool(pool)
            .keyPrefix(new Random().nextInt() + "")
            .buildCache();
    concurrentTest(thread, 500, time);
}
 

public void setJedisSlavePools(Pool<Jedis>... jedisSlavePools) {
    this.jedisSlavePools = jedisSlavePools;
}
 

public Pool<Jedis>[] getJedisSlavePools() {
    return jedisSlavePools;
}
 

public void setJedisPool(Pool<Jedis> jedisPool) {
    this.jedisPool = jedisPool;
}
 

public Pool<Jedis> getJedisPool() {
    return jedisPool;
}
 

public void setJedisSlavePools(Pool<Jedis>... jedisSlavePools) {
    getConfig().setJedisSlavePools(jedisSlavePools);
}
 

public void setJedisPool(Pool<Jedis> jedisPool) {
    getConfig().setJedisPool(jedisPool);
}
 

public T jedisPool(Pool<Jedis> pool) {
    getConfig().setJedisPool(pool);
    return self();
}
 

@Test
public void create_jedis_pool_on_node_scheme() throws Exception {

    when(redisConnectionConfig.getScheme()).thenReturn(RedisConnectionConfig.RedisScheme.NODE);

    final Pool<Jedis> pool = jedisPoolFactory.createPool(redisConnectionConfig);

    assertThat(pool, is(instanceOf(JedisPool.class)));
}
 

@Test
public void create_sentinel_pool_on_sentinel_scheme() throws Exception {

    when(redisConnectionConfig.getScheme()).thenReturn(RedisConnectionConfig.RedisScheme.SENTINEL);

    final Pool<Jedis> pool = jedisPoolFactory.createPool(redisConnectionConfig);

    assertThat(pool, is(instanceOf(JedisSentinelPool.class)));
}
 

@Test(expected = IllegalArgumentException.class)
public void exception_on_null_scheme() throws Exception {

    when(redisConnectionConfig.getScheme()).thenReturn(null);

    final Pool<Jedis> pool = jedisPoolFactory.createPool(redisConnectionConfig);

    assertThat(pool, is(instanceOf(JedisPool.class)));
}