Java Code Examples for redis.clients.jedis.Jedis#hkeys()

public Set<String> hKeys(String key) throws Exception {
    Jedis jedis = null;
    try {
        jedis = this.jedisPool.getResource();
        Set<byte[]> hkeys = jedis.hkeys(SafeEncoder.encode(key));
        logger.info("hkeys key:" + key);
        if (CollectionUtils.isEmpty(hkeys)) {
            return new HashSet<String>(1);
        } else {
            Set<String> keys = new HashSet<String>(hkeys.size());
            for (byte[] bb : hkeys) {
                keys.add(SafeEncoder.encode(bb));
            }
            return keys;
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
        this.jedisPool.returnBrokenResource(jedis);
        throw e;
    } finally {
        if (jedis != null) {
            this.jedisPool.returnResource(jedis);
        }
    }
}
 

/**
 * Retrieves job from redis.
 *
 * @param jobKey the job key
 * @param jedis thread-safe redis connection
 * @return the job detail
 * @throws JobPersistenceException
 */
@SuppressWarnings("unchecked")
private JobDetail retrieveJob(JobKey jobKey, Jedis jedis) throws JobPersistenceException, ClassNotFoundException {
	String jobHashkey = createJobHashKey(jobKey.getGroup(), jobKey.getName());
	String jobDataMapHashKey = createJobDataMapHashKey(jobKey.getGroup(), jobKey.getName());
     if (!jedis.exists(jobHashkey)) {
        log.warn("job: " + jobHashkey + " does not exist");
        return null;
     }
	Class<Job> jobClass = (Class<Job>) loadHelper.getClassLoader().loadClass(jedis.hget(jobHashkey, JOB_CLASS));
	JobBuilder jobBuilder = JobBuilder.newJob(jobClass)
								.withIdentity(jobKey)
								.withDescription(jedis.hget(jobHashkey, DESCRIPTION))
								.storeDurably(Boolean.getBoolean(jedis.hget(jobHashkey, IS_DURABLE)));
							
	Set<String> jobDataMapFields = jedis.hkeys(jobDataMapHashKey);
	if (!jobDataMapFields.isEmpty()) {
		for (String jobDataMapField : jobDataMapFields)
			jobBuilder.usingJobData(jobDataMapField, jedis.hget(jobDataMapHashKey, jobDataMapField));							
	}
	
	return jobBuilder.build();		
}
 

@Override
public Set<String> notExisted(String queueID, Set<String> resourceItemKeys) {
    if (!lockQueue(queueID)) {
        return Collections.emptySet();
    }
    Jedis jedis = jedisPool.getResource();
    try {
        final Set<String> hkeys = jedis.hkeys(makeDataKey(queueID));
        return Sets.filter(resourceItemKeys, new Predicate<String>() {
            @Override
            public boolean apply(String input) {
                return !hkeys.contains(input);
            }
        });
    } finally {
        IOUtils.closeQuietly(jedis);
        unLockQueue(queueID);
    }
}
 

@Override
public void addBatch(String queueID, Set<ResourceItem> resourceItems) {
    if (!lockQueue(queueID)) {
        return;
    }
    final Jedis jedis = jedisPool.getResource();
    final String dataKey = makeDataKey(queueID);
    try {
        final Set<String> hkeys = jedis.hkeys(dataKey);
        Set<ResourceItem> filterSet = Sets.filter(resourceItems, new Predicate<ResourceItem>() {
            @Override
            public boolean apply(ResourceItem input) {
                return !hkeys.contains(input.getKey());
            }
        });

        String poolQueueKey = makePoolQueueKey(queueID);
        for (ResourceItem resourceItem : filterSet) {
            jedis.hset(dataKey, resourceItem.getKey(), JSONObject.toJSONString(resourceItem));
            jedis.rpush(poolQueueKey, resourceItem.getKey());
        }
    } finally {
        IOUtils.closeQuietly(jedis);
        unLockQueue(queueID);
    }
}
 

@Override
public Set<String> notExisted(String queueID, Set<String> resourceItemKeys) {
    if (!lockQueue(queueID)) {
        return Collections.emptySet();
    }
    @Cleanup Jedis jedis = jedisPool.getResource();
    try {
        final Set<String> existedSet = jedis.hkeys(makeDataKey(queueID));
        return Sets.filter(resourceItemKeys, new Predicate<String>() {
            @Override
            public boolean apply(String input) {
                return !existedSet.contains(input);
            }
        });
    } finally {
        unLockQueue(queueID);
    }
}
 

@Override
public Set<String> notExisted(String queueID, Set<String> resourceItemKeys) {
    if (!lockQueue(queueID)) {
        return Collections.emptySet();
    }
    Jedis jedis = jedisPool.getResource();
    try {
        final Set<String> hkeys = jedis.hkeys(makeDataKey(queueID));
        return Sets.filter(resourceItemKeys, new Predicate<String>() {
            @Override
            public boolean apply(String input) {
                return !hkeys.contains(input);
            }
        });
    } finally {
        unLockQueue(queueID);
        IOUtils.closeQuietly(jedis);
    }
}
 

/**
 * 取得hash的 keys
 *
 * @param key
 * @return
 */
public static Set<byte[]> hkeys(final String key) {
    Jedis jedis = null;
    Set<byte[]> result = null;
    try {
        jedis = getResource();
        result = jedis.hkeys(getBytesKey(key));
    } finally {
        close(jedis);
    }
    return result;
}
 

/**
 * 返回指定hash中的所有存储名字,类似Map中的keySet方法
 * 
 * @param String
 *            key
 * @return Set<String> 存储名称的集合
 * */
public Set<String> hkeys(String key) {
	// ShardedJedis sjedis = getShardedJedis();
	Jedis sjedis = getJedis();
	Set<String> set = sjedis.hkeys(key);
	returnJedis(sjedis);
	return set;
}
 

@Override
public void addBatch(String queueID, Set<ResourceItem> resourceItems) {
    if (!lockQueue(queueID)) {
        return;
    }
    @Cleanup Jedis jedis = jedisPool.getResource();
    final String dataKey = makeDataKey(queueID);
    try {
        final Set<String> hkeys = jedis.hkeys(dataKey);
        Set<ResourceItem> filterSet = Sets.filter(resourceItems, new Predicate<ResourceItem>() {
            @Override
            public boolean apply(ResourceItem input) {
                return !hkeys.contains(input.getKey());
            }
        });
        List<String> sliceQueue = sliceQueue(queueID);
        Set<String> newSlices = Sets.newHashSet();
        long index = size(queueID) + 1;
        String tailSlice = null;
        for (ResourceItem resourceItem : filterSet) {
            jedis.hset(dataKey, resourceItem.getKey(), JSONObject.toJSONString(resourceItem));
            String sliceID = String.valueOf(blockID(index));
            if (sliceID.equals(tailSlice) || sliceQueue.contains(sliceID)) {
                sliceID = sliceQueue.get(sliceQueue.size() - 1);
                tailSlice = sliceID;
            } else if (!newSlices.contains(sliceID)) {
                jedis.rpush(makeSliceQueueKey(queueID), sliceID);
                newSlices.add(sliceID);
            }
            jedis.rpush(makePoolQueueKey(queueID, sliceID), resourceItem.getKey());
            index++;
        }
    } finally {
        unLockQueue(queueID);
    }
}
 

@Override
public Set<String> hkeys(String key) {
    Jedis jedis = null;
    Set<String> res = null;
    try {
        jedis = pool.getResource();
        res = jedis.hkeys(key);
    } catch (Exception e) {

        LOGGER.error(e.getMessage());
    } finally {
        returnResource(pool, jedis);
    }
    return res;
}
 

@Override
protected int doRequest(Jedis jedis, String redisAddress) {
  Set<byte[]> fields = jedis.hkeys(key.getBytes());
  redisFields[index] = fields;

  if (CollectionUtils.isEmpty(fields)) {
    String verbose = String.format("get fields [%s] from [%s] is empty", key, redisAddress);
    LOGGER.debug(verbose);
    return 1;
  }

  return 0;
}
 

@Override
public Set<String> hkeys(String key) {
    Jedis jedis = jedisPool.getResource();
    Set<String> result = jedis.hkeys(key);
    jedis.close();
    return result;
}
 

public List<String> hkeys(String key) {
	Jedis client = jedisPool.getResource();
	try {
		List<String> fields = new ArrayList<String>();
		Set<String> set = client.hkeys(key);
		fields.addAll(set);
		return fields;
	} finally {
		// 向连接池“归还”资源
		jedisPool.returnResourceObject(client);
	}

}
 

/**
 * 返回指定hash中的所有存储名字,类似Map中的keySet方法
 * 
 * @param  key
 * @return Set<String> 存储名称的集合
 */
public Set<String> hkeys(String key) {
	Jedis sjedis = getJedis();
	Set<String> set = sjedis.hkeys(key);
	sjedis.close();
	return set;
}
 

/**
 * <p>
 * 通过key返回所有的field
 * </p>
 *
 * @param key
 * @return
 */
public Set<String> hkeys(String key) {
    Jedis jedis = null;
    Set<String> res = null;
    try {
        jedis = jedisPool.getResource();
        res = jedis.hkeys(key);
    } catch (Exception e) {

        log.error(e.getMessage());
    } finally {
        returnResource(jedisPool, jedis);
    }
    return res;
}
 

@Test
public void testJedis() {

  String host = "localhost";
  int port = 6379;
  String key = "test_xxx";
  String keyNotExist = "test_not_exist";

  String field = "field_1";
  String value = "value_1";

  String fieldNotExist = "field_not_exist";

  JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  jedisPoolConfig.setMaxTotal(Config.getInstance().getJedisPoolMax());

  JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, Config.getInstance().getJedisSocketTimeoutMs(), Config.getInstance().getRedisPassword());
  Jedis jedis = jedisPool.getResource();

  jedis.hset(key.getBytes(), field.getBytes(), value.getBytes());

  // hgetAll
  Map<byte[], byte[]> result = jedis.hgetAll(key.getBytes());
  Assert.assertTrue(MapUtils.isNotEmpty(result));

  result = jedis.hgetAll(keyNotExist.getBytes());
  Assert.assertTrue(MapUtils.isEmpty(result));

  // hkeys
  Set<byte[]> redisKeys = jedis.hkeys(key.getBytes());
  Assert.assertTrue(CollectionUtils.isNotEmpty(redisKeys));

  redisKeys = jedis.hkeys(keyNotExist.getBytes());
  Assert.assertTrue(CollectionUtils.isEmpty(redisKeys));


  // hget
  byte[] redisValue = jedis.hget(key.getBytes(), field.getBytes());
  Assert.assertTrue(!ArrayUtils.isEmpty(redisValue));

  redisValue = jedis.hget(key.getBytes(), fieldNotExist.getBytes());
  Assert.assertTrue(ArrayUtils.isEmpty(redisValue));

  redisValue = jedis.hget(keyNotExist.getBytes(), field.getBytes());
  Assert.assertTrue(ArrayUtils.isEmpty(redisValue));

}
 

private Set<String> hkeys0(Jedis j, String key) {
	return j.hkeys(key);
}