IRedisToolsService
package com.dmz.app.biz.redis.service;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
/**
* redis基础服务bate版本
*
*/
public interface IRedisToolsService {
/**
* 保存数据， 默认7天
* @param key redis的key值
* @param t 要保存的对象， 必须实现序列化接口
* @return 成功， 返回保存的数据
*/
<T extends Serializable> T set(String key, T t);
/**
* 保存数据
* @param key redis的key值
* @param t 要保存的对象， 必须实现序列化接口
* @param liveSeconds 设置存活时间 单位秒
* @return 成功， 返回保存的数据
*/
<T extends Serializable> T set(String key, T t, long liveSeconds);
/**
* 返回redis中的所有存在的key
* @return
*/
Set<String> keys();
/**
* 返回随即生成的key值
* @return
*/
String randomKey();
/**
* 返回是否存在该key值
* @param key
* @return
*/
boolean exists(String key);
/**
* 通过key值删除redis中的数据
* @param key
* @return
*/
<T extends Serializable> T del(String key);
/**
* 从redis根据key查找数据
* @param key
* @return
*/
<T extends Serializable> T get(String key);
/**
* 延长key对应的value的存活时间
* @param key
* @param liveSeconds
* @return 延长成功：true， 否则false
*/
boolean expire(String key, long liveSeconds);
long incr(String key);
long decr(String key);
<T extends Serializable> boolean setNX(final String key, final T t);
<T extends Serializable> T getSet(final String key, final T t);
/**
* 将一个或多个值插入到列表头部
* @param key
* @param t
* @return
*/
<T extends Serializable> long lpush(final String key, final T t);
/**
* 获取列表指定范围内的元素
* @param key
* @param t
* @return
*/
List lrange(final String key, final long start, final long end);
/**
* 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
* @param key
* @param start
* @param end
* @return
*/
boolean ltrim(final String key, long start, long end);
long lpop(final String key);
/**
*
* @Title: batchPipelineSet
* @Description: 批量插入数据
* @param @param keyList key值列表
* @param @param dataList value列表
* @param @param expire 过期时间
* @return void 返回类型
* @throws
*/
void batchPipelineSet(List<String> keyList,List<Object> dataList, long expire);
}
RedisToolsServiceImpl
package com.dmz.app.biz.redis.service.impl;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.aic.dmz.app.biz.redis.dao.IRedisToolsDAO;
import com.aic.dmz.app.biz.redis.service.IRedisToolsService;
@Service("redisToolsService")
public class RedisToolsServiceImpl implements IRedisToolsService{
@Resource
private IRedisToolsDAO redisToolsDAO;
@Override
public <T extends Serializable> T set(String key, T t) {
return (T)redisToolsDAO.set(key, t);
}
@Override
public <T extends Serializable> T set(String key, T t, long liveSeconds) {
return (T)redisToolsDAO.set(key, t, liveSeconds);
}
@Override
public Set<String> keys() {
return redisToolsDAO.keys();
}
@Override
public String randomKey() {
return redisToolsDAO.randomKey();
}
@Override
public boolean exists(String key) {
return redisToolsDAO.exists(key);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Serializable> T del(String key) {
return (T)redisToolsDAO.del(key);
}
@SuppressWarnings("unchecked")
@Override
public <T extends Serializable> T get(String key) {
return (T)redisToolsDAO.get(key);
}
@Override
public boolean expire(String key, long liveSeconds) {
return redisToolsDAO.expire(key, liveSeconds);
}
@Override
public long incr(String key) {
return redisToolsDAO.incr(key);
}
@Override
public long decr(String key) {
return redisToolsDAO.decr(key);
}
@Override
public <T extends Serializable> boolean setNX(final String key, final T t){
return redisToolsDAO.setNX(key, t);
}
@Override
public <T extends Serializable> T getSet(final String key, final T t){
return redisToolsDAO.getSet(key, t);
}
@Override
public <T extends Serializable> long lpush(final String key, final T t) {
// TODO Auto-generated method stub
return redisToolsDAO.lpush(key, t);
}
@Override
public List lrange(final String key, final long start, final long end) {
// TODO Auto-generated method stub
return redisToolsDAO.lrange(key, start, end);
}
@Override
public boolean ltrim(final String key, final long start, final long end) {
// TODO Auto-generated method stub
return redisToolsDAO.ltrim(key, start, end);
}
@Override
public long lpop(String key) {
// TODO Auto-generated method stub
return redisToolsDAO.lpop(key);
}
public void batchPipelineSet(final List<String> keyList,final List<Object> dataList, final long expire){
redisToolsDAO.batchPipelineSet(keyList, dataList, expire);
}
}
IRedisToolsDAO
package com.dmz.app.biz.redis.dao;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
/**
* redis集成spring， 暂时开放如下接口。如有需要在做扩展
* @author EX-CHENKEFENG001
*
* @version 1.0bate
*
*/
public interface IRedisToolsDAO {
/**
* 保存数据， 默认7天
* @param key redis的key值
* @param t 要保存的对象， 必须实现序列化接口
* @return 成功， 返回保存的数据
*/
<T extends Serializable> T set(String key, T t);
/**
* 保存数据
* @param key redis的key值
* @param t 要保存的对象， 必须实现序列化接口
* @param liveSeconds 设置存活时间 单位秒
* @return 成功， 返回保存的数据
*/
<T extends Serializable> T set(String key, T t, long liveSeconds);
/**
* 返回redis中的所有存在的key
* @return
*/
Set<String> keys();
/**
* 返回随即生成的key值
* @return
*/
String randomKey();
/**
* 返回是否存在该key值
* @param key
* @return
*/
boolean exists(String key);
/**
* 通过key值删除redis中的数据
* @param key
* @return
*/
<T extends Serializable> T del(String key);
/**
* 从redis根据key查找数据
* @param key
* @return
*/
<T extends Serializable> T get(String key);
/**
* 延长key对应的value的存活时间
* @param key
* @param liveSeconds
* @return 延长成功：true， 否则false
*/
boolean expire(String key, long liveSeconds);
/**
* 增加获取值
* @param key
* @return
*/
long incr(String key);
/**
* 减少获取值
* @param key
* @return
*/
long decr(String key);
<T extends Serializable> boolean setNX(final String key, final T t);
<T extends Serializable> T getSet(final String key, final T t);
/**
* 将一个或多个值插入到列表头部
* @param key
* @param t
* @return
*/
<T extends Serializable> long lpush(final String key, final T t);
/**
* 获取列表指定范围内的元素
* @param key
* @param t
* @return
*/
List lrange(final String key, final long start, final long end);
/**
* 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
* @param key
* @param start
* @param end
* @return
*/
boolean ltrim(final String key, long start, long end);
long lpop(final String key);
/**
* pipeline
* @Title: batchPipelineSet
* @Description: 管道方式插入数据
* @param keyList key值列表
* @param dataList value值列表
* @param expire 过期时间
* @return void
* @throws
*/
void batchPipelineSet(final List<String> keyList,final List<Object> dataList,final long expire);
}
RedisToolsDAOImpl
package com.dmz.app.biz.redis.dao.impl;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Repository;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
/**
* Redis基础服务
* @author EX-CHENKEFENG001
*
*/
@Repository("redisToolsDAO")
public class RedisToolsDAOImpl implements IRedisToolsDAO, ApplicationContextAware{
protected final FormatLogger logger = new FormatLogger(this.getClass());
private RedisTemplate<String, String> redisTemplate;
@Override
public <T extends Serializable> T set(final String key, final T t) {
return (T)set(key, t, Constants.DEFAULT_CACHE_SECONDS);
}
@Override
public <T extends Serializable> T set(final String key, final T t, final long liveSeconds) {
try{
return redisTemplate.execute(new RedisCallback<T>() {
@SuppressWarnings("unchecked")
@Override
public T doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] keys = redisTemplate.getStringSerializer().serialize(key);
RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
byte[] values = valueSerializer.serialize(t);
conn.set(keys, values);
conn.expire(keys, liveSeconds);
return t;
}
});
}catch(Exception e){
logger.error(e, "set data has error. key=[{0}]. value=[{1}]", key, t);
return null;
}
}
@Override
public Set<String> keys() {
return redisTemplate.execute(new RedisCallback<Set<String>>() {
@Override
public Set<String> doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] keys = redisTemplate.getStringSerializer().serialize("*");
Set<byte[]> keyRes = conn.keys(keys);
Set<String> result = new HashSet<String>();
for (byte[] bs : keyRes) {
result.add(redisTemplate.getStringSerializer().deserialize(bs));
}
return result;
}
});
}
@Override
public String randomKey() {
return redisTemplate.randomKey();
}
@Override
public boolean exists(final String key) {
return redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection conn)
throws DataAccessException {
return conn.exists(redisTemplate.getStringSerializer().serialize(key));
}
});
}
@Override
public <T extends Serializable> T del(final String key) {
return redisTemplate.execute(new RedisCallback<T>() {
@SuppressWarnings("unchecked")
@Override
public T doInRedis(RedisConnection conn)
throws DataAccessException {
T t = (T)get(key);
conn.del(redisTemplate.getStringSerializer().serialize(key));
return t;
}
});
}
@Override
public <T extends Serializable> T get(final String key) {
return redisTemplate.execute(new RedisCallback<T>() {
@SuppressWarnings("unchecked")
@Override
public T doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] valBytes = conn.get(redisTemplate.getStringSerializer().serialize(key));
RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
return (T)valueSerializer.deserialize(valBytes);
}
});
}
@Override
public boolean expire(final String key, final long liveSeconds) {
if(!exists(key)){
return false;
}
redisTemplate.execute(new RedisCallback<Void>() {
@Override
public Void doInRedis(RedisConnection conn)
throws DataAccessException {
conn.expire(redisTemplate.getStringSerializer().serialize(key), liveSeconds);
return null;
}
});
return true;
}
@Override
public long incr(final String key) {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.incr(redisTemplate.getStringSerializer().serialize(key));
}
});
}
@Override
public long decr(final String key) {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.decr(redisTemplate.getStringSerializer().serialize(key));
}
});
}
@SuppressWarnings("unchecked")
@Override
public void setApplicationContext(ApplicationContext context)
throws BeansException {
this.redisTemplate = (RedisTemplate<String, String>) context.getBean("redisTemplate");
CyberarkV9Service cyberarkV9Service =(CyberarkV9Service) context.getBean("cyberarkV9Service");
JedisConnectionFactory jedisConnectionFactory =(JedisConnectionFactory)redisTemplate.getConnectionFactory();
String password= cyberarkV9Service.getPassword("ilifecore.dmz.redis.password");
if(password==null){
logger.warn("get redis password from V9 failed!");
return;
}
jedisConnectionFactory.setPassword(password);
jedisConnectionFactory.getShardInfo().setPassword(password);
jedisConnectionFactory.afterPropertiesSet();
}
@Override
public <T extends Serializable> boolean setNX(final String key, final T t) {
try{
return redisTemplate.execute(new RedisCallback<Boolean>() {
@SuppressWarnings("unchecked")
@Override
public Boolean doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] keys = redisTemplate.getStringSerializer().serialize(key);
RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
byte[] values = valueSerializer.serialize(t);
return conn.setNX(keys,values);
}
});
}catch(Exception e){
logger.error(e, "setNX data has error. key=[{0}]. value=[{1}]", key, t);
return false;
}
}
@Override
public <T extends Serializable> T getSet(final String key, final T t) {
try{
return redisTemplate.execute(new RedisCallback<T>() {
@SuppressWarnings("unchecked")
@Override
public T doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] keys = redisTemplate.getStringSerializer().serialize(key);
RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
byte[] values = valueSerializer.serialize(t);
return (T)valueSerializer.deserialize(conn.getSet(keys, values));
}
});
}catch(Exception e){
logger.error(e, "getSet data has error. key=[{0}]. value=[{1}]", key, t);
return null;
}
}
@Override
public <T extends Serializable> long lpush(final String key, final T t) {
try {
return redisTemplate.execute(new RedisCallback<Long>() {
public Long doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] keys = redisTemplate.getStringSerializer().serialize(key);
RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
byte[] values = valueSerializer.serialize(t);
return conn.lPush(keys, values);
}
});
} catch (Exception e) {
logger.error(e, "lpush data has error. key=[{0}].value=[{1}]", key, t);
return 0l;
}
}
@Override
public List lrange(final String key, final long start, final long end) {
try {
return redisTemplate.execute(new RedisCallback<List>() {
public List doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] keys = redisTemplate.getStringSerializer().serialize(key);
RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
List list = conn.lRange(keys, start, end);
List<Object> objects = new ArrayList<Object>();
for(Object object : list){
objects.add(valueSerializer.deserialize((byte[]) object));
}
return objects;
}
});
} catch (Exception e) {
logger.error(e, "lrange data has error. key=[{0}]. start=[{1}]. end=[{2}]", key, start, end);
return null;
}
}
@Override
public boolean ltrim(final String key, final long start, final long end) {
try {
return redisTemplate.execute(new RedisCallback<Boolean>() {
public Boolean doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] keys = redisTemplate.getStringSerializer().serialize(key);
conn.lTrim(keys, start, end);
return true;
}
});
} catch (Exception e) {
logger.error(e, "ltrim data has error. key=[{0}]. start=[{1}]. end=[{2}]", key, start, end);
return false;
}
}
@Override
public long lpop(final String key) {
try {
return redisTemplate.execute(new RedisCallback<Long>() {
public Long doInRedis(RedisConnection conn)
throws DataAccessException {
byte[] keys = redisTemplate.getStringSerializer().serialize(key);
RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
conn.lPop(keys);
return 1l;
}
});
} catch (Exception e) {
logger.error(e, "lpop data has error. key=[{0}]]", key);
return 0l;
}
}
@Override
public void batchPipelineSet(final List<String> keyList,final List<Object> dataList, final long expire) {
//使用pipeline方式
redisTemplate.executePipelined(new RedisCallback<List<Object>>() {
@Override
public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
for(int i = 0; i < keyList.size();i++){
String key = keyList.get(i);
byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
@SuppressWarnings("unchecked")
RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>) redisTemplate.getValueSerializer();
byte[] value = valueSerializer.serialize(dataList.get(i));
connection.setEx(rawKey, expire, value);
}
return null;
}
});
}
}
666
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
