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

/**
 * 设置List缓存
 *
 * @param key          键
 * @param value        值
 * @param cacheSeconds 超时时间，0为不超时
 * @return
 */
public static long setList(String key, List<String> value, int cacheSeconds) {
    long result = 0;
    Jedis jedis = null;
    try {
        jedis = getResource();
        if (jedis.exists(key)) {
            jedis.del(key);
        }
        for (String v : value) {
            result += jedis.rpush(key, v);
        }
        if (cacheSeconds != 0) {
            jedis.expire(key, cacheSeconds);
        }
    } catch (Exception e) {
        logger.warn("setList {} = {}", key, value, e);
    } finally {
        close(jedis);
    }
    return result;
}
 

@Override
protected void append(ILoggingEvent event) {
    Jedis client = pool.getResource();
    try {

        String json = layout == null ? jsonlayout.doLayout(event) : layout.doLayout(event);
        client.rpush(key, json);
    } catch (Exception e) {
        log.error("e message: {}", e.getMessage());
        pool.returnBrokenResource(client);
        client = null;
    } finally {
        if (client != null) {
            pool.returnResource(client);
        }
    }
}
 

@Override
public void rpush(final String listName, final String value) {
    Jedis jedis = null;
    try {
        jedis = getInstance();
        jedis.rpush(listName, value);
    } catch (Exception e) {
        if (LOG.isErrorEnabled()) {
            LOG.error("Cannot send Redis message with command RPUSH to list {} error message {}",
                listName, e.getMessage());
        }
        throw e;
    } finally {
        releaseInstance(jedis);
    }
}
 

/**
 * 向Set缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
public static long setSetObjectAdd(String key, Object... value) {
	long result = 0;
	Jedis jedis = null;
	try {
		jedis = getResource();
		Set<byte[]> set = Sets.newHashSet();
		for (Object o : value){
			set.add(toBytes(o));
		}
		result = jedis.rpush(getBytesKey(key), (byte[][])set.toArray());
		logger.debug("setSetObjectAdd {} = {}", key, value);
	} catch (Exception e) {
		logger.warn("setSetObjectAdd {} = {}", key, value, e);
	} finally {
		returnResource(jedis);
	}
	return result;
}
 

/**
 * 向List缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
public static long listObjectAdd(String key, Object... value) {
	long result = 0;
	Jedis jedis = null;
	try {
		jedis = getResource();
		List<byte[]> list = Lists.newArrayList();
		for (Object o : value){
			list.add(toBytes(o));
		}
		result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
		logger.debug("listObjectAdd {} = {}", key, value);
	} catch (Exception e) {
		logger.warn("listObjectAdd {} = {}", key, value, e);
	} finally {
		returnResource(jedis);
	}
	return result;
}
 

/**
 * 设置List缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间，0为不超时
 * @return
 */
public static long setObjectList(String key, List<Object> value, int cacheSeconds) {
	long result = 0;
	Jedis jedis = null;
	try {
		jedis = getResource();
		if (jedis.exists(getBytesKey(key))) {
			jedis.del(key);
		}
		List<byte[]> list = Lists.newArrayList();
		for (Object o : value){
			list.add(toBytes(o));
		}
		result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
		if (cacheSeconds != 0) {
			jedis.expire(key, cacheSeconds);
		}
		logger.debug("setObjectList {} = {}", key, value);
	} catch (Exception e) {
		logger.warn("setObjectList {} = {}", key, value, e);
	} finally {
		returnResource(jedis);
	}
	return result;
}
 

private void addDataToConnection(Jedis conn, String key, String data) {
    try {
        if (redisDataType == RedisDataType.REDIS_DATA_TYPE_LIST) {
            log.debug("Executing rpush against redis list");
            // Add data string to list's tail
            conn.rpush(redisKey, data);
        } else if (redisDataType == RedisDataType.REDIS_DATA_TYPE_SET) {
            log.debug("Executing sadd against redis set");
            conn.sadd(key, data);
        } else {
            log.warn("Unexpected redis datatype: {0}".format(key));
        }
    } catch (JedisDataException jde) {
        log.error("Exception when adding data to Redis: " + jde);
    }
}
 

@Override
public boolean addLast(String queueID, ResourceItem e) {
    if (!lockQueue(queueID)) {
        return false;
    }
    remove(queueID, e.getKey());
    Jedis jedis = jedisPool.getResource();
    try {
        jedis.rpush(makePoolQueueKey(queueID), e.getKey());
        jedis.hset(makeDataKey(queueID), e.getKey(), JSONObject.toJSONString(e));
    } finally {
        IOUtils.closeQuietly(jedis);
        unLockQueue(queueID);
    }
    return true;
}
 

/**
 * 向List缓存中添加值
 *
 * @param key   键
 * @param value 值
 * @return
 */
public static long listObjectAdd(String key, Object... value) {
    long result = 0;
    Jedis jedis = null;
    try {
        jedis = getResource();
        for (Object o : value) {
            result += jedis.rpush(getBytesKey(key), toBytes(o));
        }
    } catch (Exception e) {
        logger.warn("listObjectAdd {} = {}", key, value, e);
    } finally {
        close(jedis);
    }
    return result;
}
 

private void pushToTaskWriteQueue(Document doc) {
      Jedis jedis = DataStore.getJedisConnection();
try {
	jedis.rpush(
			TaggerConfigurator
					.getInstance()
					.getProperty(
							TaggerConfigurationProperty.REDIS_LABEL_TASK_WRITE_QUEUE)
					.getBytes(), Serializer.serialize(doc));
} catch (IOException e) {
	logger.warn("Exception while serializing DocumentSet.");
}
DataStore.close(jedis);
  }
 

private void enqueue(Document doc) {
	Jedis jedis = DataStore.getJedisConnection();

	try {
		jedis.rpush(outputQueueName, Serializer.serialize(doc));
	} catch (IOException e) {
		logger.error("Error when serializing input document.", e);
	} finally {
		DataStore.close(jedis);
	}
}
 

@Override
public void listAppend(String key, String value) {
    Jedis jedis = borrowJedis();

    if(null!=jedis){
        jedis.rpush(key, value);
        returnJedis(jedis);
    }
}
 

/**
 * 向List缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
public static long listAdd(String key, String... value) {
	long result = 0;
	Jedis jedis = null;
	try {
		jedis = getResource();
		result = jedis.rpush(key, value);
		logger.debug("listAdd {} = {}", key, value);
	} catch (Exception e) {
		logger.warn("listAdd {} = {}", key, value, e);
	} finally {
		returnResource(jedis);
	}
	return result;
}
 

/**
 * 向List缓存中添加值
 *
 * @param key   键
 * @param value 值
 * @return
 */
public static long listAdd(String key, String... value) {
    long result = 0;
    Jedis jedis = null;
    try {
        jedis = getResource();
        result = jedis.rpush(key, value);
    } catch (Exception e) {
        logger.warn("listAdd {} = {}", key, value, e);
    } finally {
        close(jedis);
    }
    return result;
}
 

private void initTestData() {
  TEST_VALUE.add("testValue1");
  TEST_VALUE.add("testValue2");
  TEST_VALUE.add("testValue3");
  TEST_VALUE.add("testValue4");
  TEST_VALUE.add("testValue5");

  Jedis redisClient = new Jedis(URI.create(String.format(REDIS_URI_TEMPLATE, redisPort)));

  redisClient.del(TEST_KEY);
  redisClient.rpush(TEST_KEY, TEST_VALUE.toArray(new String[TEST_VALUE.size()]));

  redisClient.close();
}
 

@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);
    }
}
 

private Long rpush0(Jedis j, String key, String... values) {
	return j.rpush(key, values);
}
 

/**
 * 向List头部追加记录
 * 
 * @param  key
 * @param  value
 * @return 记录总数
 */
public long rpush(byte[] key, byte[] value) {
	Jedis jedis = getJedis();
	long count = jedis.rpush(key, value);
	jedis.close();
	return count;
}
 

/**
 * 向List头部追加记录
 * 
 * @param  key
 * @param  value
 * @return 记录总数
 */
public long rpush(String key, String value) {
	Jedis jedis = getJedis();
	long count = jedis.rpush(key, value);
	jedis.close();
	return count;
}
 

/**
 * 向List头部追加记录
 * 
 * @param String
 *            key
 * @param String
 *            value
 * @return 记录总数
 * */
public long rpush(String key, String value) {
	Jedis jedis = getJedis();
	long count = jedis.rpush(key, value);
	returnJedis(jedis);
	return count;
}