首先在applicationContext.xml中引入redisTemplate
<bean id="propertyConfigurer" class="PropertiesUtils">
<property name="ignoreResourceNotFound" value="true" />
<property name="locations">
<list>
<value>classpath*:*.properties</value>
</list>
</property>
</bean>
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="${redis.max_total}" />
<property name="minIdle" value="${redis.min_idle}" />
<property name="maxIdle" value="${redis.max_idle}" />
<property name="maxWaitMillis" value="${redis.max_wait}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
<property name="testOnReturn" value="${redis.testOnReturn}" />
<property name="testWhileIdle" value="${redis.testWhileIdle}" />
</bean>
<bean id="jedisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="poolConfig" ref="jedisPoolConfig" />
<property name="hostName" value="${redis.ip}" />
<property name="port" value="${redis.port}" />
<property name="database" value="${redis.db.index}" />
</bean>
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory" />
</bean>
然后写一个redis.property去保存对应的配置
然后写一个读取配置的文件
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
public class PropertiesUtils extends PropertyPlaceholderConfigurer {
//所有属性文件的键值对
private static Map<String, Object> ctxPropertiesMap;
/**
* 添加所有属性到map中
* @see org.springframework.beans.factory.config.PropertyPlaceholderConfigurer#processProperties(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.Properties)
*/
@Override
protected synchronized void processProperties(
ConfigurableListableBeanFactory beanFactoryToProcess,
Properties props) throws BeansException {
super.processProperties(beanFactoryToProcess, props);
if (null==ctxPropertiesMap) {
ctxPropertiesMap = new HashMap<String, Object>();
}
for (Object key : props.keySet()) {
String keyStr = key.toString();
String value = props.getProperty(keyStr);
ctxPropertiesMap.put(keyStr, value);
}
}
public static String getContextProperty(String name) {
return null == ctxPropertiesMap || ctxPropertiesMap.get(name) == null ? "" : ctxPropertiesMap.get(name).toString();
}
public static String getContextProperty(String name, String defaultValue) {
return null == ctxPropertiesMap || ctxPropertiesMap.get(name) == null ? defaultValue : ctxPropertiesMap.get(name).toString();
}
public static Integer getInt(String name) {
String value = getContextProperty(name);
if ((value + "").matches("-?\\d+")) {
return Integer.parseInt(value);
} else {
return null;
}
}
/**
* @param name 属性名
*/
public static Integer getInt(String name, Integer defaultValue) {
String value = getContextProperty(name);
if ((value + "").matches("-?\\d+")) {
return Integer.parseInt(value);
} else {
return defaultValue;
}
}
}
首先定义一个接口
import org.springframework.data.redis.connection.RedisZSetCommands.Tuple;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
public interface CacheService {
/**
* key
*
* @param key
* @return 获取过期时间
*/
public Long ttl(final String key);
/**
* 生成缓存 key
*
* @param namespace eg : carModle:{carFamily}:{id}:year
* @param keys eg: audi,123
* @return eg: carModle:audi:123:year
*/
public String generateCacheKey(String namespace, Object... keys);
public Boolean existsKey(String key);
/**
* 将对象添加到缓存中
*
* @param key 缓存的 key 值
* @param value 对象
*/
public void putIntoCache(final String key, final Object value);
/**
* 将对象添加到缓存中
*
* @param key 缓存的 key 值
* @param value 对象
* @param time 过期时间(多久之后过期) 单位为秒
*/
public void putIntoCache(final String key, final Object value, final long time);
/**
* 清除缓存
*
* @param key 缓存的 key 值
*/
public void clearCache(final String key);
/**
* 从缓存中获得对象
*
* @param key 缓存的 key
* @param clazz 对象的类型
* @return 缓存的 value
*/
public <T> T getFromCache(final String key, final Class<T> clazz);
/**
* 从缓存中获取字符串
* @param key
* @return
*/
String getStringFromCache(final String key);
public <T> T getMapFromCache(final String key, final Class<T> clazz);
public <T> T getObjectFromCache(final String key,final Class<T> clazz);
/**
* 根据 key ,从缓存中获取 list
*
* @param key 缓存的 key
* @param clazz 对象的类型
*/
public <T> List<T> getListFromCache(final String key, final Class<T> clazz);
/**
* 从缓存中批量获取 对象的值
*
* @param keys 缓存 key 的 list
* @param clazz 对象的类型
* @return
*/
public <T> List<T> getListFromCache(final List<String> keys,
final Class<T> clazz);
/**
* 自增 key
*
* @param key
* @return 自增之后的 id
*/
public Long incr(final String key);
/**
* 自增 key
*
* @param key
* @return 自增之后的 id
*/
public Long incr(final String key, final Long expireTime);
/**
* hashSet put操作
*
* @param hashName hash hash表的名字
* @param filedName key 值
* @param value key 对应的 value值
* @param expireTime 超时时间
* @return
*/
Boolean hset(String hashName, String filedName, Object value,
long expireTime);
/**
* hashSet 操作
*
* @param hashName hash hash表的名字
* @param filedName key 值
* @param value key 对应的value值
* @return
*/
Boolean hset(String hashName, String filedName, Object value);
/**
* hashGet hash get 操作
*
* @param hashName hash 表的名字
* @param filedName key 值
* @return 对应的 value 的值
*/
Object hget(String hashName, String filedName);
/**
* hashGet hash getAll 操作
*
* @param hashName hash 表的名
* @param filedName key 值
* @return 对应的 value 的值
*/
<T> List<T> hgetall(String hashName, final Class<T> clazz);
/**
* hashGet hash haskey 操作
*
* @param hashName hash 表的名字
* @param filedName key 值
* @return
*/
Boolean hhaskey(String hashName, String filedName);
/**
* @param hashName
* @param filedName
* @return
*/
Boolean hExists(String hashName, String filedName);
/**
* hashGet hash delete 操作
*
* @param hashName hash 表的名字
* @param filedName key 值
* @return
*/
void hdelete(String hashName, String filedName);
/**
* 批量保存
*
* @param <DefaultTuple>
* @param <T>
* @param key
* @param value
* @param score
* @param expireTime
* @return
*/
Long zsetBatch(final String key, final Set<Tuple> tuples, final long expireTime);
/**
* zset add 操作
*
* @param key
* @param value
* @param score
* @param expireTime 如果该zet过期时间,则设置这个过期时间
* @return
*/
Boolean zset(String key, final Serializable value, double score, long expireTime);
/**
* 会有默认值的设置有效期
*
* @param key
* @param value
* @param score
* @return
*/
Boolean zset(String key, final Serializable value, double score);
/**
* 不改变设置有效期的zset插入
*
* @param key
* @param value
* @param score
* @return
*/
Boolean zsetNoExpire(String key, final Serializable value, double score);
/**
* zset add 操作
*
* @param key
* @param value
* @param score
* @param expireTime 如果该key不存在/zet无过期时间,则设置这个过期时间
* @return
*/
Boolean zset(String key, final Object value, double score, long expireTime);
/**
* zset add 操作
*
* @param key
* @param value
* @param score
* @return
*/
Boolean zset(String key, final Object value, double score);
/**
* zset get 操作
*
* @param key
* @param value
* @param score
* @return
*/
<T> Set<T> zget(String key, final Class<T> clazz);
/**
* zset顺序取数据
*
* @param key
* @param startIndex
* @param endIndex
* @param clazz
* @return
*/
<T> Set<T> zrange(final String key, final Integer startIndex, final Integer endIndex, final Class<T> clazz);
/**
* zset集合总数
*
* @param key
* @param startIndex
* @param endIndex
* @param clazz
* @return
*/
public Long zcount(final String key);
/**
* 删除KEY
*
* @param key
* @return
*/
Long delKey(final String key);
/**
* set add 操作
*
* @param key
* @param value
* @param expireTime
* @return
*/
Boolean set(String key, final Object value, long expireTime);
/**
* set remove 操作
*
* @param key
* @param value
* @return
*/
Boolean sRem(String key, final Object value);
/**
* 获得set所有元素
*
* @param key
* @param clazz
* @return
*/
<T> Set<T> sMembers(String key, final Class<T> clazz);
/**
* 增加value大小的值
*
* @param key
* @param value
* @return
*/
Long incrBy(final String key, final Long value);
/**
* 分布式锁
* 缓存减压使用
*
* @param key
* @param value
* @param expireTime
* @return
*/
Boolean setnx(final String key, final Long value, final Long expireTime);
/**
* 检查set中是否包含这个值
* @param key
* @param value
* @return
*/
Boolean sIsMember(String key, final Object value);
}
然后定义redis的实现类
import java.io.Serializable;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.Resource;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisZSetCommands.Tuple;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.SerializeWriter;
import com.ttpai.api.cache.CacheService;
@Service
public class RedisCacheServiceImpl implements CacheService {
private static final String pattern = "\\{[^}]*\\}";
private static final long oneDayExexpire = 22 * 60 * 60L;// 默认22小时有效期
private static final String DEFAULT_CHARSET = "utf-8";
@Resource
private RedisTemplate<String, Serializable> redisTemplate;
protected Feature T;
@Override
public String generateCacheKey(String namespace, Object... keys) {
checkRedisKeyParamCount(namespace, keys);
// 创建 Pattern 对象
Pattern r = Pattern.compile(pattern);
// 现在创建 matcher 对象
Matcher m = r.matcher(namespace);
int count = 0;
String replaceName = null;
while (m.find()) {
replaceName = m.replaceFirst(keys[count].toString());
m = r.matcher(replaceName);
count++;
}
int argsLength = keys.length;
if (count != argsLength) {
throw new IllegalArgumentException("字符串占位符个数和传入的参数数量不相等");
}
return replaceName;
}
@Override
public void putIntoCache(final String key, final Object value, final long expireTime) {
redisTemplate.execute(new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
connection.set(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
out.toBytes(DEFAULT_CHARSET));
if(expireTime > -1) {
connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
}
return true;
}
});
}
@Override
public void putIntoCache(final String key, final Object value) {
putIntoCache(key, value, Constants.REDIS_DEFAULT_CACHE_TIME);
}
@Override
public void clearCache(final String key) {
redisTemplate.execute(new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
connection.del(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
return true;
}
});
}
@Override
public <T> T getFromCache(final String key, final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<T>() {
@Override
public T doInRedis(RedisConnection connection) throws DataAccessException {
byte[] out = connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (out == null) {
return null;
}
return JSONObject.parseObject(out, clazz);
}
});
}
@Override
public String getStringFromCache(final String key){
return redisTemplate.execute((RedisCallback<String>) connection -> {
byte[] out=connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
if(out==null){
return null;
}
return new String(out);
});
}
@Override
public <T> T getMapFromCache(final String key, final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<T>() {
@Override
public T doInRedis(RedisConnection connection) throws DataAccessException {
byte[] out = connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (out == null) {
return null;
}
String resultStr = new String(out, Charset.forName(DEFAULT_CHARSET));
resultStr = resultStr.substring(1, resultStr.length());
resultStr = resultStr.substring(0, resultStr.length() - 1);
return JSONObject.parseObject(resultStr.replace("\\", ""), clazz);
}
});
}
@SuppressWarnings("all")
@Override
public <T> T getObjectFromCache(final String key, final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<T>() {
@Override
public T doInRedis(RedisConnection connection) throws DataAccessException {
byte[] out = connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (out == null) {
return null;
}
String resultStr = new String(out, Charset.forName(DEFAULT_CHARSET));
resultStr = resultStr.substring(1, resultStr.length());
resultStr = resultStr.substring(0, resultStr.length() - 1);
resultStr.replace("\\", "");
return JSONObject.parseObject(resultStr.replace("\\", ""), clazz);
}
});
}
// public static void main(String[] args) throws ClassNotFoundException {
// String str =
// "{\"别克\":[],\"大众\":[],\"奥迪\":[],\"宝马\":[],\"日产\":[],\"本田\":[{\"carAge\":5,\"rate\":18}],\"比亚迪\":[],\"现代\":[],\"雪佛兰\":[]}";
// Class clazz = Class.forName("java.util.Map");
// Map map = JSONObject.parseObject(str, clazz);
// System.out.println();
// }
@Override
public <T> List<T> getListFromCache(final List<String> keys, final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<List<T>>() {
@SuppressWarnings("unchecked")
@Override
public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
if (keys.size() == 0) {
return new ArrayList<T>();
}
List<byte[]> keySet = new ArrayList<byte[]>();
for (String key : keys) {
keySet.add(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
}
List<T> out = new ArrayList<T>();
if (keySet.size() <= Constants.REDIS_MGET_LIMIT) {
List<byte[]> results =
connection.mGet(keySet.toArray(new byte[keySet.size()][]));
if (results == null) {
return null;
}
for (byte[] result : results) {
if (result != null) {
T t = JSONObject.parseObject(result, clazz);
out.add(t);
}
}
} else {
connection.openPipeline();
int limitCount = keySet.size() / Constants.REDIS_MGET_LIMIT;
int leftCount = keySet.size() % Constants.REDIS_MGET_LIMIT;
for (int i = 0; i < limitCount; i++) {
connection.mGet(keySet
.subList(i * Constants.REDIS_MGET_LIMIT,
(i + 1) * Constants.REDIS_MGET_LIMIT)
.toArray(new byte[Constants.REDIS_MGET_LIMIT][]));
}
if (leftCount > 0) {
connection.mGet(keySet
.subList(limitCount * Constants.REDIS_MGET_LIMIT, keySet.size())
.toArray(new byte[leftCount][]));
}
List<Object> results = connection.closePipeline();
for (Object object : results) {
if (object != null) {
for (byte[] o : (List<byte[]>) object) {
if (o != null) {
T t = JSONObject.parseObject(o, clazz);
out.add(t);
}
}
}
}
}
return out;
}
});
}
@Override
public <T> List<T> getListFromCache(final String key, final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<List<T>>() {
@Override
public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
byte[] out = connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (out == null) {
return null;
}
return JSONObject.parseArray(new String(out, Charset.forName(DEFAULT_CHARSET)),
clazz);
}
});
}
@Override
public Long incr(final String key) {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
Long result = connection.incr(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
return result;
}
});
}
@Override
public Long incr(final String key, final Long expireTime) {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
Long result = connection.incr(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
return result;
}
});
}
@Override
public Boolean hset(final String hashName, final String filedName, final Object value,
final long expireTime) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
Boolean result =
connection.hSet(hashName.getBytes(Charset.forName(DEFAULT_CHARSET)),
filedName.getBytes(Charset.forName(DEFAULT_CHARSET)),
out.toBytes(DEFAULT_CHARSET));
if (result && expireTime > 0) {
connection.expire(hashName.getBytes(Charset.forName(DEFAULT_CHARSET)),
expireTime);
}
return result;
}
});
}
@Override
public Boolean hset(String hashName, String filedName, Object value) {
return hset(hashName, filedName, value, Constants.REDIS_DEFAULT_CACHE_TIME);
}
@Override
public Object hget(final String hashName, final String filedName) {
return this.redisTemplate.execute(new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
byte[] bytes = connection.hGet(hashName.getBytes(Charset.forName(DEFAULT_CHARSET)),
filedName.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (bytes == null) {
return null;
}
Object obj = JSONObject.parseObject(
new String(bytes, Charset.forName(DEFAULT_CHARSET)), Object.class);
return obj;
}
});
}
private void checkRedisKeyParamCount(String key, Object... args) {
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(key);
int count = 0;
while (m.find()) {
count++;
}
int argsLength = args.length;
if (count != argsLength) {
throw new IllegalArgumentException("缓存skey中的字符串占位符个数和传入的参数数量不相等");
}
}
@Override
public Boolean hhaskey(String hashName, String filedName) {
return redisTemplate.opsForHash().hasKey(hashName, filedName);
}
@Override
public Boolean hExists(final String hashName, final String filedName) {
return redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
Boolean flag = connection.hExists(hashName.getBytes(), filedName.getBytes());
return flag;
}
});
}
@Override
public void hdelete(String hashName, String filedName) {
redisTemplate.opsForHash().delete(hashName, filedName);
}
@Override
public Boolean zset(final String key, final Serializable value, final double score,
final long expireTime) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
/*
* Boolean haskey =
* connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
*/
// 已有key不需要重复设置有效期
Boolean result = connection.zAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
score, out.toBytes(DEFAULT_CHARSET));
if (result && expireTime > 0) {
connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
}
return result;
}
});
}
@Override
public Boolean zset(final String key, final Serializable value, final double score) {
return zset(key, value, score, oneDayExexpire);
}
@Override
public Boolean zsetNoExpire(final String key, final Serializable value, final double score) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
/*
* Boolean haskey =
* connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
*/
// 已有key不需要重复设置有效期
Boolean result = connection.zAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
score, out.toBytes(DEFAULT_CHARSET));
return result;
}
});
}
/**
* 批量插入zset
*/
@Override
public Long zsetBatch(final String key, final Set<Tuple> tuples, final long expireTime) {
if (null == tuples || tuples.size() == 0) return 0L;
return this.redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
Long cnt = connection.zAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)), tuples);
connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
return cnt;
}
});
}
@Override
public Boolean zset(final String key, final Object value, final double score,
final long expireTime) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
Boolean haskey = connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
// connection.ttl(key.getBytes());//获取有效时间
Boolean result = connection.zAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
score, out.toBytes(DEFAULT_CHARSET));
if (!haskey && result && expireTime > 0) {
connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
}
return result;
}
});
}
@Override
public Boolean zset(final String key, final Object value, final double score) {
return this.zset(key, value, score, oneDayExexpire);
}
@Override
public <T> Set<T> zget(final String key, final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<Set<T>>() {
@SuppressWarnings("unchecked")
@Override
public Set<T> doInRedis(RedisConnection connection) throws DataAccessException {
Long sum = connection.zCard(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (sum < 1) {
return null;
}
Set<T> res = new HashSet<T>(sum.intValue());
Set<byte[]> out =
connection.zRange(key.getBytes(Charset.forName(DEFAULT_CHARSET)), 0l, sum);
for (byte[] bs : out) {
res.add((T) JSONObject.parseObject(bs, clazz));
}
return res;
}
});
}
/**
* zset集合中取出某一段范围数据,不包含分数scoure
*
* @param key
* @param startIndex
* @param endIndex
* @param clazz
* @return
*/
public <T> Set<T> zrange(final String key, final Integer startIndex, final Integer endIndex,
final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<Set<T>>() {
@SuppressWarnings("unchecked")
@Override
public Set<T> doInRedis(RedisConnection connection) throws DataAccessException {
LinkedHashSet<T> res = new LinkedHashSet<T>();
Set<byte[]> out = connection.zRange(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
startIndex, endIndex);
for (byte[] bs : out) {
res.add((T) JSONObject.parseObject(bs, clazz));
}
return res;
}
});
}
/**
* zset集合总数
*
* @param key
* @return
*/
public Long zcount(final String key) {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.zCount(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
Double.MIN_VALUE, Double.MAX_VALUE);
}
});
}
@Override
public <T> List<T> hgetall(final String hashName, final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<List<T>>() {
@Override
public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
List<byte[]> out =
connection.hVals(hashName.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (out == null) {
return null;
}
return RedisObjectUtil.getListFrom(out, clazz);
}
});
}
@Override
public Boolean existsKey(final String key) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
Boolean haskey = connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
// connection.ttl(key.getBytes());//获取有效时间
return haskey;
}
});
}
/**
* 删除某个key
*
* @return long 被删除的数量
* @author rickycoder
*/
@Override
public Long delKey(final String key) {
return this.redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.del(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
}
});
}
/**
* set add 操作
*/
@Override
public Boolean set(final String key, final Object value, final long expireTime) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
Boolean haskey = connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
Long result = connection.sAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
out.toBytes(DEFAULT_CHARSET));
if (!haskey && result != null && result == 1 && expireTime > 0) {
connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
}
return result != null && result == 1;
}
});
}
/**
* set remove 操作
*/
@Override
public Boolean sRem(final String key, final Object value) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
Boolean haskey = connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (haskey) {
Long result = connection.sRem(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
out.toBytes(DEFAULT_CHARSET));
return result == null || result.intValue() == 0 ? false : true;
} else {
return false;
}
}
});
}
/**
* 获得set所有元素
*/
@Override
public <T> Set<T> sMembers(final String key, final Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<Set<T>>() {
@Override
public Set<T> doInRedis(RedisConnection connection) throws DataAccessException {
Set<byte[]> out =
connection.sMembers(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
if (out == null) {
return null;
}
return RedisObjectUtil.getSetFrom(out, clazz);
}
});
}
@Override
public Long incrBy(final String key, final Long value) {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
Long result =
connection.incrBy(key.getBytes(Charset.forName(DEFAULT_CHARSET)), value);
return result;
}
});
}
@Override
public Boolean setnx(final String key, final Long value, final Long expireTime) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
final byte[] keyBytes = key.getBytes(Charset.forName(DEFAULT_CHARSET));
Boolean result = connection.setNX(keyBytes, out.toBytes(DEFAULT_CHARSET));
if (result) {
connection.expire(keyBytes, expireTime);
}
return result;
}
});
}
/**
* 以秒为单位,返回给定 key 的剩余有效时间
*/
@Override
public Long ttl(final String key) {
return this.redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.ttl(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
}
});
}
@Override
public Boolean sIsMember(final String key, final Object value) {
return this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
SerializeWriter out = new SerializeWriter();
JSONSerializer serializer = new JSONSerializer(out);
serializer.write(value);
Boolean result = connection.sIsMember(key.getBytes(Charset.forName("utf-8")),
out.toBytes("utf-8"));
return result;
}
});
}
}
其中 cacheService.generateCacheKey(“store_{mobile}”, mobile);使用正则去替换生成的key。