java 使用redis的工具类

import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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 RedisUtil {

private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);
private Jedis jedis;//非切片额客户端连接
private JedisPool jedisPool;//非切片连接池
private ShardedJedis shardedJedis;//切片额客户端连接
private ShardedJedisPool shardedJedisPool;//切片连接池
private static String PASSWORD = null;
private String ip ="127.0.0.1";
private int port = 6397;

public RedisUtil()
{

initialPool();
initialShardedPool();
shardedJedis = shardedJedisPool.getResource();
jedis = jedisPool.getResource();

}

/**
* 初始化非切片池
*/
private void initialPool()
{
// 池基本配置
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(20);
config.setMaxIdle(5);
config.setMaxWait(1000l);
config.setTestOnBorrow(false);

//jedisPool = new JedisPool(config,"123.207.229.148",6379);
config.setTestWhileIdle(true);
config.setMinEvictableIdleTimeMillis(60000L);
config.setNumTestsPerEvictionRun(1);
config.setTimeBetweenEvictionRunsMillis(30000L);

if(PASSWORD!=null){
jedisPool = new JedisPool(config,ip,port,10000,PASSWORD);
}else{
jedisPool = new JedisPool(config,ip,port);
}
}

private static RedisUtil Singleton = new RedisUtil();

public  static RedisUtil getSingleton() {
return Singleton;
}

private  Jedis getJedis() {
if (jedisPool == null)
initialPool();
return jedisPool.getResource();
}

private  void returnJedis(Jedis jedis) {
if (jedis != null)
jedisPool.returnResource(jedis);
}

/**
* 获取数据
*
* @param key
* @return
*/
public  void setString(String key,String value){
Jedis jedis = null;
try {
jedis = getJedis();
value = jedis.set(key,value);
} catch (Exception e) {
//释放redis对象
logger.info(""+e);
returnJedis(jedis);
} finally {
//返还到连接池
returnResource(jedisPool, jedis);
}

}

/**
* 获取数据
*
* @param key
* @return
*/
public  void setObject(byte[] key,byte[] value){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.set(key,value);
} catch (Exception e) {
//释放redis对象
logger.info(""+e);
returnJedis(jedis);
} finally {
//返还到连接池
returnResource(jedisPool, jedis);
}

}

/**
* 获取数据
*
* @param key
* @return
*/
public  String getString(String key){
String value = null;

Jedis jedis = null;
try {
jedis = getJedis();
value = jedis.get(key);
} catch (Exception e) {
//释放redis对象
logger.info(""+e);
returnJedis(jedis);
} finally {
//返还到连接池
returnResource(jedisPool, jedis);
}

return value;
}

/**
* 获取数据
*
* @param key
* @return
*/
public  Object getObject(byte[] key){
byte[] value = null;

Jedis jedis = null;
try {
jedis = getJedis();
value = jedis.get(key);
return SerializeUtil.unSerialize(value);
} catch (Exception e) {
//释放redis对象
logger.info(""+e);
returnJedis(jedis);
} finally {
//返还到连接池
returnResource(jedisPool, jedis);
}

return value;
}

/**
* 初始化切片池
*/
private void initialShardedPool()
{
// 池基本配置
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(20);
config.setMaxIdle(5);
config.setMaxWait(1000l);
config.setTestOnBorrow(false);
// slave链接
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();

logger.info("ip="+ip+"----"+"port="+port);
shards.add(new JedisShardInfo(ip,port, "master"));

// 构造池

shardedJedisPool = new ShardedJedisPool(config, shards);

}

/**
* 返还到连接池
*
* @param pool
* @param redis
*/
public  void returnResource(JedisPool pool, Jedis redis) {
if (redis != null) {
pool.returnResourceObject(redis);
}
}

public void show() {

jedisPool.returnResource(jedis);
shardedJedisPool.returnResource(shardedJedis);

}

}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SerializeUtil {
private static final Logger logger = LoggerFactory.getLogger(SerializeUtil.class);
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
//序列化
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {
logger.info("",e);
}
return null;
}

public static Object unSerialize(byte[] bytes) {
ByteArrayInputStream bais = null;
try {
//反序列化
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
logger.info("",e);
}
return null;
}
}