Redis 实践

redis 连接命令 ：redis-cli -h 10.1.15.23 -p 6379 -c
keys*
flushdb
10.1.15.21:6379,10.1.15.22:6379,10.1.15.23:6379
redis-cli -h 10.1.15.21 -p 6379 -c

HDEL

HGETALL

hset "key" "user_key" "{\"itemid\":0}"

HGET limit_Key [e-mail]_1458543261CN

 HGETALL  limit_Key

public interface CacheDataDao

{
/**
* 获取缓存数据
* @param primKey 缓存key
* @param dataKey 数据key
* @param entityClass 返回类型
* @return
*/
public <T> T getDataByKey(String primKey, String dataKey,Class<T> entityClass);
/**
* 获取List缓存数据
* @param primKey
* @param dataKey
* @param entityClass
* @return
*/
public <T> List<T> getListDataByKey(String primKey, String dataKey,Class<T> entityClass);
/**
* 批量获取缓存数据
* @param primKey 缓存key
* @param entityClass 返回类型
* @return
*/
public <T> List<T> batchGetData(String primKey,Class<T> entityClass);
/**
* 保存数据到缓存
* @param primKey 缓存key
* @param dataKey 数据key
* @param cacheData 数据
*/
public <T> void setDataByKey(String primKey, String dataKey, T cacheData);
/**
* 批量保存数据到缓存
* @param primKey
* @param cacheData
*/
public <K,T> void batchSetData(String primKey,Map<K,T> cacheData);
/**
* 删除缓存数据
* @param primKey 缓存key
* @param dataKey 数据key
*/
public void deleteDataByKey(String primKey, String ...dataKey);


public Map<String, String> getDataMap(String primaryKey);

public String getStringValueByKey(String primKey, String dataKey);

public Set<String> getMapKeysByPrimKey(String primKey);

public void deleteKey(String primKey);
/**
* 增加集合类缓存元素
* 
* @param primKey
* @param value
* @param score   排序用的分数
*/
public void zAddValueByKey(String primKey, String value, double score);
/**
* 增加集合类缓存元素
* 
* @param primKey
* @param valueMap
*/
public void zAddValueByMap(String primKey, Map<String, Double> valueMap);

/**
* 删除集合类缓存元素
* 
* @param primKey
* @param key
*/
public void zRemoveValueByKey(String primKey, String keys);
/**
* 删除集合类缓存元素
* 
* @param primKey
* @param keys
*/
public void zRemoveValueByKeys(String primKey, String[] keys);
/**
* 获取集合长度
* 
* @param primKey
* @return 集合长度
*/
public long zCard(String primKey);
/**
* 按score倒序排列获取集合元素列表
* 
* @param key 集合名称
* @param max 最大值
* @param min 最小值
* @return 集合元素列表
*/
public Set<String> zRevRangeByScore(String key, double max, double min);

}

public class RedisBaseDao implements CacheDataDao
{


@Override
public <T> T getDataByKey(String primKey, String dataKey,Class<T> entityClass)
{
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
T result = null;
try
{

String data = jedis.hget(primKey, dataKey);
//result = JSON.parseObject(data,entityClass);
result = SerializeUtil.jsonUnSerialize(data,entityClass);


} catch (Exception e)
{
logger.error(e.toString());

} finally
{
if (jedis != null)
{
//RedisConnectionUitl.releaseJedis(jedis);
}
}
return result;
}

@Override
public <T> List<T> getListDataByKey(String primKey, String dataKey,Class<T> entityClass)
{
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
List<Object> dataList = null;
List<T> result = new ArrayList<T>();
String temp = null ;
try
{
String data = jedis.hget(primKey, dataKey);
//result = JSON.parseObject(data,entityClass);
dataList = SerializeUtil.jsonUnSerialize(data,List.class);

if(dataList == null)
{
logger.error("the cache data isn't list!primKey:{};dataKey:{}",primKey,dataKey);
return null;
}

for (Object obj : dataList)
{
temp = obj.toString();
temp = temp.replace("=", "\":\"");
temp = temp.replace("{", "{\"");
temp = temp.replace("}", "\"}");
temp = temp.replace(",", "\",\"").replace(" ", "").replace("\"{", "{")
.replace("}\"", "}").replace("\"[", "[").replace("]\"", "]")
.replace("\"null\"", "null");
result.add(SerializeUtil.jsonUnSerialize(temp.trim(), entityClass));
}
} catch (Exception e)
{
logger.error(e.toString());

} finally
{
if (jedis != null)
{
//RedisConnectionUitl.releaseJedis(jedis);
}
}
return result;
}

@Override
public <T> List<T> batchGetData(String primKey,Class<T> entityClass)
{
// TODO Auto-generated method stub
List<T> result = new ArrayList<T>();

JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
try
{
Map<String, String> cachMap = jedis.hgetAll(primKey);


for (Entry<String, String> temp : cachMap.entrySet())
{
//result.add(JSON.parseObject(temp.getValue(), entityClass));
result.add(SerializeUtil.jsonUnSerialize(temp.getValue(), entityClass));
}


} catch (Exception e)
{
logger.error(e.toString());


} finally
{
/*if (jedis != null)
{
RedisConnectionUitl.releaseJedis(jedis);
}*/
}
return result;
}


@Override
public <T> void setDataByKey(String primKey, String dataKey, T cacheData)
{
// TODO Auto-generated method stub

JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
try
{
// jedis.hset(primKey.getBytes(), dataKey.getBytes(),
// SerializeUtil.serialize(cacheData));


//String dataJson = JSON.toJSONString(cacheData);
String dataJson = SerializeUtil.jsonSerialize(cacheData);
jedis.hset(primKey, dataKey, dataJson);


} catch (Exception e)
{
logger.error(e.toString(), e);


} finally
{
if (jedis != null)
{
//RedisConnectionUitl.releaseJedis(jedis);
}
}


}

@Override
public <K,T> void batchSetData(String primKey, Map<K, T> cacheData){
// TODO Auto-generated method stub
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();


Map<String, String> cacheMap = new HashMap<String, String>();
try
{
for (Entry<K, T> temp : cacheData.entrySet())
{
if (temp.getValue() != null)
{
cacheMap.put(temp.getKey().toString(),
SerializeUtil.jsonSerialize(temp.getValue()));
}
}
jedis.hmset(primKey, cacheMap);


} catch (Exception e)
{
logger.error(e.toString());


} finally
{
/*if (jedis != null)
{
RedisConnectionUitl.releaseJedis(jedis);
}*/
}
}

@Override
public void deleteDataByKey(String primKey,  String ...dataKey){
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
try
{
if(dataKey == null || dataKey.length == 0){
jedis.hdel(primKey);
}else{
jedis.hdel(primKey, dataKey);
}

} catch (Exception e)
{
logger.error(e.toString());


} finally
{
/*if (jedis != null)
{
RedisConnectionUitl.releaseJedis(jedis);
}*/
}
}

public Map<String, String> getDataMap(String primaryKey){

JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
Map<String, String> datamap = new HashMap<String, String>();
try
{

datamap = jedis.hgetAll(primaryKey);
} catch (Exception e)
{
logger.error(e.toString());
} finally
{
/*if (jedis != null)
{
RedisConnectionUitl.releaseJedis(jedis);
}*/
}

return datamap;
}


public  String serialize(Object object)
{
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try
{

baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
String bytes = baos.toString();
return bytes;
} catch (Exception e)
{
logger.error(e.toString());
}
return null;
}

public static <T> T unserialize(byte[] bytes,Class<T> entityClass)
{
ByteArrayInputStream bais = null;
try
{
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return  (T) ois.readObject();
} catch (Exception e)
{
logger.error(e.toString());
}
return null;
}


@Override
public String getStringValueByKey(String primKey, String dataKey) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
return jedis.hget(primKey, dataKey);
}


@Override
public Set<String> getMapKeysByPrimKey(String primKey) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
return jedis.hkeys(primKey);
}


@Override
public void deleteKey(String primKey) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
jedis.del(primKey);
}


@Override
public void zAddValueByKey(String primKey, String value, double score) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
jedis.zadd(primKey, score, value);
}


@Override
public void zRemoveValueByKey(String primKey, String key) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
jedis.zrem(primKey, key);
}

@Override
public void zRemoveValueByKeys(String primKey, String[] keys) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
jedis.zrem(primKey, keys);
}


@Override
public long zCard(String primKey) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
return jedis.zcard(primKey);
}


@Override
public Set<String> zRevRangeByScore(String key, double max, double min) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
return jedis.zrevrangeByScore(key, max, min);
}


@Override
public void zAddValueByMap(String primKey, Map<String, Double> valueMap) {
JedisCluster jedis = RedisConnectionUitl.getJedisCluster();
jedis.zadd(primKey, valueMap);
}

}

public class RedisConnectionUitl
{
public static void main(String[] args) {
JedisCluster cluster = RedisConnectionUitl.getJedisCluster();
System.out.println(cluster);



}

//连接池
private static ShardedJedisPool shardedJedisPool;

private static JedisCluster jedisCluster;


static
{
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(20);
config.setMaxIdle(5);
config.setMaxWaitMillis(1000l);
config.setTestOnBorrow(false);


List<String[]> connections = getConnectString();


List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();

for(String[] connect:connections)
{

 shards.add(new JedisShardInfo(connect[0], Integer.valueOf(connect[1])));
 
 jedisClusterNodes.add(new HostAndPort(connect[0], Integer.valueOf(connect[1])));

}

//shards.add(new JedisShardInfo(connect, 6379));


// 构造池

//Jedis Cluster will attempt to discover cluster nodes automatically

jedisCluster = new JedisCluster(jedisClusterNodes);
shardedJedisPool = new ShardedJedisPool(config, shards);
}

/**
* 获取jedis 链接
* @return
*/
public static ShardedJedis getJedis()
{
return shardedJedisPool.getResource();
}

public static JedisCluster getJedisCluster()
{
return jedisCluster;
}

/**
* 释放jedis链接
* @param jedis
*/
public static void releaseJedis(ShardedJedis jedis)
{
shardedJedisPool.returnResourceObject(jedis);
}

public static List<String[]> getConnectString()
{
Resource resource = new ClassPathResource("META-INF/conf/redis.properties");

List<String> connectStr = new ArrayList<String>();

List<String[]> result = new ArrayList<String[]>();

String [] connectAddr = null ;

try
{
Properties props = PropertiesLoaderUtils.loadProperties(resource);

String connections = props.getProperty("redis.connect");

connectStr = Arrays.asList(connections.split(","));

for (String tmp : connectStr)
{
connectAddr = tmp.split(":");

if(connectAddr.length == 2)
{
result.add(connectAddr);
}
}


} catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}

return result;
}




}