Redis操作工具类
package com.lwy.it.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.QueryTimeoutException;
import org.springframework.data.redis.RedisConnectionFailureException;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public final class RedisOperateUtil {
private static Logger LOGGER = LoggerFactory.getLogger(RedisOperateUtil.class);
// 默认最长时效时间（秒）
private static long EXPIRED_TIME = 604800L;
private void setDefaultExpiredTime(final String key) {
Long ttl = this.ttl(key, TimeUnit.SECONDS);
if (!Objects.isNull(ttl) && ttl.equals(-1L)) {
this.expire(key, EXPIRED_TIME, TimeUnit.SECONDS);
}
}
@Autowired
private RedisOperations redisTemplate;
/**
* DEL key
*
* @param key Redis Key
* @return 是否删除成功
*/
public Boolean del(final String key) {
Boolean result = null;
try {
result = redisTemplate.delete(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* DEL key key
*
* @param keys Redis Keys
* @return 删除的数量
*/
public Long del(final Set<String> keys) {
Long result = null;
try {
result = redisTemplate.delete(keys);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* EXISTS key
*
* @param key Redis Key
* @return 是否存在key
*/
public Boolean exists(final String key) {
Boolean result = null;
try {
result = redisTemplate.hasKey(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* EXISTS key1 key2
*
* @param keys Redis Keys
* @return 指定为参数的键中存在的键数，多次提及和存在的键被多次计算。
*/
public Long exists(final Set<String> keys) {
Long result = null;
try {
result = redisTemplate.countExistingKeys(keys);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* EXPIRE key seconds
*
* @param key Redis Key
* @param timeout 超时时间
* @param unit 时间粒度单位
* @return 在管道/事务中使用时为 null
*/
public Boolean expire(final String key, final long timeout, TimeUnit unit) {
Boolean result = null;
try {
result = redisTemplate.expire(key, timeout, unit);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* TTL key
*
* @param key Redis Key
* @param timeUnit 时间粒度单位
* @return 按照给定时间粒度单位，返回过期时间，时间粒度单位为空时默认为秒
*/
public Long ttl(final String key, TimeUnit timeUnit) {
if (Objects.isNull(timeUnit)) {
timeUnit = TimeUnit.SECONDS;
}
Long result = null;
try {
result = redisTemplate.getExpire(key, timeUnit);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* TTL key
*
* @param key Redis Key
* @return 按照给定时间粒度单位，返回过期时间，时间粒度单位为空时默认为秒
*/
public Long ttl(final String key) {
return this.ttl(key, TimeUnit.SECONDS);
}
/**
* SET key value
*
* @param key Redis Key
* @param value 存储的value
* @param <V> value泛型类型
*/
public <V> void set(final String key, final V value) {
this.setex(key, value, EXPIRED_TIME, TimeUnit.SECONDS);
}
/**
* GET key
*
* @param key Redis Key
* @param <V> value泛型类型
* @return 返回存储的value
*/
public <V> V get(final String key) {
ValueOperations<String, V> operations = redisTemplate.opsForValue();
V result = null;
try {
result = operations.get(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* GETSET key value
*
* @param key Redis Key
* @param value 存储的value
* @param <V> value泛型类型
* @return 指定key的值，并返回key的旧值
*/
public <V> V getset(final String key, final V value) {
ValueOperations<String, V> operations = redisTemplate.opsForValue();
V result = null;
try {
result = operations.getAndSet(key, value);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* MSET key value [key value ...]
* 缺少过期时间，不建议使用
*
* @param map 不能为空
* @param <V> value泛型类型
*/
@Deprecated
public <V> void mset(final Map<String, V> map) {
if (!CollectionUtils.isEmpty(map)) {
ValueOperations<String, V> operations = redisTemplate.opsForValue();
try {
operations.multiSet(map);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
} else {
LOGGER.warn("Parameters map is null or empty");
}
}
/**
* MGET key [key ...]
* 建议使用LinkedHashSet
*
* @param keys 不重复Redis Key集合，不能为空
* @param <V> value泛型类型
* @return 结果List集合
*/
public <V> List<V> mget(final Set<String> keys) {
List<V> result = Collections.emptyList();
if (!CollectionUtils.isEmpty(keys)) {
ValueOperations<String, V> operations = redisTemplate.opsForValue();
try {
result = operations.multiGet(keys);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
}
return result;
}
/**
* SETEX key seconds value
*
* @param key Redis Key
* @param value Redis Value
* @param timeout 超时时间
* @param unit 单位
* @param <V> value泛型类型
*/
public <V> void setex(final String key, final V value, final long timeout, TimeUnit unit) {
if (Objects.isNull(unit)) {
unit = TimeUnit.SECONDS;
}
ValueOperations<String, V> operations = redisTemplate.opsForValue();
try {
operations.set(key, value, timeout, unit);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
}
/**
* SETNX key value
*
* @param key Redis Key
* @param value Redis Value
* @param timeout 超时时间
* @param unit 单位
* @param <V> value泛型类型
* @return 设置成功，返回true。设置失败，返回false。
*/
public <V> Boolean setnx(final String key, final V value, final long timeout, TimeUnit unit) {
if (Objects.isNull(unit)) {
unit = TimeUnit.SECONDS;
}
ValueOperations<String, V> operations = redisTemplate.opsForValue();
Boolean result = null;
try {
result = operations.setIfAbsent(key, value, timeout, unit);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* INCR key
* 如果key不存在，那么key的值会先被初始化为0，然后再执行INCR操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
*
* @param key Redis Key
* @return 加上1之后，key的值。
*/
public Long incr(final String key) {
return this.incrby(key, 1L);
}
/**
* INCRBY key increment
*
* @param key Redis Key
* @param delta 指定的增量值
* @return 加上指定的增量值之后，key的值。
*/
public Long incrby(final String key, final long delta) {
Long result = null;
ValueOperations<String, Long> operations = redisTemplate.opsForValue();
try {
result = operations.increment(key, delta);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* DECRBY key
*
* @param key Redis Key
* @return 减去1之后，key的值。
*/
public Long decr(final String key) {
return this.decrby(key, 1L);
}
/**
* Redis Decrby命令将key所储存的值减去指定的减量值。
* 如果key不存在，那么key的值会先被初始化为0，然后再执行DECRBY操作。
* 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
*
* @param key Redis Key
* @param delta 指定减量值
* @return 减去指定减量值之后，key的值。
*/
public Long decrby(final String key, final long delta) {
ValueOperations<String, Long> operations = redisTemplate.opsForValue();
Long result = null;
try {
result = operations.decrement(key, delta);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HDEL key field [field ...]
*
* @param key Redis Key
* @param hashKeys Hash Keys
* @return 被成功删除字段的数量，不包括被忽略的字段。
*/
public Long hdel(final String key, final String... hashKeys) {
Long result = null;
try {
result = redisTemplate.opsForHash().delete(key, hashKeys);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HEXISTS key field
*
* @param key Redis Key
* @param hashKey Hash Key
* @return 如果哈希表含有给定字段，返回teue。如果哈希表不含有给定字段，或key不存在，返回false。
*/
public Boolean hexists(final String key, final String hashKey) {
Boolean result = null;
try {
result = redisTemplate.opsForHash().hasKey(key, hashKey);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HGET key field
*
* @param key Redis Key
* @param hashKey Hash Key
* @param <V> value泛型类型
* @return 返回给定字段的值。如果给定的字段或key不存在时，返回null。
*/
public <V> V hget(final String key, final String hashKey) {
HashOperations<String, String, V> operations = redisTemplate.opsForHash();
V result = null;
try {
result = operations.get(key, hashKey);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HGETALL key
*
* @param key Redis Key
* @param <V> value泛型类型
* @return 以列表形式返回哈希表的字段及字段值。若key不存在，返回空列表。
*/
public <V> Map<String, V> hgetall(final String key) {
HashOperations<String, String, V> operations = redisTemplate.opsForHash();
Map<String, V> result = null;
try {
result = operations.entries(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HKEYS key
*
* @param key Redis Key
* @return 包含哈希表中所有域（field）列表。当key不存在时，返回一个空列表。
*/
public Set<String> hkeys(final String key) {
Set<String> result = null;
try {
result = redisTemplate.opsForHash().keys(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HLEN key
*
* @param key Redis Key
* @return 获取哈希表中字段的数量
*/
public Long hlen(final String key) {
Long result = null;
try {
result = redisTemplate.opsForHash().size(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HMGET key field [field ...]
* 建议使用LinkedHashSet
*
* @param key Redis Key
* @param hashKeys Hash Key
* @param <V> value泛型类型
* @return 一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样。
*/
public <V> List<V> hmget(final String key, final Set<String> hashKeys) {
HashOperations<String, String, V> operations = redisTemplate.opsForHash();
List<V> result = null;
try {
result = operations.multiGet(key, hashKeys);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HSET key field value
*
* @param key Redis Key
* @param hashKey Hash Key
* @param value 存储的值
* @param <V> value泛型类型
*/
public <V> void hset(final String key, final String hashKey, final V value) {
try {
redisTemplate.opsForHash().put(key, hashKey, value);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
}
/**
* HMSET key field value [field value ...]
*
* @param key Redis Key
* @param map Redis Key Value
* @param <V> value泛型类型
*/
public <V> void hmset(final String key, final Map<String, V> map) {
if (!CollectionUtils.isEmpty(map)) {
try {
redisTemplate.opsForHash().putAll(key, map);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
}
}
/**
* HSETNX key field value
* 只有在字段 field 不存在时，设置哈希表字段的值。
*
* @param key Redis Key
* @param hashKey Hash Key
* @param value 存储的值
* @param <V> value泛型类型
* @return 设置成功，返回true。如果给定字段已经存在且没有操作被执行，返回false。
*/
public <V> Boolean hsetnx(final String key, final String hashKey, final V value) {
Boolean result = null;
try {
result = redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* HVALS key
*
* @param key Redis Key
* @param <V> value泛型类型
* @return 一个包含哈希表中所有值的列表。当key不存在时，返回一个空表。
*/
public <V> List<V> hvals(String key) {
List<V> result = null;
try {
result = redisTemplate.opsForHash().values(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* BLPOP key timeout
*
* @param key Redis Key
* @param timeout 超时时间
* @param unit 单位
* @param <V> value泛型类型
* @return 被弹出元素的值
*/
public <V> V blpop(final String key, final long timeout, TimeUnit unit) {
if (Objects.isNull(unit)) {
unit = TimeUnit.SECONDS;
}
ListOperations<String, V> operations = redisTemplate.opsForList();
V result = null;
try {
result = operations.leftPop(key, timeout, unit);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* BRPOP key timeout
*
* @param key Redis Key
* @param timeout 超时时间
* @param unit 单位
* @param <V> value泛型类型
* @return 被弹出元素的值
*/
public <V> V brpop(final String key, final long timeout, TimeUnit unit) {
if (Objects.isNull(unit)) {
unit = TimeUnit.SECONDS;
}
ListOperations<String, V> operations = redisTemplate.opsForList();
V result = null;
try {
result = operations.rightPop(key, timeout, unit);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* LINDEX key index
*
* @param key Redis Key
* @param index 索引
* @param <V> value泛型类型
* @return 通过索引获取列表中的元素
*/
public <V> V lindex(final String key, final long index) {
ListOperations<String, V> operations = redisTemplate.opsForList();
V result = null;
try {
result = operations.index(key, index);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* LLEN key
*
* @param key Redis Key
* @return 列表长度
*/
public Long llen(final String key) {
Long result = null;
try {
result = redisTemplate.opsForList().size(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* LPOP key
*
* @param key Redis Key
* @param <V> value泛型类型
* @return 移出并获取列表的第一个元素
*/
public <V> V lpop(final String key) {
ListOperations<String, V> operations = redisTemplate.opsForList();
V result = null;
try {
result = operations.leftPop(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* LPUSH key value
*
* @param key Redis Key
* @param value 存储的值
* @param <V> value泛型类型
* @return 执行LPUSH命令后，列表的长度
*/
public <V> Long lpush(final String key, final V value) {
ListOperations<String, V> operations = redisTemplate.opsForList();
Long result = null;
try {
result = operations.leftPush(key, value);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* LPUSH key value [value ...]
*
* @param key Redis Key
* @param values 存储的列表值
* @param <V> value泛型类型
* @return 执行LPUSH命令后，列表的长度
*/
public <V> Long lpush(final String key, final Collection<V> values) {
ListOperations<String, V> operations = redisTemplate.opsForList();
Long result = null;
try {
result = operations.leftPushAll(key, values);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* LRANGE key start stop
*
* @param key Redis Key
* @param start 开始索引
* @param end 结束索引
* @param <V> value泛型类型
* @return 列表指定范围内的元素
*/
public <V> List<V> lrange(final String key, final long start, final long end) {
ListOperations<String, V> operations = redisTemplate.opsForList();
List<V> result = null;
try {
result = operations.range(key, start, end);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* LSET key index value
*
* @param key Redis Key
* @param index 索引
* @param value 存储的值
* @param <V> value泛型类型
*/
public <V> void lset(final String key, final long index, final V value) {
ListOperations<String, V> operations = redisTemplate.opsForList();
try {
operations.set(key, index, value);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
}
/**
* RPOP key
*
* @param key Redis Key
* @param <V> value泛型类型
* @return 被移除的元素
*/
public <V> V rpop(final String key) {
ListOperations<String, V> operations = redisTemplate.opsForList();
V result = null;
try {
result = operations.rightPop(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* RPUSH key value
*
* @param key Redis Key
* @param value 存储的值
* @param <V> value泛型类型
* @return 执行RPUSH操作后，列表的长度
*/
public <V> Long rpush(final String key, final V value) {
ListOperations<String, V> operations = redisTemplate.opsForList();
Long result = null;
try {
result = operations.rightPush(key, value);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* RPUSH key value [value ...]
*
* @param key Redis Key
* @param values 存储的列表值
* @param <V> value泛型类型
* @return 执行RPUSH操作后，列表的长度
*/
public <V> Long rpush(final String key, Collection<V> values) {
ListOperations<String, V> operations = redisTemplate.opsForList();
Long result = null;
try {
result = operations.rightPushAll(key, values);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* SADD key member [member ...]
*
* @param key Redis Key
* @param values 存储的列表值
* @param <V> value泛型类型
* @return 被添加到集合中的新元素的数量，不包括被忽略的元素。
*/
public <V> Long sadd(final String key, final V... values) {
SetOperations<String, V> operations = redisTemplate.opsForSet();
Long result = null;
try {
result = operations.add(key, values);
this.setDefaultExpiredTime(key);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* SCARD key
*
* @param key Redis Key
* @param <V> value泛型类型
* @return 集合的数量。当集合key不存在时，返回0。
*/
public <V> Long scard(final String key) {
Long result = null;
try {
result = redisTemplate.opsForSet().size(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* SISMEMBER key member
*
* @param key Redis Key
* @param object 成员元素
* @return 如果成员元素是集合的成员，返回true。如果成员元素不是集合的成员，或key不存在，返回false。
*/
public Boolean sismember(final String key, final Object object) {
Boolean result = null;
try {
result = redisTemplate.opsForSet().isMember(key, object);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* SMEMBERS key
*
* @param key Redis Key
* @param <V> value泛型类型
* @return 集合中的所有成员。
*/
public <V> Set<V> smembers(final String key) {
SetOperations<String, V> operations = redisTemplate.opsForSet();
Set<V> result = null;
try {
result = operations.members(key);
} catch (RedisConnectionFailureException exception) {
LOGGER.error(exception.getMessage(), exception);
} catch (QueryTimeoutException exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
/**
* SREM key member [member ...]
*
* @param key Redis Key
* @param values 删除的值
* @return 被成功移除的元素的数量，不包括被忽略的元素。
*/
public Long srem(final String key, final Object... values) {
Long result = null;
try {
result = redisTemplate.opsForSet().remove(key, values);
} catch (Exception exception) {
LOGGER.error(exception.getMessage(), exception);
}
return result;
}
}