這編文章主要介紹了springboot整合redis，以及redis配置和一些redis操作數(shù)據(jù)的工具類(lèi)。
首先倒入redis依賴(lài)
一.依賴(lài)
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
二.配置文件
創(chuàng)建一個(gè)redis.properties配置redis
redis.host=localhost
redis.port=6379
redis.password=
redis.database=1
redis.maxActive=8
redis.maxWait=-1
redis.maxIdle=8
redis.minIdle=1
redis.timeOut=0
創(chuàng)建一個(gè)與redis.properties的配置類(lèi)方便直接使用配置的參數(shù)。
@Configuration
@PropertySource(value = "classpath:redis.properties")
@ConfigurationProperties(prefix = "redis")
public class RedisConfigProperties {
// 主機(jī)地址
public String host;
//端口
public int port;
//密碼沒(méi)有不填寫(xiě)
public String password;
// Redis數(shù)據(jù)庫(kù)索引（默認(rèn)為0）
public int database;
//最大活躍連接
public int maxActive;
//連接池最大阻塞等待時(shí)間（使用負(fù)值表示沒(méi)有限制）
public int maxWait;
//連接池中的最大空閑連接
public int maxIdle;
//連接池中的最小空閑連接
public int minIdle;
//連接超時(shí)時(shí)間（毫秒）
public int timeOut;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getDatabase() {
return database;
}
public void setDatabase(int database) {
this.database = database;
}
public int getMaxActive() {
return maxActive;
}
public void setMaxActive(int maxActive) {
this.maxActive = maxActive;
}
public int getMaxWait() {
return maxWait;
}
public void setMaxWait(int maxWait) {
this.maxWait = maxWait;
}
public int getMaxIdle() {
return maxIdle;
}
public void setMaxIdle(int maxIdle) {
this.maxIdle = maxIdle;
}
public int getMinIdle() {
return minIdle;
}
public void setMinIdle(int minIdle) {
this.minIdle = minIdle;
}
public int getTimeOut() {
return timeOut;
}
public void setTimeOut(int timeOut) {
this.timeOut = timeOut;
}
}
三.整合配置
聽(tīng)說(shuō)某寶的fastjson的json和序列化性能很好這里的序列化我們使用fastjson的序列化。
創(chuàng)建一個(gè)自定義序列化配置類(lèi)
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private Class<T> clazz;
public FastJson2JsonRedisSerializer(Class<T> clazz) {
super();
this.clazz = clazz;
}
public byte[] serialize(T t) throws SerializationException {
if (t == null) {
return new byte[0];
}
return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
}
public T deserialize(byte[] bytes) throws SerializationException {
if (bytes == null || bytes.length <= 0) {
return null;
}
String str = new String(bytes, DEFAULT_CHARSET);
return (T) JSON.parseObject(str, clazz);
}
}
將項(xiàng)目進(jìn)行整合
@Configuration
public class RedisConfig {
@Autowired
private RedisConfigProperties redis;
@Bean
public RedisSerializer fastJson2JsonRedisSerializer() { ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
return new FastJson2JsonRedisSerializer<Object>(Object.class);
}
@Bean
public RedisConnectionFactory redisConnectionFactory() {
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
//最大空閑接連
jedisPoolConfig.setMaxIdle(redis.getMaxIdle());
//最小空閑連接
jedisPoolConfig.setMinIdle(redis.getMinIdle());
//連接池最大阻塞等待時(shí)間
jedisPoolConfig.setMaxWaitMillis(redis.getMaxWait());
JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
//主機(jī)地址
jedisConnectionFactory.setHostName(redis.getHost())
//端口
jedisConnectionFactory.setPort(redis.getPort());
//密碼
jedisConnectionFactory.setPassword(redis.getPassword());
//索引
jedisConnectionFactory.setDatabase(redis.getDatabase());
//超時(shí)時(shí)間
jedisConnectionFactory.setTimeout(redis.getTimeOut());
jedisConnectionFactory.setUsePool(true);
jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
return jedisConnectionFactory;
}
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory, RedisSerializer fastJson2JsonRedisSerializer) {
StringRedisTemplate redisTemplate = new StringRedisTemplate(factory); redisTemplate.setConnectionFactory(redisConnectionFactory());
//redis 開(kāi)啟事務(wù)
redisTemplate.setEnableTransactionSupport(true);
//hash 使用jdk 的序列化
redisTemplate.setHashValueSerializer(fastJson2JsonRedisSerializer/*new JdkSerializationRedisSerializer()*/);
//StringRedisSerializer key 序列化
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//keySerializer 對(duì)key的默認(rèn)序列化器。默認(rèn)值是StringSerializer
redisTemplate.setKeySerializer(new StringRedisSerializer());
// valueSerializer
redisTemplate.setValueSerializer(fastJson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}
四.操作數(shù)據(jù)工具類(lèi)
接口：
public interface BaseRedisDao<K, V> {
/**
* 用戶(hù)排序通過(guò)注冊(cè)時(shí)間的 權(quán)重值
* @param date
* @return
*/
double getCreateTimeScore(long date);
/**
* 獲取Redis中所有的鍵的key
* @return
*/
Set<K> getAllKeys();
/**
* 獲取所有的普通key-value
* @return
*/
Map<K,V> getAllString();
/**
* 獲取所有的Set -key-value
* @return
*/
Map<K,Set<V>> getAllSet();
/**
* 獲取所有的ZSet正序 -key-value 不獲取權(quán)重值
* @return
*/
Map<K,Set<V>> getAllZSetReverseRange();
/**
* 獲取所有的ZSet倒序 -key-value 不獲取權(quán)重值
* @return
*/
Map<K,Set<V>> getAllZSetRange();
/**
* 獲取所有的List -key-value
* @return
*/
Map<K,List<V>> getAllList();
/**
* 獲取所有的Map -key-value
* @return
*/
Map<K,Map<K,V>> getAllMap();
/**
* 添加一個(gè)list
* @param key
* @param objectList
*/
void addList(K key, List<V> objectList);
/**
* 向list中增加值
* @param key
* @param obj
* @return 返回在list中的下標(biāo)
*/
long addList(K key,V obj);
/**
* 向list中增加值
* @param key
* @param obj
* @return 返回在list中的下標(biāo)
*/
long addList(K key,V ...obj);
/**
*
* 輸出list
* @param key List的key
* @param s 開(kāi)始下標(biāo)
* @param e 結(jié)束的下標(biāo)
* @return
*/
List<V> getList(K key, long s, long e);
/**
* 輸出完整的list
* @param key
*/
List<V> getList(K key);
/**
* 獲取list集合中元素的個(gè)數(shù)
* @param key
* @return
*/
long getListSize(K key);
/**
* 移除list中某值
* 移除list中 count個(gè)value為object的值,并且返回移除的數(shù)量,
* 如果count為0,或者大于list中為value為object數(shù)量的總和,
* 那么移除所有value為object的值,并且返回移除數(shù)量
* @param key
* @param object
* @return 返回移除數(shù)量
*/
long removeListValue(K key,V object);
/**
* 移除list中某值
* @param key
* @param object
* @return 返回移除數(shù)量
*/
long removeListValue(K key,V... object);
/**
* 批量刪除key對(duì)應(yīng)的value
* @param keys
*/
void remove(final K... keys);
/**
* 刪除緩存
* 根據(jù)key精確匹配刪除
* @param key
*/
void remove(final K key);
/**
* 通過(guò)分?jǐn)?shù)刪除ZSet中的值
* @param key
* @param s
* @param e
*/
void removeZSetRangeByScore(String key,double s , double e);
/**
* 設(shè)置Set的過(guò)期時(shí)間
* @param key
* @param time
* @return
*/
Boolean setSetExpireTime(String key,Long time);
/**
* 設(shè)置ZSet的過(guò)期時(shí)間
* @param key
* @param time
* @return
*/
Boolean setZSetExpireTime(String key,Long time);
/**
* 判斷緩存中是否有key對(duì)應(yīng)的value
* @param key
* @return
*/
boolean exists(final K key);
/**
* 讀取String緩存 可以是對(duì)象
* @param key
* @return
*/
V get(final K key);
/**
* 讀取String緩存 可以是對(duì)象
* @param key
* @return
*/
List<V> get(final K... key);
/**
* 讀取緩存 可以是對(duì)象 根據(jù)正則表達(dá)式匹配
* @param regKey
* @return
*/
List<Object> getByRegular(final K regKey);
/**
* 寫(xiě)入緩存 可以是對(duì)象
* @param key
* @param value
*/
void set(final K key, V value);
/**
* 寫(xiě)入緩存
* @param key
* @param value
* @param expireTime 過(guò)期時(shí)間 -單位s
* @return
*/
void set(final K key, V value, Long expireTime);
/**
* 設(shè)置一個(gè)key的過(guò)期時(shí)間（單位：秒）
* @param key
* @param expireTime
* @return
*/
boolean setExpireTime(K key, Long expireTime);
/**
* 獲取key的類(lèi)型
* @param key
* @return
*/
DataType getType(K key);
/**
* 刪除map中的某個(gè)對(duì)象
* @param key map對(duì)應(yīng)的key
* @param field map中該對(duì)象的key
*/
void removeMapField(K key, V... field);
/*
* 獲取map對(duì)象
* @param key map對(duì)應(yīng)的key
* @return
*/
Map<K,V> getMap(K key);
/*
* 獲取map對(duì)象
* @param key map對(duì)應(yīng)的key
* @return
*/
Long getMapSize(K key);
/**
* 獲取map緩存中的某個(gè)對(duì)象
* @param key map對(duì)應(yīng)的key
* @param field map中該對(duì)象的key
* @return
*/
<T> T getMapField(K key, K field);
/**
* 判斷map中對(duì)應(yīng)key的key是否存在
* @param key map對(duì)應(yīng)的key
* @return
*/
Boolean hasMapKey(K key,K field);
/**
* 獲取map對(duì)應(yīng)key的value
* @param key map對(duì)應(yīng)的key
* @return
*/
List<V> getMapFieldValue(K key);
/**
* 獲取map的key
* @param key map對(duì)應(yīng)的key
* @return
*/
Set<V> getMapFieldKey(K key);
/**
* 添加map
* @param key
* @param map
*/
void addMap(K key, Map<K,V> map);
/**
* 向key對(duì)應(yīng)的map中添加緩存對(duì)象
* @param key cache對(duì)象key
* @param field map對(duì)應(yīng)的key
* @param value 值
*/
void addMap(K key, K field, Object value);
/**
* 向key對(duì)應(yīng)的map中添加緩存對(duì)象
* @param key cache對(duì)象key
* @param field map對(duì)應(yīng)的key
* @param time 過(guò)期時(shí)間-整個(gè)MAP的過(guò)期時(shí)間
* @param value 值
*/
void addMap(K key, K field, V value,long time);
/**
* 向set中加入對(duì)象
* @param key 對(duì)象key
* @param obj 值
*/
void addSet(K key, V... obj);
/**
* 處理事務(wù)時(shí)鎖定key
* @param key
*/
void watch(String key);
/**
* 移除set中的某些值
* @param key 對(duì)象key
* @param obj 值
*/
long removeSetValue(K key, V obj);
/**
* 移除set中的某些值
* @param key 對(duì)象key
* @param obj 值
*/
long removeSetValue(K key, V... obj);
/**
* 獲取set的對(duì)象數(shù)
* @param key 對(duì)象key
*/
long getSetSize(K key);
/**
* 判斷set中是否存在這個(gè)值
* @param key 對(duì)象key
*/
Boolean hasSetValue(K key,V obj);
/**
* 獲得整個(gè)set
* @param key 對(duì)象key
*/
Set<V> getSet(K key);
/**
* 獲得set 并集
* @param key
* @param otherKey
* @return
*/
Set<V> getSetUnion(K key,K otherKey);
/**
* 獲得set 并集
* @param key
* @param set
* @return
*/
Set<V> getSetUnion(K key,Set<Object> set);
/**
* 獲得set 交集
* @param key
* @param otherKey
* @return
*/
Set<V> getSetIntersect(K key,K otherKey);
/**
* 獲得set 交集
* @param key
* @param set
* @return
*/
Set<V> getSetIntersect(K key,Set<Object> set);
/**
* 模糊移除 支持*號(hào)等匹配移除
* @param blears
*/
void removeBlear(K... blears);
/**
* 修改key名 如果不存在該key或者沒(méi)有修改成功返回false
* @param oldKey
* @param newKey
* @return
*/
Boolean renameIfAbsent(String oldKey,String newKey);
/**
* 模糊移除 支持*號(hào)等匹配移除
* @param blear
*/
void removeBlear(K blear);
/**
* 根據(jù)正則表達(dá)式來(lái)移除key-value
* @param blears
*/
void removeByRegular(String... blears);
/**
* 根據(jù)正則表達(dá)式來(lái)移除key-value
* @param blears
*/
void removeByRegular(String blears);
/**
* 根據(jù)正則表達(dá)式來(lái)移除 Map中的key-value
* @param key
* @param blears
*/
void removeMapFieldByRegular(K key,K... blears);
/**
* 根據(jù)正則表達(dá)式來(lái)移除 Map中的key-value
* @param key
* @param blear
*/
void removeMapFieldByRegular(K key,K blear);
/**
* 移除key 對(duì)應(yīng)的value
* @param key
* @param value
* @return
*/
Long removeZSetValue(K key, V... value);
/**
* 移除key ZSet
* @param key
* @return
*/
void removeZSet(K key);
/**
*刪除，鍵為K的集合，索引start<=index<=end的元素子集
* @param key
* @param start
* @param end
* @return
*/
void removeZSetRange(K key,Long start,Long end);
/**
* 并集 將key對(duì)應(yīng)的集合和key1對(duì)應(yīng)的集合合并到key2中
* 如果分?jǐn)?shù)相同的值，都會(huì)保留
* 原來(lái)key2的值會(huì)被覆蓋
* @param key
* @param key1
* @param key2
*/
void setZSetUnionAndStore(String key,String key1, String key2);
/**
* 獲取整個(gè)有序集合ZSET，正序
* @param key
*/
<T> T getZSetRange(K key);
/**
* 獲取有序集合ZSET
* 鍵為K的集合，索引start<=index<=end的元素子集，正序
* @param key
* @param start 開(kāi)始位置
* @param end 結(jié)束位置
*/
<T> T getZSetRange(K key,long start,long end);
/**
* 獲取整個(gè)有序集合ZSET，倒序
* @param key
*/
Set<Object> getZSetReverseRange(K key);
/**
* 獲取有序集合ZSET
* 鍵為K的集合，索引start<=index<=end的元素子集，倒序
* @param key
* @param start 開(kāi)始位置
* @param end 結(jié)束位置
*/
Set<V> getZSetReverseRange(K key,long start,long end);
/**
* 通過(guò)分?jǐn)?shù)(權(quán)值)獲取ZSET集合 正序 -從小到大
* @param key
* @param start
* @param end
* @return
*/
Set<V> getZSetRangeByScore(String key, double start, double end);
/**
* 通過(guò)分?jǐn)?shù)(權(quán)值)獲取ZSET集合 倒序 -從大到小
* @param key
* @param start
* @param end
* @return
*/
Set<V> getZSetReverseRangeByScore(String key, double start, double end);
/**
* 鍵為K的集合，索引start<=index<=end的元素子集
* 返回泛型接口（包括score和value），正序
* @param key
* @param start
* @param end
* @return
*/
Set<ZSetOperations.TypedTuple<V>> getZSetRangeWithScores(K key, long start, long end);
/**
* 鍵為K的集合，索引start<=index<=end的元素子集
* 返回泛型接口（包括score和value），倒序
* @param key
* @param start
* @param end
* @return
*/
Set<ZSetOperations.TypedTuple<V>> getZSetReverseRangeWithScores(K key, long start, long end);
/**
* 鍵為K的集合
* 返回泛型接口（包括score和value），正序
* @param key
* @return
*/
Set<ZSetOperations.TypedTuple<V>> getZSetRangeWithScores(K key);
/**
* 鍵為K的集合
* 返回泛型接口（包括score和value），倒序
* @param key
* @return
*/
Set<ZSetOperations.TypedTuple<V>> getZSetReverseRangeWithScores(K key);
/**
* 鍵為K的集合，sMin<=score<=sMax的元素個(gè)數(shù)
* @param key
* @param sMin
* @param sMax
* @return
*/
long getZSetCountSize(K key,double sMin,double sMax);
/**
* 獲取Zset 鍵為K的集合元素個(gè)數(shù)
* @param key
* @return
*/
long getZSetSize(K key);
/**
* 獲取鍵為K的集合，value為obj的元素分?jǐn)?shù)
* @param key
* @param value
* @return
*/
double getZSetScore(K key,V value);
/**
* 元素分?jǐn)?shù)增加，delta是增量
* @param key
* @param value
* @param delta
* @return
*/
double incrementZSetScore(K key,V value,double delta);
/**
* 添加有序集合ZSET
* 默認(rèn)按照score升序排列，存儲(chǔ)格式K(1)==V(n)，V(1)=S(1)
* @param key
* @param score
* @param value
* @return
*/
Boolean addZSet(String key ,double score, Object value);
/**
* 添加有序集合ZSET
* @param key
* @param value
* @return
*/
Long addZSet(K key,TreeSet<V> value);
/**
* 添加有序集合ZSET
* @param key
* @param score
* @param value
* @return
*/
Boolean addZSet(K key,double[] score, Object[] value);
}
實(shí)現(xiàn)類(lèi)
@Repository("redisHandle")
public class RedisHandle implements BaseRedisDao<String, Object> {
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Resource(name="redisTemplate")
protected RedisTemplate redisTemplate;
/**
* 出異常，重復(fù)操作的次數(shù)
*/
private static Integer times = 5;
public double getCreateTimeScore(long date) {
return date/ 100000.0;
}
public Set<String> getAllKeys() {
return redisTemplate.keys("*");
}
public Map<String, Object> getAllString() {
Set<String> stringSet = getAllKeys();
Map<String, Object> map = new HashMap<String, Object>();
Iterator<String> iterator = stringSet.iterator();
while (iterator.hasNext()) {
String k = iterator.next();
if (getType(k) == DataType.STRING) {
map.put(k, get(k));
}
}
return map;
}
public Map<String, Set<Object>> getAllSet() {
Set<String> stringSet = getAllKeys();
Map<String, Set<Object>> map = new HashMap<String, Set<Object>>();
Iterator<String> iterator = stringSet.iterator();
while (iterator.hasNext()) {
String k = iterator.next();
if (getType(k) == DataType.SET) {
map.put(k, getSet(k));
}
}
return map;
}
public Map<String, Set<Object>> getAllZSetRange() {
Set<String> stringSet = getAllKeys();
Map<String, Set<Object>> map = new HashMap<String, Set<Object>>();
Iterator<String> iterator = stringSet.iterator();
while (iterator.hasNext()) {
String k = iterator.next();
if (getType(k) == DataType.ZSET) {
logger.debug("k:"+k);
map.put(k, getZSetRange(k));
}
}
return map;
}
public Map<String, Set<Object>> getAllZSetReverseRange() {
Set<String> stringSet = getAllKeys();
Map<String, Set<Object>> map = new HashMap<String, Set<Object>>();
Iterator<String> iterator = stringSet.iterator();
while (iterator.hasNext()) {
String k = iterator.next();
if (getType(k) == DataType.ZSET) {
map.put(k, getZSetReverseRange(k));
}
}
return map;
}
public Map<String, List<Object>> getAllList() {
Set<String> stringSet = getAllKeys();
Map<String, List<Object>> map = new HashMap<String, List<Object>>();
Iterator<String> iterator = stringSet.iterator();
while (iterator.hasNext()) {
String k = iterator.next();
if (getType(k) == DataType.LIST) {
map.put(k, getList(k));
}
}
return map;
}
public Map<String, Map<String, Object>> getAllMap() {
Set<String> stringSet = getAllKeys();
Map<String, Map<String, Object>> map = new HashMap<String, Map<String, Object>>();
Iterator<String> iterator = stringSet.iterator();
while (iterator.hasNext()) {
String k = iterator.next();
if (getType(k) == DataType.HASH) {
map.put(k, getMap(k));
}
}
return map;
}
public void addList(String key, List<Object> objectList) {
for (Object obj : objectList) {
addList(key, obj);
}
}
public long addList(String key, Object obj) {
return redisTemplate.boundListOps(key).rightPush(obj);
}
public long addList(String key, Object... obj) {
return redisTemplate.boundListOps(key).rightPushAll(obj);
}
public List<Object> getList(String key, long s, long e) {
return redisTemplate.boundListOps(key).range(s, e);
}
public List<Object> getList(String key) {
return redisTemplate.boundListOps(key).range(0, getListSize(key));
}
public long getListSize(String key) {
return redisTemplate.boundListOps(key).size();
}
public long removeListValue(String key, Object object) {
return redisTemplate.boundListOps(key).remove(0, object);
}
public long removeListValue(String key, Object... objects) {
long r = 0;
for (Object object : objects) {
r += removeListValue(key, object);
}
return r;
}
public void remove(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
remove(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
public void removeBlear(String... blears) {
for (String blear : blears) {
removeBlear(blear);
}
}
public Boolean renameIfAbsent(String oldKey, String newKey) {
return redisTemplate.renameIfAbsent(oldKey, newKey);
}
public void removeBlear(String blear) {
redisTemplate.delete(redisTemplate.keys(blear));
}
public void removeByRegular(String... blears) {
for (String blear : blears) {
removeBlear(blear);
}
}
public void removeByRegular(String blear) {
Set<String> stringSet = getAllKeys();
for (String s : stringSet) {
if (Pattern.compile(blear).matcher(s).matches()) {
redisTemplate.delete(s);
}
}
}
public void removeMapFieldByRegular(String key, String... blears) {
for (String blear : blears) {
removeMapFieldByRegular(key, blear);
}
}
public void removeMapFieldByRegular(String key, String blear) {
Map<String, Object> map = getMap(key);
Set<String> stringSet = map.keySet();
for (String s : stringSet) {
if (Pattern.compile(blear).matcher(s).matches()) {
redisTemplate.boundHashOps(key).delete(s);
}
}
}
public Long removeZSetValue(String key, Object... value) {
return redisTemplate.boundZSetOps(key).remove(value);
}
public void removeZSet(String key) {
removeZSetRange(key, 0L, getZSetSize(key));
}
public void removeZSetRange(String key, Long start, Long end) {
redisTemplate.boundZSetOps(key).removeRange(start, end);
}
public void setZSetUnionAndStore(String key,String key1, String key2) {
redisTemplate.boundZSetOps(key).unionAndStore(key1,key2);
}
public Set<Object> getZSetRange(String key) {
return getZSetRange(key, 0, getZSetSize(key));
}
public Set<Object> getZSetRange(String key, long s, long e) {
return redisTemplate.boundZSetOps(key).range(s, e);
}
public Set<Object> getZSetReverseRange(String key) {
return getZSetReverseRange(key, 0, getZSetSize(key));
}
public Set<Object> getZSetReverseRange(String key, long start, long end) {
return redisTemplate.boundZSetOps(key).reverseRange(start, end);
}
public Set<Object> getZSetRangeByScore(String key, double start, double end) {
return redisTemplate.boundZSetOps(key).rangeByScore(start, end);
}
public Set<Object> getZSetReverseRangeByScore(String key, double start, double end) {
return redisTemplate.boundZSetOps(key).reverseRangeByScore(start, end);
}
public Set<ZSetOperations.TypedTuple<Object>> getZSetRangeWithScores(String key, long start, long end) {
return redisTemplate.boundZSetOps(key).rangeWithScores(start, end);
}
public Set<ZSetOperations.TypedTuple<Object>> getZSetReverseRangeWithScores(String key, long start, long end) {
return redisTemplate.boundZSetOps(key).reverseRangeWithScores(start, end);
}
public Set<ZSetOperations.TypedTuple<Object>> getZSetRangeWithScores(String key) {
return getZSetRangeWithScores(key, 0, getZSetSize(key));
}
public Set<ZSetOperations.TypedTuple<Object>> getZSetReverseRangeWithScores(String key) {
return getZSetReverseRangeWithScores(key, 0, getZSetSize(key));
}
public long getZSetCountSize(String key, double sMin, double sMax) {
return redisTemplate.boundZSetOps(key).count(sMin, sMax);
}
public long getZSetSize(String key) {
return redisTemplate.boundZSetOps(key).size();
}
public double getZSetScore(String key, Object value) {
return redisTemplate.boundZSetOps(key).score(value);
}
public double incrementZSetScore(String key, Object value, double delta) {
return redisTemplate.boundZSetOps(key).incrementScore(value, delta);
}
public Boolean addZSet(String key, double score, Object value) {
return redisTemplate.boundZSetOps(key).add(value, score);
}
public Long addZSet(String key, TreeSet<Object> value) {
return redisTemplate.boundZSetOps(key).add(value);
}
public Boolean addZSet(String key, double[] score, Object[] value) {
if (score.length != value.length) {
return false;
}
for (int i = 0; i < score.length; i++) {
if (addZSet(key, score[i], value[i]) == false) {
return false;
}
}
return true;
}
public void remove(String key) {
if (exists(key)) {
redisTemplate.delete(key);
}
}
public void removeZSetRangeByScore(String key,double s , double e) {
redisTemplate.boundZSetOps(key).removeRangeByScore(s,e);
}
public Boolean setSetExpireTime(String key, Long time) {
return redisTemplate.boundSetOps(key).expire(time, TimeUnit.SECONDS);
}
public Boolean setZSetExpireTime(String key, Long time) {
return redisTemplate.boundZSetOps(key).expire(time, TimeUnit.SECONDS);
}
public boolean exists(String key) {
return redisTemplate.hasKey(key);
}
public Object get(int key) {
return this.get(String.valueOf(key));
}
public Object get(long key) {
return this.get(String.valueOf(key));
}
public Object get(String key) {
return redisTemplate.boundValueOps(key).get();
}
public List<Object> get(String... keys) {
List<Object> list = new ArrayList<Object>();
for (String key : keys) {
list.add(get(key));
}
return list;
}
public List<Object> getByRegular(String regKey) {
Set<String> stringSet = getAllKeys();
List<Object> objectList = new ArrayList<Object>();
for (String s : stringSet) {
if (Pattern.compile(regKey).matcher(s).matches() && getType(s) == DataType.STRING) {
objectList.add(get(s));
}
}
return objectList;
}
public void set(long key, Object value) {
this.set(String.valueOf(key) ,value);
}
public void set(int key, Object value) {
this.set(String.valueOf(key) ,value);
}
public void set(String key, Object value) {
redisTemplate.boundValueOps(key).set(value);
}
public void set(String key, Object value, Long expireTime) {
redisTemplate.boundValueOps(key).set(value, expireTime, TimeUnit.SECONDS);
}
public boolean setExpireTime(String key, Long expireTime) {
return redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
}
public DataType getType(String key) {
return redisTemplate.type(key);
}
public void removeMapField(String key, Object... field) {
redisTemplate.boundHashOps(key).delete(field);
}
public Long getMapSize(String key) {
return redisTemplate.boundHashOps(key).size();
}
public Map<String, Object> getMap(String key) {
return redisTemplate.boundHashOps(key).entries();
}
public <T> T getMapField(String key, String field) {
return (T) redisTemplate.boundHashOps(key).get(field);
}
public Boolean hasMapKey(String key, String field) {
return redisTemplate.boundHashOps(key).hasKey(field);
}
public List<Object> getMapFieldValue(String key) {
return redisTemplate.boundHashOps(key).values();
}
public Set<Object> getMapFieldKey(String key) {
return redisTemplate.boundHashOps(key).keys();
}
public void addMap(String key, Map<String, Object> map) {
redisTemplate.boundHashOps(key).putAll(map);
}
public void addMap(String key, String field, Object value) {
redisTemplate.boundHashOps(key).put(field, value);
}
public void addMap(String key, String field, Object value, long time) {
redisTemplate.boundHashOps(key).put(field, value);
redisTemplate.boundHashOps(key).expire(time, TimeUnit.SECONDS);
}
public void watch(String key) {
redisTemplate.watch(key);
}
public void addSet(String key, Object... obj) {
redisTemplate.boundSetOps(key).add(obj);
}
public long removeSetValue(String key, Object obj) {
return redisTemplate.boundSetOps(key).remove(obj);
}
public long removeSetValue(String key, Object... obj) {
if (obj != null && obj.length > 0) {
return redisTemplate.boundSetOps(key).remove(obj);
}
return 0L;
}
public long getSetSize(String key) {
return redisTemplate.boundSetOps(key).size();
}
public Boolean hasSetValue(String key, Object obj) {
Boolean boo = null;
int t =0;
while (true){
try {
boo = redisTemplate.boundSetOps(key).isMember(obj);
break;
} catch (Exception e) {
logger.error("key[" + key + "],obj[" + obj + "]判斷Set中的值是否存在失敗,異常信息:" + e.getMessage());
t++;
}
if(t>times){
break;
}
}
logger.info("key[" + key + "],obj[" + obj + "]是否存在,boo:" + boo);
return boo;
}
public Set<Object> getSet(String key) {
return redisTemplate.boundSetOps(key).members();
}
public Set<Object> getSetUnion(String key, String otherKey) {
return redisTemplate.boundSetOps(key).union(otherKey);
}
public Set<Object> getSetUnion(String key, Set<Object> set) {
return redisTemplate.boundSetOps(key).union(set);
}
public Set<Object> getSetIntersect(String key, String otherKey) {
return redisTemplate.boundSetOps(key).intersect(otherKey);
}
public Set<Object> getSetIntersect(String key, Set<Object> set) {
return redisTemplate.boundSetOps(key).intersect(set);
}
}
五.單元測(cè)試
創(chuàng)建一個(gè)測(cè)試的base了后面的類(lèi)只需要繼承這個(gè)父類(lèi)即可
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes=App.class)
@WebAppConfiguration
public class BaseTest {
}
測(cè)試：
public class RedisTest extends BaseTest {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
@Resource
RedisHandle rs;
@Test
public void RedisTest() throws Exception {
rs.set(1, "11");
System.out.println(rs.get(1));
}
}
文章來(lái)源： http://www.haha174.top/article/details/251216
項(xiàng)目源碼： https://github.com/haha174/boot.git
