類結構圖：
BaseJedisHandler
package com.wj.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* 抽象 Jedis 共有方法
*/
public abstract class BaseJedisHandler implements Constants {
/**
* jedis 連接池
*/
private static JedisPool jedisPool;
BaseJedisHandler() {
}
static {
JedisPoolConfig config = new JedisPoolConfig();
/*
* 控制一個 pool 可分配多少個 jedis 實例，通過 pool.getResource() 來獲取
*
* 如果賦值爲-1，則表示不限制
*
* 如果 pool 已經分配了 maxActive 個 jedis 實例，則此時pool的狀態爲exhausted(耗盡)
*/
config.setMaxTotal(500);
/*
* 控制一個 pool 最多有多少個狀態爲 idle(空閒的) 的 jedis 實例。
*/
config.setMaxIdle(5);
/*
* 表示當 borrow(引入) 一個 jedis 實例時，最大的等待時間，如果超過等待時間，則直接拋出 JedisConnectionException
*/
config.setMaxWaitMillis(100_1000);
/*
* 在 borrow 一個 jedis 實例時，是否提前進行 validate 操作
*
* 如果爲true，則得到的 jedis 實例均是可用的
*/
config.setTestOnBorrow(true);
/* redis如果設置了密碼 */
// jedisPool = new JedisPool(config, "localhost", 6379, 10000, "password");
/* redis未設置了密碼 */
jedisPool = new JedisPool(config, "localhost", 6379);
}
/**
* 從jedis連接池中獲取獲取jedis對象
*
* @return Jedis 對象
*/
Jedis getJedis() {
return jedisPool.getResource();
}
/**
* 回收 jedis( 放到finally中 )
*
* @param jedis 待回收的Jedis
*/
void returnJedis(Jedis jedis) {
if (null != jedis) {
jedis.close();
}
}
/**
* 獲取 StringsHandler
*
* @return StringsHandler
*/
public static StringsHandler newStringsInstance() {
return StringsHandler.getInstance();
}
/**
* 獲取 JedisHandler
*
* @return JedisHandler
*/
public static HashHandler newHashHandler() {
return HashHandler.getInstance();
}
/**
* 獲取 KeyHandler
*
* @return KeyHandler
*/
public static KeyHandler newKeyHandler() {
return KeyHandler.getInstance();
}
/**
* 獲取 ListsHandler
*
* @return ListsHandler
*/
public static ListsHandler newListsHandler() {
return ListsHandler.getInstance();
}
/**
* 獲取 ListsHandler
*
* @return ListsHandler
*/
public static SetsHandler newSetsHandler() {
return SetsHandler.getInstance();
}
}
KeyHandler
package com.wj.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.SortingParams;
import redis.clients.util.SafeEncoder;
import java.util.List;
import java.util.Set;
/**
* Key Handler
*/
class KeyHandler extends BaseJedisHandler {
private static final KeyHandler INSTANCE = new KeyHandler();
public static KeyHandler getInstance() {
return INSTANCE;
}
/**
* Delete all the keys of all the existing databases
*/
public String flushAll() {
Jedis jedis = getJedis();
try {
return jedis.flushAll();
} finally {
returnJedis(jedis);
}
}
/**
* Atomically renames the key oldKey to newKey.<p>
* <p>
* If the source and destination name are the same an error is returned.
* <p>
* If newkey already exists it is overwritten.
*
* @param oldKey old key
* @param newKey new key
* @return status
*/
public String rename(String oldKey, String newKey) {
return rename(SafeEncoder.encode(oldKey), SafeEncoder.encode(newKey));
}
/**
* Rename oldKey into newKey but fails if the destination key newKey already exists.
*
* @param oldKey old key
* @param newKey new key
* @return status
*/
public long renamenx(String oldKey, String newKey) {
Jedis jedis = getJedis();
try {
return jedis.renamenx(oldKey, newKey);
} finally {
returnJedis(jedis);
}
}
/**
* Atomically renames the key oldKey to newKey
*
* @param oldKey old key
* @param newKey new key
* @return status
*/
public String rename(byte[] oldKey, byte[] newKey) {
Jedis jedis = getJedis();
String status = jedis.rename(oldKey, newKey);
returnJedis(jedis);
return status;
}
/**
* Set a default timeout on the specified key
*
* @param key Key
* @return result
*/
public long expire(String key) {
return expire(key, EXPIRE);
}
/**
* Set a timeout on the specified key
*
* @param key Key
* @param seconds second, -1 : no expired
* @return result
*/
public long expire(String key, int seconds) {
Jedis jedis = getJedis();
try {
return jedis.expire(key, seconds);
} finally {
returnJedis(jedis);
}
}
/**
* expire at timestamp (UTC)
*
* @param key Key
* @param timestamp long
* @return result
*/
public long expireAt(String key, long timestamp) {
Jedis jedis = getJedis();
try {
return jedis.expireAt(key, timestamp);
} finally {
returnJedis(jedis);
}
}
/**
* returns the remaining time to live in seconds
*
* @param key Key
* @return time to live in seconds
*/
public long ttl(String key) {
Jedis jedis = getJedis();
try {
return jedis.ttl(key);
} finally {
returnJedis(jedis);
}
}
/**
* Undo a expire at turning the expire key into a normal key.(no expire)
*
* @param key Key
* @return result
*/
public long persist(String key) {
Jedis jedis = getJedis();
try {
return jedis.persist(key);
} finally {
returnJedis(jedis);
}
}
/**
* Remove the specified keys.
*
* @param keys keys to removed
* @return returns the number of keys removed
*/
public long del(String... keys) {
Jedis jedis = getJedis();
try {
return jedis.del(keys);
} finally {
returnJedis(jedis);
}
}
/**
* Remove the specified keys.
*
* @param keys keys to removed
* @return returns the number of keys removed
*/
public long del(byte[]... keys) {
Jedis jedis = getJedis();
try {
return jedis.del(keys);
} finally {
returnJedis(jedis);
}
}
/**
* Test if the specified key exists.
*
* @param key Key
* @return The command returns true if the key exists, otherwise false is returned.
*/
public boolean exists(String key) {
Jedis jedis = getJedis();
try {
return jedis.exists(key);
} finally {
returnJedis(jedis);
}
}
/**
* Sort the elements contained in the List, Set, or Sorted Set value at key.
*
* @param key Key
* @return the list of numbers ordered from the smallest to the biggest number.
*/
public List<String> sort(String key) {
Jedis sjedis = getJedis();
try {
return sjedis.sort(key);
} finally {
returnJedis(sjedis);
}
}
/**
* Sort a Set or a List accordingly to the specified parameters.
*
* @param key Key
* @param sortingParameters 定義排序類型或limit的起止位置.
* @return List<String> a list of sorted elements.
**/
public List<String> sort(String key, SortingParams sortingParameters) {
Jedis jedis = getJedis();
try {
return jedis.sort(key, sortingParameters);
} finally {
returnJedis(jedis);
}
}
/**
* Return the type of the value stored at key in form of a string.
* <p>
* The type can be one of "none", "string", "list", "set".
* <p>
* "none" is returned if the key does not exist.
*
* @param key Key
* @return String string|list|set|set|hash
**/
public String type(String key) {
Jedis jedis = getJedis();
try {
return jedis.type(key);
} finally {
returnJedis(jedis);
}
}
/**
* Returns all the keys matching the glob-style pattern
*
* @param pattern pattern
* @return Multi bulk reply
*/
public Set<String> keys(String pattern) {
Jedis jedis = getJedis();
try {
return jedis.keys(pattern);
} finally {
returnJedis(jedis);
}
}
}
StringsHandler
package com.wj.redis;
import redis.clients.jedis.Jedis;
import redis.clients.util.SafeEncoder;
import java.util.List;
/**
* Strings Handler
*/
public class StringsHandler extends BaseJedisHandler {
private static final StringsHandler INSTANCE = new StringsHandler();
public static StringsHandler getInstance() {
return INSTANCE;
}
/**
* Get the value of the specified key.
*
* @param key Key
* @return Value
*/
public String get(String key) {
Jedis jedis = getJedis();
try {
return jedis.get(key);
} finally {
returnJedis(jedis);
}
}
/**
* Get the value of the specified key.
*
* @param key Key
* @return Value
*/
public byte[] get(byte[] key) {
Jedis jedis = getJedis();
try {
return jedis.get(key);
} finally {
returnJedis(jedis);
}
}
/**
* The command is exactly equivalent to the following group of commands: SET + EXPIRE. The operation is atomic.
*
* @param key Key
* @param seconds 過期時間，以秒爲單位
* @param value Value
* @return Status code
*/
public String setEx(String key, int seconds, String value) {
Jedis jedis = getJedis();
try {
return jedis.setex(key, seconds, value);
} finally {
returnJedis(jedis);
}
}
/**
* The command is exactly equivalent to the following group of commands: SET + EXPIRE. The operation is atomic.
*
* @param key Key
* @param seconds 過期時間，以秒爲單位
* @param value Value
* @return Status code
*/
public String setEx(byte[] key, int seconds, byte[] value) {
Jedis jedis = getJedis();
try {
return jedis.setex(key, seconds, value);
} finally {
returnJedis(jedis);
}
}
/**
* if the key already exists no operation is performed
*
* @param key Key
* @param value Value
* @return 1 if the key was set 0 if the key was not set
*/
public long setnx(String key, String value) {
Jedis jedis = getJedis();
try {
return jedis.setnx(key, value);
} finally {
returnJedis(jedis);
}
}
/**
* Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1 GB).
*
* @param key Key
* @param value Value
* @return Status code
*/
public String set(String key, String value) {
return set(SafeEncoder.encode(key), SafeEncoder.encode(value));
}
/**
* Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1 GB).
*
* @param key Key
* @param value Value
* @return Status code
*/
public String set(String key, byte[] value) {
return set(SafeEncoder.encode(key), value);
}
/**
* Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1 GB).
*
* @param key Key
* @param value Value
* @return Status code
*/
public String set(byte[] key, byte[] value) {
Jedis jedis = getJedis();
try {
return jedis.set(key, value);
} finally {
returnJedis(jedis);
}
}
/**
* 從指定位置開始插入數據，插入的數據會覆蓋指定位置以後的數據<br/>
* <p>
* 例:String str1="123456789";<br/>
* <p>
* 對str1操作後setRange(key,4,0000)，str1="123400009";
*
* @param key Key
* @param offset offset
* @param value value
* @return long value的長度
*/
public long setRange(String key, long offset, String value) {
Jedis jedis = getJedis();
try {
return jedis.setrange(key, offset, value);
} finally {
returnJedis(jedis);
}
}
/**
* If the key already exists and is a string, this command appends the provided value at the end of the string.
* <p>
* If the key does not exist it is created and set as an empty string
*
* @param key Key
* @param value Value
* @return specifically the total length of the string after the append operation.
**/
public long append(String key, String value) {
Jedis jedis = getJedis();
try {
return jedis.append(key, value);
} finally {
returnJedis(jedis);
}
}
/**
* 將key對應的value減去指定的值，只有value可以轉爲數字時該方法纔可用
*
* @param key Key
* @param number 要減去的值
* @return the new value of key after the increment.
*/
public long decrBy(String key, long number) {
Jedis jedis = getJedis();
try {
return jedis.decrBy(key, number);
} finally {
returnJedis(jedis);
}
}
/**
* 將key對應的value加上指定的值，只有value可以轉爲數字時該方法纔可用
* <p>
* ( 可以作爲獲取唯一id的方法 )
*
* @param key Key
* @param number 要減去的值
* @return the new value of key after the increment.
*/
public long incrBy(String key, long number) {
Jedis jedis = getJedis();
try {
return jedis.incrBy(key, number);
} finally {
returnJedis(jedis);
}
}
/**
* 對指定key對應的value進行截取
*
* @param key Key
* @param startOffset 開始位置(包含)
* @param endOffset 結束位置(包含)
* @return String 截取的值
*/
public String getrange(String key, long startOffset, long endOffset) {
Jedis jedis = getJedis();
try {
return jedis.getrange(key, startOffset, endOffset);
} finally {
returnJedis(jedis);
}
}
/**
* GETSET is an atomic set this value and return the old value command.
* <p>
* Set key to the string value and return the old value stored at key.
*
* @param key Key
* @param value Value
* @return return the old value
*/
public String getSet(String key, String value) {
Jedis jedis = getJedis();
try {
return jedis.getSet(key, value);
} finally {
returnJedis(jedis);
}
}
/**
* Get the values of all the specified keys.
*
* @param keys Keys
* @return 值的集合
*/
public List<String> mget(String... keys) {
Jedis jedis = getJedis();
try {
return jedis.mget(keys);
} finally {
returnJedis(jedis);
}
}
/**
* Set the the respective keys to the respective values.
*
* @param keysvalues 例:keysvalues="key1","value1","key2","value2";
* @return Status code reply Basically +OK as MSET can't fail
*/
public String mset(String... keysvalues) {
Jedis jedis = getJedis();
try {
return jedis.mset(keysvalues);
} finally {
returnJedis(jedis);
}
}
/**
* 獲取key對應的值的長度
*
* @param key Key
* @return value值得長度
*/
public long strlen(String key) {
Jedis jedis = getJedis();
try {
return jedis.strlen(key);
} finally {
returnJedis(jedis);
}
}
}
HashHandler
package com.wj.redis;
import redis.clients.jedis.Jedis;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Hash Handler
*/
public class HashHandler extends BaseJedisHandler {
private static final HashHandler INSTANCE = new HashHandler();
public static HashHandler getInstance() {
return INSTANCE;
}
/**
* Remove the specified field from an hash stored at key.
*
* @param key Key
* @param field 存儲的名字
* @return 狀態碼，1成功，0失敗
*/
public long hdel(String key, String field) {
Jedis jedis = getJedis();
try {
return jedis.hdel(key, field);
} finally {
returnJedis(jedis);
}
}
/**
* Test for existence of a specified field in a hash.
*
* @param key Key
* @param field 存儲的名字
* @return Return true if the hash stored at key contains the specified field. Return false if the key is not found or the field is not present.
*/
public boolean hexists(String key, String field) {
Jedis jedis = getJedis();
try {
return jedis.hexists(key, field);
} finally {
returnJedis(jedis);
}
}
/**
* If key holds a hash, retrieve the value associated to the specified field.
* <p>
* If the field is not found or the key does not exist, a special 'nil' value is returned.
*
* @param key Key
* @param field Field
* @return the value associated to the specified field.
*/
public String hget(String key, String field) {
Jedis jedis = getJedis();
try {
return jedis.hget(key, field);
} finally {
returnJedis(jedis);
}
}
/**
* If key holds a hash, retrieve the value associated to the specified field.
* <p>
* If the field is not found or the key does not exist, a special 'nil' value is returned.
*
* @param key Key
* @param field Field
* @return the value associated to the specified field.
*/
public byte[] hget(byte[] key, byte[] field) {
Jedis jedis = getJedis();
try {
return jedis.hget(key, field);
} finally {
returnJedis(jedis);
}
}
/**
* Return all the fields and associated values in a hash.
*
* @param key Key
* @return Map<String, String>
*/
public Map<String, String> hgetAll(String key) {
Jedis jedis = getJedis();
try {
return jedis.hgetAll(key);
} finally {
returnJedis(jedis);
}
}
/**
* Set the specified hash field to the specified value.
* <p>
* If key does not exist, a new key holding a hash is created.
*
* @param key Key
* @param field Field
* @param value Value
* @return If the field already exists, and the HSET just produced an update of the value, 0 is returned, otherwise if a new field is created 1 is returned.
**/
public long hset(String key, String field, String value) {
Jedis jedis = getJedis();
try {
return jedis.hset(key, field, value);
} finally {
returnJedis(jedis);
}
}
/**
* Set the specified hash field to the specified value.
* <p>
* If key does not exist, a new key holding a hash is created.
*
* @param key Key
* @param field Field
* @param value Value
* @return If the field already exists, and the HSET just produced an update of the value, 0 is returned, otherwise if a new field is created 1 is returned.
*/
public long hset(String key, String field, byte[] value) {
Jedis jedis = getJedis();
try {
return jedis.hset(key.getBytes(), field.getBytes(), value);
} finally {
returnJedis(jedis);
}
}
/**
* Set the specified hash field to the specified value if the field not exists.
*
* @param key Key
* @param field Field
* @param value Value
* @return If the field already exists, 0 is returned, otherwise if a new field is created 1 is returned.
**/
public long hsetnx(String key, String field, String value) {
Jedis jedis = getJedis();
try {
return jedis.hsetnx(key, field, value);
} finally {
returnJedis(jedis);
}
}
/**
* Return all the values in a hash.
*
* @param key Key
* @return All the fields values contained into a hash.
*/
public List<String> hvals(String key) {
Jedis jedis = getJedis();
try {
return jedis.hvals(key);
} finally {
returnJedis(jedis);
}
}
/**
* Increment the number stored at field in the hash at key by value.
*
* @param key Key
* @param field Field
* @param value 要增加的值,可以是負數
* @return The new value at field after the increment operation.
*/
public long hincrby(String key, String field, long value) {
Jedis jedis = getJedis();
try {
return jedis.hincrBy(key, field, value);
} finally {
returnJedis(jedis);
}
}
/**
* Return all the fields in a hash.
*
* @param key Key
* @return All the fields names contained into a hash.
*/
public Set<String> hkeys(String key) {
Jedis jedis = getJedis();
try {
return jedis.hkeys(key);
} finally {
returnJedis(jedis);
}
}
/**
* Return the number of items in a hash.
*
* @param key Key
* @return The number of entries (fields) contained in the hash stored at key. If the specified key does not exist, 0 is returned assuming an empty hash.
*/
public long hlen(String key) {
Jedis jedis = getJedis();
try {
return jedis.hlen(key);
} finally {
returnJedis(jedis);
}
}
/**
* Retrieve the values associated to the specified fields.
*
* @param key Key
* @param fields 存儲位置
* @return Multi Bulk Reply specifically a list of all the values associated with the specified fields, in the same order of the request.
*/
public List<String> hmget(String key, String... fields) {
Jedis jedis = getJedis();
try {
return jedis.hmget(key, fields);
} finally {
returnJedis(jedis);
}
}
/**
* Retrieve the values associated to the specified fields.
*
* @param key Key
* @param fields 存儲位置
* @return Multi Bulk Reply specifically a list of all the values associated with the specified fields, in the same order of the request.
*/
public List<byte[]> hmget(byte[] key, byte[]... fields) {
Jedis jedis = getJedis();
try {
return jedis.hmget(key, fields);
} finally {
returnJedis(jedis);
}
}
/**
* Set the respective fields to the respective values. HMSET replaces old values with new values.
* <p>
* If key does not exist, a new key holding a hash is created.
*
* @param key Key
* @param map 對應關係
* @return Return OK or Exception if hash is empty
*/
public String hmset(String key, Map<String, String> map) {
Jedis jedis = getJedis();
try {
return jedis.hmset(key, map);
} finally {
returnJedis(jedis);
}
}
/**
* Set the respective fields to the respective values. HMSET replaces old values with new values.
* <p>
* If key does not exist, a new key holding a hash is created.
*
* @param key Key
* @param map 對應關係
* @return Return OK or Exception if hash is empty
*/
public String hmset(byte[] key, Map<byte[], byte[]> map) {
Jedis jedis = getJedis();
try {
return jedis.hmset(key, map);
} finally {
returnJedis(jedis);
}
}
}
ListsHandler
package com.wj.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.ListPosition;
import redis.clients.util.SafeEncoder;
import java.util.List;
/**
* Lists Handler
*/
public class ListsHandler extends BaseJedisHandler {
private static final ListsHandler INSTANCE = new ListsHandler();
public static ListsHandler getInstance() {
return INSTANCE;
}
/**
* Return the length of the list stored at the specified key.
*
* @param key Key
* @return The length of the list.
*/
public long llen(byte[] key) {
Jedis jedis = getJedis();
try {
return jedis.llen(key);
} finally {
returnJedis(jedis);
}
}
/**
* Return the length of the list stored at the specified key.
*
* @param key Key
* @return The length of the list.
*/
public long llen(String key) {
return llen(SafeEncoder.encode(key));
}
/**
* Set a new value as the element at index position of the List at key.
*
* @param key Key
* @param index 位置
* @param value 值
* @return Status code
*/
public String lset(byte[] key, int index, byte[] value) {
Jedis jedis = getJedis();
try {
return jedis.lset(key, index, value);
} finally {
returnJedis(jedis);
}
}
/**
* Set a new value as the element at index position of the List at key.
*
* @param key Key
* @param index 位置
* @param value 值
* @return Status code
*/
public String lset(String key, int index, String value) {
return lset(SafeEncoder.encode(key), index, SafeEncoder.encode(value));
}
/**
* 在指定位置插入記錄
*
* @param key Key
* @param where 前面插入或後面插入
* @param pivot 相對位置的內容
* @param value 插入的內容
* @return 記錄總數
*/
public long linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value) {
Jedis jedis = getJedis();
try {
return jedis.linsert(key, where, pivot, value);
} finally {
returnJedis(jedis);
}
}
/**
* 在value的相對位置插入記錄
*
* @param key Key
* @param where 前面插入或後面插入
* @param pivot 相對位置的內容
* @param value 插入的內容
* @return 記錄總數
*/
public long linsert(String key, ListPosition where, String pivot, String value) {
return linsert(SafeEncoder.encode(key), where, SafeEncoder.encode(pivot), SafeEncoder.encode(value));
}
/**
* 獲取List中指定位置的值
*
* @param key Key
* @param index 位置
* @return 值
**/
public byte[] lindex(byte[] key, int index) {
Jedis jedis = getJedis();
try {
return jedis.lindex(key, index);
} finally {
returnJedis(jedis);
}
}
/**
* 獲取List中指定位置的值
*
* @param key Key
* @param index 位置
* @return 值
**/
public String lindex(String key, int index) {
return SafeEncoder.encode(lindex(SafeEncoder.encode(key), index));
}
/**
* Atomically return and remove the first (LPOP) element of the list.
*
* @param key Key
* @return 移出的記錄
*/
public byte[] lpop(byte[] key) {
Jedis jedis = getJedis();
try {
return jedis.lpop(key);
} finally {
returnJedis(jedis);
}
}
/**
* Atomically return and remove the first (LPOP) element of the list.
*
* @param key Key
* @return 移出的記錄
*/
public String lpop(String key) {
return SafeEncoder.encode(lpop(SafeEncoder.encode(key)));
}
/**
* Atomically return and remove the last (RPOP) element of the list.
*
* @param key Key
* @return 移出的記錄
*/
public String rpop(String key) {
Jedis jedis = getJedis();
try {
return jedis.rpop(key);
} finally {
returnJedis(jedis);
}
}
/**
* Add the string value to the head (LPUSH) of the list stored at key.
*
* @param key Key
* @param value Value
* @return 記錄總數
*/
public long rpush(byte[] key, byte[] value) {
Jedis jedis = getJedis();
try {
return jedis.rpush(key, value);
} finally {
returnJedis(jedis);
}
}
/**
* Add the string value to the head (LPUSH) of the list stored at key.
*
* @param key Key
* @param value Value
* @return 記錄總數
*/
public long rpush(String key, String value) {
Jedis jedis = getJedis();
try {
return jedis.rpush(key, value);
} finally {
returnJedis(jedis);
}
}
/**
* Add the string value to the tail (RPUSH) of the list stored at key.
*
* @param key Key
* @param value Value
* @return 記錄總數
*/
public long lpush(byte[] key, byte[] value) {
Jedis jedis = getJedis();
try {
return jedis.lpush(key, value);
} finally {
returnJedis(jedis);
}
}
/**
* Add the string value to the tail (RPUSH) of the list stored at key.
*
* @param key Key
* @param value Value
* @return 記錄總數
*/
public long lpush(String key, String value) {
return lpush(SafeEncoder.encode(key), SafeEncoder.encode(value));
}
/**
* Return the specified elements of the list stored at the specified key.
*
* @param key key
* @param start start
* @param end end
* @return List
*/
public List<String> lrange(String key, long start, long end) {
Jedis jedis = getJedis();
try {
return jedis.lrange(key, start, end);
} finally {
returnJedis(jedis);
}
}
/**
* Return the specified elements of the list stored at the specified key.
*
* @param key key
* @param start start
* @param end end
* @return List
*/
public List<byte[]> lrange(byte[] key, int start, int end) {
Jedis jedis = getJedis();
try {
return jedis.lrange(key, start, end);
} finally {
returnJedis(jedis);
}
}
/**
* Remove the first count occurrences of the value element from the list.
*
* @param key Key
* @param count 要刪除的數量，如果爲負數則從List的尾部檢查並刪除符合的記錄
* @param value 要匹配的值
* @return 刪除後的List中的記錄數
*/
public long lrem(byte[] key, int count, byte[] value) {
Jedis jedis = getJedis();
try {
return jedis.lrem(key, count, value);
} finally {
returnJedis(jedis);
}
}
/**
* Remove the first count occurrences of the value element from the list.
*
* @param key Key
* @param count 要刪除的數量，如果爲負數則從List的尾部檢查並刪除符合的記錄
* @param value 要匹配的值
* @return 刪除後的List中的記錄數
*/
public long lrem(String key, int count, String value) {
return lrem(SafeEncoder.encode(key), count, SafeEncoder.encode(value));
}
/**
* Trim an existing list so that it will contain only the specified range of elements specified.
*
* @param key Key
* @param start 記錄的開始位置(0表示第一條記錄)
* @param end 記錄的結束位置（如果爲-1則表示最後一個，-2，-3以此類推）
* @return Status code
*/
public String ltrim(byte[] key, int start, int end) {
Jedis jedis = getJedis();
try {
return jedis.ltrim(key, start, end);
} finally {
returnJedis(jedis);
}
}
/**
* Trim an existing list so that it will contain only the specified range of elements specified.
*
* @param key Key
* @param start 記錄的開始位置(0表示第一條記錄)
* @param end 記錄的結束位置（如果爲-1則表示最後一個，-2，-3以此類推）
* @return Status code
*/
public String ltrim(String key, int start, int end) {
return ltrim(SafeEncoder.encode(key), start, end);
}
}
SetsHandler
package com.wj.redis;
import redis.clients.jedis.Jedis;
import java.util.Set;
/**
* Set Handler
*/
public class SetsHandler extends BaseJedisHandler {
private static final SetsHandler INSTANCE = new SetsHandler();
public static SetsHandler getInstance() {
return INSTANCE;
}
/**
* Add the specified member to the set value stored at key
*
* @param key Key
* @param member Member
* @return status, 0 or 1
*/
public long sadd(String key, String... member) {
Jedis jedis = getJedis();
try {
return jedis.sadd(key, member);
} finally {
returnJedis(jedis);
}
}
/**
* Add the specified member to the set value stored at key
*
* @param key Key
* @param member Member
* @return status, 0 or 1
*/
public long sadd(byte[] key, byte[] member) {
Jedis jedis = getJedis();
try {
return jedis.sadd(key, member);
} finally {
returnJedis(jedis);
}
}
/**
* Return the set cardinality (number of elements)
*
* @param key Key
* @return the cardinality (number of elements) of the set as an integer.
*/
public long scard(String key) {
Jedis jedis = getJedis();
try {
return jedis.scard(key);
} finally {
returnJedis(jedis);
}
}
/**
* Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN
*
* @param keys keys
* @return the members of a set resulting from the difference between the first set provided and all the successive sets.
*/
public Set<String> sdiff(String... keys) {
Jedis jedis = getJedis();
try {
return jedis.sdiff(keys);
} finally {
returnJedis(jedis);
}
}
/**
* This command works exactly like SDIFF but instead of being returned the resulting set is stored in dstKey.
*
* @param dstKey 新結果集的key
* @param keys 比較的集合
* @return 新集合中的記錄數
**/
public long sdiffstore(String dstKey, String... keys) {
Jedis jedis = getJedis();
try {
return jedis.sdiffstore(dstKey, keys);
} finally {
returnJedis(jedis);
}
}
/**
* Return the members of a set resulting from the intersection of all the sets hold at the specified keys.
*
* @param keys Keys
* @return Multi bulk reply, specifically the list of common elements.
**/
public Set<String> sinter(String... keys) {
Jedis jedis = getJedis();
try {
return jedis.sinter(keys);
} finally {
returnJedis(jedis);
}
}
/**
* This command works exactly like SINTER but instead of being returned the resulting set is stored as dstkey.
*
* @param dstkey 新結果集的key
* @param keys 比較的集合
* @return 新集合中的記錄數
**/
public long sinterstore(String dstkey, String... keys) {
Jedis jedis = getJedis();
try {
return jedis.sinterstore(dstkey, keys);
} finally {
returnJedis(jedis);
}
}
/**
* Return true if member is a member of the set stored at key, otherwise false is returned.
*
* @param key Key
* @param member member
* @return Return true if member is a member of the set stored at key, otherwise false is returned.
**/
public boolean sismember(String key, String member) {
Jedis jedis = getJedis();
try {
return jedis.sismember(key, member);
} finally {
returnJedis(jedis);
}
}
/**
* Return all the members (elements) of the set value stored at key. This is just syntax glue for SINTER.
*
* @param key Key
* @return Multi bulk reply
*/
public Set<String> smembers(String key) {
Jedis jedis = getJedis();
try {
return jedis.smembers(key);
} finally {
returnJedis(jedis);
}
}
/**
* Return all the members (elements) of the set value stored at key. This is just syntax glue for SINTER.
*
* @param key Key
* @return Multi bulk reply
*/
public Set<byte[]> smembers(byte[] key) {
Jedis jedis = getJedis();
try {
return jedis.smembers(key);
} finally {
returnJedis(jedis);
}
}
/**
* Move the specified member from the set at srcKey to the set at dstKey.
*
* @param srcKey srcKey
* @param dstKey dstKey
* @param member member
* @return 1 if the element was moved 0 if the element was not found on the first set and no operation was performed
*/
public long smove(String srcKey, String dstKey, String member) {
Jedis jedis = getJedis();
try {
return jedis.smove(srcKey, dstKey, member);
} finally {
returnJedis(jedis);
}
}
/**
* Remove a random element from a Set returning it as return value.
*
* @param key Key
* @return If the Set is empty or the key does not exist, a nil object is returned.
*/
public String spop(String key) {
Jedis jedis = getJedis();
try {
return jedis.spop(key);
} finally {
returnJedis(jedis);
}
}
/**
* Remove the specified member from the set value stored at key.
* <p>
* If member was not a member of the set no operation is performed.
* <p>
* If key does not hold a set value an error is returned.
*
* @param key key
* @param member member
* @return 1 if the new element was removed 0 if the new element was not a member of the set
*/
public long srem(String key, String member) {
Jedis jedis = getJedis();
try {
return jedis.srem(key, member);
} finally {
returnJedis(jedis);
}
}
/**
* Return the members of a set resulting from the union of all the sets hold at the specified keys.
*
* @param keys keys
* @return Multi bulk reply, specifically the list of common elements.
*/
public Set<String> sunion(String... keys) {
Jedis jedis = getJedis();
try {
return jedis.sunion(keys);
} finally {
returnJedis(jedis);
}
}
/**
* This command works exactly like SUNION but instead of being returned the resulting set is stored as dstKey.
* <p>
* Any existing value in dstKey will be over-written.
*
* @param dstKey dstKey
* @param keys keys
* @return status code
*/
public long sunionstore(String dstKey, String... keys) {
Jedis jedis = getJedis();
long s = jedis.sunionstore(dstKey, keys);
returnJedis(jedis);
return s;
}
}
SortSetHandler
package com.wj.redis;
import redis.clients.jedis.Jedis;
import java.util.Map;
import java.util.Set;
/**
* SortSet Handler
*/
public class SortSetHandler extends BaseJedisHandler {
/**
* Add the specified member having the specified score to the sorted set stored at key.
*
* @param key Key
* @param score 權重
* @param member member
* @return 1 if the new element was added 0 if the element was already a member of the sorted set and the score was updated
*/
public long zadd(String key, double score, String member) {
Jedis jedis = getJedis();
try {
return jedis.zadd(key, score, member);
} finally {
returnJedis(jedis);
}
}
/**
* Add the specified member having the specified score to the sorted set stored at key.
*
* @param key Key
* @param scoreMembers member-權重
* @return 1 if the new element was added 0 if the element was already a member of the sorted set and the score was updated
*/
public long zadd(String key, Map<String, Double> scoreMembers) {
Jedis jedis = getJedis();
try {
return jedis.zadd(key, scoreMembers);
} finally {
returnJedis(jedis);
}
}
/**
* Return the sorted set cardinality (number of elements).
*
* @param key key
* @return the cardinality (number of elements) of the set as an integer.
*/
public long zcard(String key) {
Jedis jedis = getJedis();
try {
return jedis.zcard(key);
} finally {
returnJedis(jedis);
}
}
/**
* 獲取指定權重區間內集合的數量
*
* @param key key
* @param min 最小排序位置
* @param max 最大排序位置
*/
public long zcount(String key, double min, double max) {
Jedis jedis = getJedis();
try {
return jedis.zcount(key, min, max);
} finally {
returnJedis(jedis);
}
}
/**
* 返回指定位置的集合元素,0爲第一個元素，-1爲最後一個元素
*
* @param key Key
* @param start 開始位置(包含)
* @param end 結束位置(包含)
* @return Set<String>
*/
public Set<String> zrange(String key, int start, int end) {
Jedis jedis = getJedis();
try {
return jedis.zrange(key, start, end);
} finally {
returnJedis(jedis);
}
}
/**
* If member already exists in the sorted set adds the increment to its score and updates the position of the element in the sorted set accordingly.
*
* @param key Key
* @param score 要增的權重
* @param member 要插入的值
* @return The new score
*/
public double zincrby(String key, double score, String member) {
Jedis jedis = getJedis();
try {
return jedis.zincrby(key, score, member);
} finally {
returnJedis(jedis);
}
}
/**
* Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
*
* @param key Key
* @param min 上限權重
* @param max 下限權重
* @return Set<String>
*/
public Set<String> zrangeByScore(String key, double min, double max) {
Jedis jedis = getJedis();
try {
return jedis.zrangeByScore(key, min, max);
} finally {
returnJedis(jedis);
}
}
/**
* Return the rank (or index) of member in the sorted set at key, with scores being ordered from low to high.
*
* @param key Key
* @param member member
* @return long 位置
*/
public long zrank(String key, String member) {
Jedis jedis = getJedis();
try {
return jedis.zrank(key, member);
} finally {
returnJedis(jedis);
}
}
/**
* Return the rank (or index) of member in the sorted set at key, with scores being ordered from high to low.
*
* @param key key
* @param member member
* @return long 位置
*/
public long zrevrank(String key, String member) {
Jedis jedis = getJedis();
try {
return jedis.zrevrank(key, member);
} finally {
returnJedis(jedis);
}
}
/**
* Remove the specified member from the sorted set value stored at key.
*
* @param key key
* @param member member
* @return 1 if the new element was removed 0 if the new element was not a member of the set
*/
public long zrem(String key, String member) {
Jedis jedis = getJedis();
try {
return jedis.zrem(key, member);
} finally {
returnJedis(jedis);
}
}
/**
* delete key
*
* @param key key
* @return status
*/
public long zrem(String key) {
Jedis jedis = getJedis();
try {
return jedis.del(key);
} finally {
returnJedis(jedis);
}
}
/**
* Remove all elements in the sorted set at key with rank between start and end.
*
* @param key Key
* @param start 開始區間，從0開始(包含)
* @param end 結束區間,-1爲最後一個元素(包含)
* @return specifically the number of elements removed.
*/
public long zremrangeByRank(String key, int start, int end) {
Jedis jedis = getJedis();
try {
return jedis.zremrangeByRank(key, start, end);
} finally {
returnJedis(jedis);
}
}
/**
* Remove all the elements in the sorted set at key with a score between min and max
* <p>
* (including elements with score equal to min or max).
*
* @param key Key
* @param min 下限權重(包含)
* @param max 上限權重(包含)
* @return specifically the number of elements removed.
*/
public long zremrangeByScore(String key, double min, double max) {
Jedis jedis = getJedis();
try {
return jedis.zremrangeByScore(key, min, max);
} finally {
returnJedis(jedis);
}
}
/**
* 獲取給定區間的元素，原始按照權重由高到低排序
*
* @param key Key
* @param start 開始區間，從0開始(包含)
* @param end 結束區間,-1爲最後一個元素(包含)
* @return Set<String>
*/
public Set<String> zrevrange(String key, int start, int end) {
Jedis jedis = getJedis();
try {
return jedis.zrevrange(key, start, end);
} finally {
returnJedis(jedis);
}
}
/**
* Return the score of the specified element of the sorted set at key.
* <p>
* If the specified element does not exist in the sorted set, or the key does not exist at all, a special 'nil' value is returned.
*
* @param key Key
* @param member member
* @return double 權重
*/
public double zscore(String key, String member) {
Jedis jedis = getJedis();
try {
return jedis.zscore(key, member);
} finally {
returnJedis(jedis);
}
}
}
用法實例
package com.wj.test;
import com.wj.redis.HashHandler;
import com.wj.redis.BaseJedisHandler;
import com.wj.redis.StringsHandler;
import org.junit.Test;
/**
* Jedis Util demo
*/
public class JedisUtilTest {
@Test
public void test() {
StringsHandler stringsHandler = BaseJedisHandler.newStringsInstance();
stringsHandler.set("nnn", "nnnn");
System.out.println("-----" + stringsHandler.get("nnn"));
HashHandler hashHandler = BaseJedisHandler.newHashHandler();
hashHandler.hset("hashKey", "field_hash", "field_value");
System.out.println(hashHandler.hget("hashKey", "field_hash"));
}
}