简单的redis工具类

import java.util.Arrays;

import java.util.List;
import java.util.Set;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class RedisUtils {
// Redis服务器IP
private static String ADDR = "localhost";

// Redis的端口号
private static int PORT = 6379;

// 访问密码,若你的redis服务器没有设置密码，就不需要用密码去连接
// private static String AUTH = "123456";

// 可用连接实例的最大数目，默认值为8；
private static int MAX_TOTAL = 512;

// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 50;

// 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。
private static int MAX_WAIT = -1;

private static int TIMEOUT = 100000;

// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
private static boolean TEST_ON_BORROW = true;

private static JedisPool jedisPool = null;

private static List<JedisShardInfo> shards = null;

private static ShardedJedisPool shardedJedisPool = null;

private static Object lock = new Object();

public static void setADDR(String aDDR, int port) {
ADDR = aDDR;
PORT = port;
}

private static Logger log = Logger.getLogger(RedisUtils.class);

/**
* 初始化Redis连接池
*/
private static void initJedisPool() {
synchronized (lock) {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_TOTAL);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);
} catch (Exception e) {
log.error("initJedisPool出错:" + e);
}
}
}

private static void initShardedJedisPool() {
synchronized (lock) {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_TOTAL);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
JedisShardInfo info = new JedisShardInfo(ADDR, PORT);
info.setTimeout(TIMEOUT);
shards = Arrays.asList(info);
shardedJedisPool = new ShardedJedisPool(config, shards);
} catch (Exception e) {
log.error("initShardedJedisPool出错:" + e);
}
}
}

/**
* 获取shardedJedis实例
* @return
*/
public static ShardedJedis getShardedJedis() {
try {
if (shardedJedisPool == null) {
initShardedJedisPool();
}
ShardedJedis jedis = shardedJedisPool.getResource();
return jedis;
} catch (Exception e) {
log.error("getShardedJedis出错:" + e);
return null;
}
}

/**
* 释放shardedJedis资源
* @param jedis
*/
public static void returnShardedResource(final ShardedJedis jedis) {
if (jedis != null) {
shardedJedisPool.returnResource(jedis);
}
}

/**
* 获取Jedis实例
* @return
*/
public static Jedis getJedis() {
try {
if (jedisPool == null) {
initJedisPool();
}
Jedis jedis = jedisPool.getResource();
return jedis;
} catch (Exception e) {
log.error("getJedis出错:" + e);
return null;
}
}

/**
* 释放jedis资源
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
}
}

/**
* 根据key值来获取对应的数据
* @param key
* @return
*/
public static String getString(final String key) {
String result = "";
try (Jedis jedis = getJedis()) {
if (StringUtils.isEmpty(key)) {
return result;
}
result = jedis.get(key);
} catch (Exception e) {
log.error("get String fail", e);
}
return result;
}

/**
* 设置缓存
* @param key
* @param values
*/
public static void setString(final String key, final String values) {
try (Jedis jedis = getJedis()) {
if (StringUtils.isEmpty(key)) {
return;
}
jedis.set(key, values);
} catch (Exception e) {
log.error("set String fail", e);
}

}

/**
* 根据key值来删除缓存
* @param key
* @return
*/
public static long delKey(final String key) {
long result = 0;
try (Jedis jedis = getJedis()) {
if (StringUtils.isEmpty(key)) {
return result;
}
result = jedis.del(key);
} catch (Exception e) {
log.error("del key fail", e);
}
return result;
}

/**
* 生成key genKey
* @param projectId
* @param module
* @param unit
* @return String
*/
public static String genKey(String projectId, String module, String unit) {
StringBuilder builder = new StringBuilder();
builder.append(unit);
builder.append("_");
builder.append(module);
builder.append(projectId);
return builder.toString();
}

/**
* 设置键值 setString
* @param key
* @param values
* @param seconds
*/
public static void setString(final String key, final String values, final int seconds) {
try (Jedis jedis = getJedis()) {
if (StringUtils.isEmpty(key)) {
return;
}
jedis.setex(key, seconds, values);
} catch (Exception e) {
log.error("set String and expire fail ", e);
}
}

public synchronized static void deleteKey(String... keys) {
try (Jedis jedis = getJedis()) {

jedis.del(keys);
} catch (Exception e) {
log.error("delete key[] fail ", e);
}
}

public synchronized static void deleteKeys(String pattern) {
try (Jedis jedis = getJedis()) {
Set<String> keySet = jedis.keys(pattern);
if (keySet == null || keySet.size() <= 0) {
return;
}
String keyArr[] = new String[keySet.size()];
int i = 0;
for (String keys : keySet) {
keyArr[i] = keys;
i++;
}
deleteKey(keyArr);
} catch (Exception e) {
log.error("delete keys by pattern fail ", e);
}

}

public synchronized static void deleteKeyByPrefix(String prefix) {
deleteKeys(prefix + "*");
}

public synchronized static void deleteKeyByContain(String contain) {
deleteKeys("*" + contain + "*");
}

}