Redis常用操作工具类---包含单例和集群模式
- 接口：
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @Author: lcx
* @Date: Created at 2018/8/18 13:40.
* @Description:
*/
public interface JedisCommonDao {
/**
* 序列化方式从redis中获取对象
*
* @param key
* @return
*/
T getObject(String key, Class clazz);
/**
* 序列化方式向redis中存入对象(1小时过期)
*
* @param key
* @param obj
* @return
*/
String putObject(String key, Object obj);
/**
* 序列化方式向redis中存入对象并设置过期时间(秒)
*
* @param key
* @param obj
* @return
*/
String putObject(String key, Object obj, int expire) ;
/**
* 指定的键值
*
* @param key
* @return
*/
public Long del(String key);
/**
* JSON形式从redis中获取对象数组
*
* @param key
* @return
*/
List getList(String key, Class clazz);
/**
* JSON形式向redis中存入对象
*
* @param key
* @param obj
* @return
*/
String put(String key, Object obj) ;
/**
* 从Redis中取值
*
* @param key
* @return
*/
String getValue(String key) ;
/**
* 往redis里存入值，如果成功则返回1，失败返回0
* @param key
* @return
*/
Long setNxValue(String key);
/**
* 往redis Set 键里面添加成员
* @param key 键
* @param expire 时间 单位s
* @param members
* @return
*/
Long addSetValue(String key, int expire, String... members);
/**
* redis Set 键里面删除成员
* @param key
* @return
*/
Long moveSetValue(String key, String... members) ;
/**
* 获取redis Set 键里面所有成员
* @param key
* @return
*/
Set getSetValues(String key);
/**
* 存入map
* @param key
* @param map
* @return
*/
String putMapValues(String key, Map map);
/**
* 根据key 获取map中数据
* @param key
* @param filed
* @param clazz
* @param
* @return
*/
T getMapObject(String key, String filed, Class clazz);
/**
* 根据key获取map
* @param key
* @return
*/
Map getAllMap(String key);
/**
* 往redis map中存值，如果已经存在就跳过
* @param key
* @param filed
* @param obj
* @return
*/
Long putMapObject(String key, String filed, Object obj);
void setMap(String key, Map map);
Map getMap(String key);
Long putMapString(String key, String filed, String s, int expire);
Long incr(String key);
String setString(String key, String value);
}
- 工具类
package com.redis;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import java.io.*;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 序列化工具类
*
* Created by lcx on 2018/04/19.
*/
public class ProtostuffUtil {
private static Map, Schema> cachedSchema = new ConcurrentHashMap, Schema>();
private static Schema getSchema(Class clazz) {
Schema schema = (Schema) cachedSchema.get(clazz);
if (schema == null) {
schema = RuntimeSchema.getSchema(clazz);
if (schema != null) {
cachedSchema.put(clazz, schema);
}
}
return schema;
}
/**
* 序列化
*
* @param obj
* @return
*/
public static byte[] serializer(T obj) {
@SuppressWarnings("unchecked")
Class clazz = (Class) obj.getClass();
LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
try {
Schema schema = getSchema(clazz);
return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
} catch (Exception e) {
throw new IllegalStateException(e.getMessage(), e);
} finally {
buffer.clear();
}
}
/**
* 反序列化
*
* @param data
* @param clazz
* @return
*/
public static T deserializer(byte[] data, Class clazz) {
try {
T obj = clazz.newInstance();
Schema schema = getSchema(clazz);
ProtostuffIOUtil.mergeFrom(data, obj, schema);
return obj;
} catch (Exception e) {
throw new IllegalStateException(e.getMessage(), e);
}
}
public static byte[] serialize(Object value) {
if (value == null) {
throw new NullPointerException("Can't serialize null");
}
byte[] rv=null;
ByteArrayOutputStream bos = null;
ObjectOutputStream os = null;
try {
bos = new ByteArrayOutputStream();
os = new ObjectOutputStream(bos);
os.writeObject(value);
os.close();
bos.close();
rv = bos.toByteArray();
} catch (IOException e) {
throw new IllegalArgumentException("Non-serializable object", e);
} finally {
try {
if(os!=null)os.close();
if(bos!=null)bos.close();
}catch (Exception e2) {
e2.printStackTrace();
}
}
return rv;
}
public static Object deserialize(byte[] in) {
Object rv=null;
ByteArrayInputStream bis = null;
ObjectInputStream is = null;
try {
if(in != null) {
bis=new ByteArrayInputStream(in);
is=new ObjectInputStream(bis);
rv=is.readObject();
is.close();
bis.close();
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(is!=null)is.close();
if(bis!=null)bis.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
return rv;
}
}
- 单例实现：
import com.alibaba.fastjson.JSON;
import com.redis.JedisCommonDao;
import com.redis.ProtostuffUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Redis 通用DAO
* Created by lcx on 2018/4/20.
*/
@Service
public class SingleRedisDao implements JedisCommonDao {
/*Redis超时时间*/
public static final int TIMEOUT_ONE_HOUR = 60 * 60;
public static final int REDIS_ONE_DAY= 24 * 60 * 60;
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
private ShardedJedisPool shardedJedisPool;
/**
* 序列化方式从redis中获取对象
*
* @param key
* @return
*/
@Override
public T getObject(String key, Class clazz) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
byte[] bytes = jedis.get(key.getBytes());
if (bytes != null) {
T obj = ProtostuffUtil.deserializer(bytes, clazz);
if (obj != null) {
return obj;
}
}
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 序列化方式向redis中存入对象(1小时过期)
*
* @param key
* @param obj
* @return
*/
@Override
public String putObject(String key, Object obj) {
return putObject(key, obj, REDIS_ONE_DAY);
}
/**
* 序列化方式向redis中存入对象并设置过期时间(秒)
*
* @param key
* @param obj
* @return
*/
@Override
public String putObject(String key, Object obj, int expire) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
/*存储到redis，成功返回"OK"，失败则返回错误信息*/
byte[] bytes = ProtostuffUtil.serializer(obj);
return jedis.setex(key.getBytes(), expire, bytes);
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 指定的键值
*
* @param key
* @return
*/
@Override
public Long del(String key) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.del(key);
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* JSON形式从redis中获取对象数组
*
* @param key
* @return
*/
@Override
public List getList(String key, Class clazz) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
String objStr = jedis.get(key);
if (objStr != null) {
return JSON.parseArray(objStr, clazz);
}
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* JSON形式向redis中存入对象
*
* @param key
* @param obj
* @return
*/
@Override
public String put(String key, Object obj) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
/*存储到redis，成功返回"OK"，失败则返回错误信息*/
return jedis.setex(key, REDIS_ONE_DAY, JSON.toJSONString(obj));
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 从Redis中取值
*
* @param key
* @return
*/
@Override
public String getValue(String key) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.get(key);
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 往redis里存入值，如果成功则返回1，失败返回0
* @param key
* @return
*/
@Override
public Long setNxValue(String key) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.setnx(key,key);
} finally {
jedis.expire(key,REDIS_ONE_DAY);
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 往redis Set 键里面添加成员
* @param key 键
* @param expire 时间 单位s
* @param members
* @return
*/
@Override
public Long addSetValue(String key, int expire, String... members) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
Long i = jedis.sadd(key,members);
jedis.expire(key,expire);
return i;
} finally {
jedis.expire(key,REDIS_ONE_DAY);
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* redis Set 键里面删除成员
* @param key
* @return
*/
@Override
public Long moveSetValue(String key, String... members) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.srem(key,members);
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 获取redis Set 键里面所有成员
* @param key
* @return
*/
@Override
public Set getSetValues(String key) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.smembers(key);
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
@Override
public String putMapValues(String key, Map map) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.hmset(key.getBytes(), map);
} catch (Exception e) {
logger.error(e.getMessage(), e);
} finally {
jedis.expire(key,REDIS_ONE_DAY);
jedis.close();
}
}catch (Exception e){
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 序列化方式向redis map中存入对象并设置过期时间(秒)
*
* @param key
* @param obj
* @return
*/
public Long putMapObject(String key,String filed, Object obj) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
/*存储到redis，成功返回"OK"，失败则返回错误信息*/
byte[] bytes = ProtostuffUtil.serializer(obj);
return jedis.hsetnx(key.getBytes(),filed.getBytes(), bytes);
} finally {
jedis.expire(key,REDIS_ONE_DAY);
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 序列化方式向redis map中存入对象并设置过期时间(秒)
*
* @param key
* @param s
* @return
*/
public Long putMapString(String key,String filed, String s,int expire) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.hsetnx(key,filed, s);
} finally {
jedis.expire(key,expire);
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
@Override
public Long incr(String key) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.incr(key);
} finally {
jedis.expire(key,REDIS_ONE_DAY);
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return 0L;
}
@Override
public String setString(String key, String value) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
return jedis.setex(key,REDIS_ONE_DAY,value);
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/* *//**
* 序列化方式从redis中获取对象
*
* @param key
* @return
*//*
public T putAllMapObject(String key,Map objectMap) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
*//*存储到redis，成功返回"OK"，失败则返回错误信息*//*
// byte[] bytes = ProtostuffUtil.serializer(obj);
return jedis.hmset()
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}*/
/**
* 序列化方式从redis中获取对象
*
* @param key
* @return
*/
@Override
public T getMapObject(String key, String filed, Class clazz) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
byte[] bytes = jedis.hget(key.getBytes(),filed.getBytes());
if (bytes != null) {
T obj = ProtostuffUtil.deserializer(bytes, clazz);
if (obj != null) {
return obj;
}
}
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
@Override
public Map getAllMap(String key) {
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
Map allMap = jedis.hgetAll(key.getBytes());
return allMap;
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 设置 map
* @param
* @param key
* @param map
*/
public void setMap(String key ,Map map){
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
jedis.set(key.getBytes(),ProtostuffUtil.serialize(map));
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
}
/**
* 获取map
* @param
* @param key
* @return Map
*/
public Map getMap(String key){
try {
ShardedJedis jedis = shardedJedisPool.getResource();
try {
byte[] in = jedis.get(key.getBytes());
Map map = (Map) ProtostuffUtil.deserialize(in);
return map;
} finally {
jedis.close();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
}
- 集群模式
package com.redis.cluster;
import com.alibaba.fastjson.JSON;
;
import com.redis.JedisCommonDao;
import com.redis.ProtostuffUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisCluster;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @Author: lcx
* @Date: Created at 2018/8/18 11:03.
* @Description:
*/
@Component
public class JedisClientClusterDao implements JedisCommonDao {
/*Redis超时时间*/
public static final int REDIS_TIMEOUT = 60 * 60;
public static final int REDIS_ONE_DAY= 24 * 60 * 60;
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Resource
private JedisCluster jedisCluster;
/**
* 序列化方式从redis中获取对象
*
* @param key
* @return
*/
@Override
public T getObject(String key, Class clazz) {
try {
byte[] bytes = jedisCluster.get(key.getBytes());
if (bytes != null) {
T obj = ProtostuffUtil.deserializer(bytes, clazz);
if (obj != null) {
return obj;
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 序列化方式向redis中存入对象(1小时过期)
*
* @param key
* @param obj
* @return
*/
@Override
public String putObject(String key, Object obj) {
return putObject(key, obj, REDIS_ONE_DAY);
}
/**
* 序列化方式向redis中存入对象并设置过期时间(秒)
*
* @param key
* @param obj
* @return
*/
@Override
public String putObject(String key, Object obj, int expire) {
try {
/*存储到redis，成功返回"OK"，失败则返回错误信息*/
byte[] bytes = ProtostuffUtil.serializer(obj);
return jedisCluster.setex(key.getBytes(), expire, bytes);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 指定的键值
*
* @param key
* @return
*/
@Override
public Long del(String key) {
try {
return jedisCluster.del(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* JSON形式从redis中获取对象数组
*
* @param key
* @return
*/
@Override
public List getList(String key, Class clazz) {
try {
String objStr = jedisCluster.get(key);
if (objStr != null) {
return JSON.parseArray(objStr, clazz);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* JSON形式向redis中存入对象
*
* @param key
* @param obj
* @return
*/
@Override
public String put(String key, Object obj) {
try {
/*存储到redis，成功返回"OK"，失败则返回错误信息*/
return jedisCluster.setex(key, REDIS_ONE_DAY, JSON.toJSONString(obj));
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 从Redis中取值
*
* @param key
* @return
*/
@Override
public String getValue(String key) {
try {
return jedisCluster.get(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 往redis里存入值，如果成功则返回1，失败返回0
* @param key
* @return
*/
@Override
public Long setNxValue(String key) {
try {
return jedisCluster.setnx(key,key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}finally {
jedisCluster.expire(key,REDIS_ONE_DAY);
}
return null;
}
/**
* 往redis Set 键里面添加成员
* @param key 键
* @param expire 时间 单位s
* @param members
* @return
*/
@Override
public Long addSetValue(String key, int expire, String... members) {
try {
Long i = jedisCluster.sadd(key,members);
jedisCluster.expire(key,expire);
return i;
} catch (Exception e) {
logger.error(e.getMessage(), e);
}finally {
jedisCluster.expire(key,REDIS_ONE_DAY);
}
return null;
}
/**
* redis Set 键里面删除成员
* @param key
* @return
*/
@Override
public Long moveSetValue(String key, String... members) {
try {
return jedisCluster.srem(key,members);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 获取redis Set 键里面所有成员
* @param key
* @return
*/
@Override
public Set getSetValues(String key) {
try {
return jedisCluster.smembers(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}finally {
jedisCluster.expire(key,REDIS_ONE_DAY);
}
return null;
}
/**
* 获取redis Set 键里面所有成员
* @param key
* @return
*/
@Override
public String putMapValues(String key, Map map) {
try {
String isOk = jedisCluster.hmset(key.getBytes(),map);
jedisCluster.expire(key.getBytes(),REDIS_ONE_DAY);
return isOk;
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 根据键取值
* @param key
* @param filed
* @param clazz
* @param
* @return
*/
@Override
public T getMapObject(String key, String filed, Class clazz) {
try {
byte[] bytes = jedisCluster.hget(key.getBytes(),filed.getBytes());
if (bytes != null) {
T obj = ProtostuffUtil.deserializer(bytes, clazz);
if (obj != null) {
return obj;
}
}
}catch (Exception e){
logger.error(e.getMessage(),e);
}
return null;
}
public Map getAllMap(String key) {
try {
Map allMap = jedisCluster.hgetAll(key.getBytes());
return allMap;
}catch (Exception e){
logger.error(e.getMessage(),e);
}
return null;
}
/**
* 序列化方式向redis map中存入对象并设置过期时间(秒)
*
* @param key
* @param obj
* @return
*/
public Long putMapObject(String key,String filed, Object obj) {
try {
try {
/*存储到redis，成功返回"OK"，失败则返回错误信息*/
byte[] bytes = ProtostuffUtil.serializer(obj);
return jedisCluster.hsetnx(key.getBytes(),filed.getBytes(), bytes);
} finally {
jedisCluster.expire(key,REDIS_ONE_DAY);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 设置 map
* @param
* @param key
* @param map
*/
public void setMap(String key ,Map map){
try {
jedisCluster.set(key.getBytes(),ProtostuffUtil.serialize(map));
} catch (Exception e) {
logger.error("Set key error : "+e);
}
}
/**
* 获取map
* @param
* @param key
* @return Map
*/
public Map getMap(String key){
try {
byte[] in = jedisCluster.get(key.getBytes());
Map map = (Map) ProtostuffUtil.deserialize(in);
return map;
}catch (Exception e){
e.printStackTrace();
}
return null;
}
public Long putMapString(String key,String filed, String s,int expire){
try {
try {
return jedisCluster.hsetnx(key,filed,s);
} finally {
jedisCluster.expire(key,expire);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return 0L;
}
public Long incr(String key){
try {
try {
return jedisCluster.incr(key);
} finally {
jedisCluster.expire(key,REDIS_ONE_DAY);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return 0L;
}
public String setString(String key,String value){
try {
try {
return jedisCluster.setex(key,REDIS_ONE_DAY,value);
} finally {
jedisCluster.expire(key,REDIS_ONE_DAY);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
}