RedisConfig
@Configuration
public class RedisConfig {
//编写redisTemplate
//固定模板，开箱即用
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
//为了开发方便一般使用string,object
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
//json序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); 部分版本因为漏洞或者其他原因弃用
om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
//String的序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用的string序列化方式
template.setKeySerializer(stringRedisSerializer);
//hash的key也采用string的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
//value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
//hash的value采用jackson序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
RedisUtil
@Component
public class RedisUtil {
@Autowired
RedisTemplate<String, Object> redisTemplate;
/**-----------------------------key相关操作-------------------------------------*/
/**
* @Description: 是否存在key
* @Param: [key]
* @return: boolean
* @Author: MiZiMi
* @Date: 2020/4/28 17:10
*/
public boolean hasKey(String key) {
return key == null ? false : redisTemplate.hasKey(key);
}
/**
* @Description: 删除key
* @Param: [key]
* @return: boolean
* @Author: MiZiMi
* @Date: 2020/4/28 17:10
*/
public boolean delete(String key) {
return key == null ? false : redisTemplate.delete(key);
}
/**
* @Description: 批量删除key
* @Param: [keys]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 17:12
*/
public Long delete(Collection<String> keys) {
return redisTemplate.delete(keys);
}
/**
* @Description: 设置过期时间
* @Param: [key, timeout, unit]
* @return: java.lang.Boolean
* @Author: MiZiMi
* @Date: 2020/4/28 17:15
*/
public Boolean expire(String key, long timeout, TimeUnit unit) {
if (key == null || unit == null) {
return false;
}
return redisTemplate.expire(key, timeout, unit);
}
/**
* @Description: 查找匹配的key
* @Param: [pattern]
* @return: java.util.Set<java.lang.String>
* @Author: MiZiMi
* @Date: 2020/4/28 17:16
*/
public Set<String> keys(String pattern) {
if (pattern == null) {
return null;
}
return redisTemplate.keys(pattern);
}
/**
* @Description: 移除key的过期时间，key将持久保持
* @Param: [key]
* @return: java.lang.Boolean
* @Author: MiZiMi
* @Date: 2020/4/28 17:18
*/
public Boolean persist(String key) {
if (key == null) {
return false;
}
return redisTemplate.persist(key);
}
/**
* @Description: 查看key的过期时间, key或者unit不存在时返回0，key存在但是没有设置生存时间，返回-1，key不存在返回-2
* @Param: [key, unit]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 17:20
*/
public Long getExpire(String key, TimeUnit unit) {
if (key == null || unit == null) {
throw new IllegalArgumentException("getExpire 参数不能为null");
}
return redisTemplate.getExpire(key, unit);
}
/**-----------------------------String相关操作-------------------------------------*/
/**
* @Description: 设置key-value
* @Param: [key, value]
* @return: void
* @Author: MiZiMi
* @Date: 2020/4/28 17:23
*/
public void set(String key, Object value) {
if (key == null || value == null) {
return;
}
redisTemplate.opsForValue().set(key, value);
}
/**
* @Description: 设置key value并设置过期时间
* @Param: [key, value, Time, unit]
* @return: void
* @Author: MiZiMi
* @Date: 2020/4/28 17:26
*/
public void set(String key, Object value, long Time, TimeUnit unit) {
if (key == null || value == null || unit == null) {
return;
}
redisTemplate.opsForValue().set(key, value, Time, unit);
}
/**
* @Description: 设置key-value并设置过期时间，有返回值
* @Param: [key, value, Time, unit]
* @return: java.lang.Boolean
* @Author: MiZiMi
* @Date: 2020/4/28 17:31
*/
public Boolean setIfAbsent(String key, Object value, long Time, TimeUnit unit) {
if (key == null || value == null || unit == null) {
throw new IllegalArgumentException("setIfAbsent 参数不能为null");
}
return redisTemplate.opsForValue().setIfAbsent(key, value, Time, unit);
}
/**
* @Description: 获取指定key的值
* @Param: [key]
* @return: java.lang.Object
* @Author: MiZiMi
* @Date: 2020/4/28 17:34
*/
public Object get(String key) {
if (key == null) {
return null;
}
return redisTemplate.opsForValue().get(key);
}
/**
* @Description: 先获取，再设置
* @Param: [key, value]
* @return: java.lang.Object
* @Author: MiZiMi
* @Date: 2020/4/28 17:36
*/
public Object getSet(String key, Object value) {
if (key == null) {
return null;
}
return redisTemplate.opsForValue().getAndSet(key, value);
}
/**
* @Description: 批量key获取批量value
* @Param: [keys]
* @return: java.util.List<java.lang.Object>
* @Author: MiZiMi
* @Date: 2020/4/28 17:38
*/
public List<Object> mget(Collection<String> keys) {
if (keys == null) {
return Collections.emptyList();
}
return redisTemplate.opsForValue().multiGet(keys);
}
/**
* @Description: 将指定Key的Value原子性的增加increment。如果该Key不存在，其初始值为0，
* 在incrby之后其值为increment。如果Value的值不能转换为整型值，如Hi，
* 该操作将执行失败并抛出相应异常。操作成功则返回增加后的value值
* @Param: [key, increment]
* @return: long
* @Author: MiZiMi
* @Date: 2020/4/28 17:43
*/
public Long incrby(String key, long increment) {
if (key == null) {
throw new IllegalArgumentException("incrby 参数 key 不能为null");
}
return redisTemplate.opsForValue().increment(key, increment);
}
/**
* @Description: 将指定key的value原子性的减少decrement, 如果key不存在，其初始冷0，
* 在decrby之后其值decrement,如果value的值不能转换为整数值，如果执行失败就抛出异常，操作成功后返回减少后的值
* @Param: [key, decrement]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 17:46
*/
public Long decrby(String key, long decrement) {
if (key == null) {
throw new IllegalArgumentException("decrby 参数 key 不能为null");
}
return redisTemplate.opsForValue().decrement(key, decrement);
}
/**
* @Description: 如果key存在，append命令将参数value的数据追加到已存在value的末尾，
* 如果key不存在，append命令就会创建一个新的 key/value，返回追加后的value的字符串长度
* @Param: [key, value]
* @return: java.lang.Integer
* @Author: MiZiMi
* @Date: 2020/4/28 17:50
*/
public Integer append(String key, String value) {
if (key == null) {
throw new IllegalArgumentException("append 参数 key 不能为null");
}
return redisTemplate.opsForValue().append(key, value);
}
/**-----------------------------hash相关操作-------------------------------------*/
/**
* @Description: 通过key和field获取指定的value
* @Param: [key, field]
* @return: java.lang.Object
* @Author: MiZiMi
* @Date: 2020/4/28 17:52
*/
public Object hGet(String key, Object field) {
if (key == null || field == null) {
return null;
}
return redisTemplate.opsForHash().get(key, field);
}
/**
* @Description: 设置key field value
* @Param: [key, field, value]
* @return: void
* @Author: MiZiMi
* @Date: 2020/4/28 17:54
*/
public void hSet(String key, Object field, Object value) {
if (key == null || field == null) {
return;
}
redisTemplate.opsForHash().put(key, field, value);
}
/**
* @Description: 判断指定的key中是否存在指定的field
* @Param: [key, field]
* @return: java.lang.Boolean
* @Author: MiZiMi
* @Date: 2020/4/28 17:55
*/
public Boolean hExists(String key, Object field) {
if (key == null || field == null) {
return false;
}
return redisTemplate.opsForHash().hasKey(key, field);
}
/**
* @Description: 删除指定key中的多个字段
* @Param: [key, fields]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 17:57
*/
public Long hDel(String key, Object... fields) {
if (key == null || fields == null || fields.length == 0) {
return 0L;
}
return redisTemplate.opsForHash().delete(key, fields);
}
/**
* @Description: 通过指定的key获取所有的field和value
* @Param: [key]
* @return: java.util.Map<java.lang.Object, java.lang.Object>
* @Author: MiZiMi
* @Date: 2020/4/28 17:59
*/
public Map<Object, Object> hgetAll(String key) {
if (key == null) {
return null;
}
return redisTemplate.opsForHash().entries(key);
}
/**
* @Description: 批量设置hash的field/value
* @Param: [key, hash]
* @return: void
* @Author: MiZiMi
* @Date: 2020/4/28 18:01
*/
public void hmSet(String key, Map<String, Object> hash) {
if (key == null || hash == null) {
return;
}
redisTemplate.opsForHash().putAll(key, hash);
}
/**
* @Description: 获取指定key中的一组filed的一组value的值
* @Param: [key, fields]
* @return: java.util.List<java.lang.Object>
* @Author: MiZiMi
* @Date: 2020/4/28 18:04
*/
public List<Object> hmGet(String key, Collection<Object> fields) {
if (key == null || fields == null) {
return null;
}
return redisTemplate.opsForHash().multiGet(key, fields);
}
/**
* @Description: 对应key的字段自增相应的值
* @Param: [key, field, increment]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 18:06
*/
public Long hIncrby(String key, Object field, long increment) {
if (key == null || field == null) {
throw new IllegalArgumentException("hIncrby key or field 不能为空");
}
return redisTemplate.opsForHash().increment(key, field, increment);
}
/**-----------------------------List相关操作-------------------------------------*/
/**
* @Description: 向列表左边添加元素。如果该Key不存在，该命令将在插入之前创建一个与该Key关联的空链表，
* 之后再将数据从链表的头部插入。
* 如果该键的Value不是链表类型，该命令将将会抛出相关异常。操作成功则返回插入后链表中元素的数量
* @Param: [key, strs]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 18:09
*/
public Long lPush(String key, Object... strs) {
if (key == null) {
return 0L;
}
return redisTemplate.opsForList().leftPushAll(key, strs);
}
/**
* @Description: 向列表右边添加元素。如果该Key不存在，该命令将在插入之前创建一个与该Key关联的空链表，
* 之后再将数据从链表的头部插入。
* 如果该键的Value不是链表类型，该命令将将会抛出相关异常。操作成功则返回插入后链表中元素的数量
* @Param: [key, strs]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 18:11
*/
public Long rPush(String key, Object... strs) {
if (key == null) {
return 0L;
}
return redisTemplate.opsForList().rightPushAll(key, strs);
}
/**
* @Description: 从左边弹出指定key的value
* @Param: [key]
* @return: java.lang.Object
* @Author: MiZiMi
* @Date: 2020/4/28 18:12
*/
public Object lPop(String key) {
if (key == null) {
return null;
}
return redisTemplate.opsForList().leftPop(key);
}
/**
* @Description: 从右边弹出指定key的value
* @Param: [key]
* @return: java.lang.Object
* @Author: MiZiMi
* @Date: 2020/4/28 18:12
*/
public Object rPop(String key) {
if (key == null) {
return null;
}
return redisTemplate.opsForList().rightPop(key);
}
/**
* @Description:取返回
* @Param: [key, start, end]
* @return: java.util.List<java.lang.Object>
* @Author: MiZiMi
* @Date: 2020/4/28 18:16
*/
public List<Object> lRange(String key, long start, long end) {
if (key == null) {
return null;
}
return redisTemplate.opsForList().range(key, start, end);
}
/**
* @Description: 让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
* 下标 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
* 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推
* @Param: [key, start, end]
* @return: void
* @Author: MiZiMi
* @Date: 2020/4/28 18:19
*/
public void lTrim(String key, long start, long end) {
if (key == null) {
return;
}
redisTemplate.opsForList().trim(key, start, end);
}
/**
* @Description: 该命令将返回链表中指定位置(index)的元素，index是0-based，表示从头部位置开始第index的元素，
* 如果index为-1，表示尾部元素。如果与该Key关联的不是链表，该命令将返回相关的错误信息。 如果超出index返回这返回nil
* @Param: [key, index]
* @return: java.lang.Object
* @Author: MiZiMi
* @Date: 2020/4/28 18:20
*/
public Object lIndex(String key, long index) {
if (key == null) {
return null;
}
return redisTemplate.opsForList().index(key, index);
}
/**
* @Description: 返回指定key关联的队列中的元素数量
* @Param: [key]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 18:24
*/
public Long lLen(String key) {
if (null == key) {
return 0L;
}
return redisTemplate.opsForList().size(key);
}
/** *************Set数据类型************* */
/**
* @Description: 向set中插入
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:24
*/
public Long sAdd(String key, Object... members) {
if (null == key) {
return 0L;
}
return redisTemplate.opsForSet().add(key, members);
}
/**
* @Description: 返回set成员数量
* @Param: [key]
* @return: java.lang.Long
* @Author: MiZiMi
* @Date: 2020/4/28 18:26
*/
public Long sCard(String key) {
if (null == key) {
return 0L;
}
return redisTemplate.opsForSet().size(key);
}
/**
* @Description: 判断是否是成员
* @Param: [key, member]
* @return: java.lang.Boolean
* @Author: MiZiMi
* @Date: 2020/4/28 18:26
*/
public Boolean sIsMember(String key, Object member) {
if (null == key) {
return false;
}
return redisTemplate.opsForSet().isMember(key, member);
}
/**
* @Description: 随机返回一个成员
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:27
*/
public Object sRandomMember(String key) {
if (null == key) {
return null;
}
return redisTemplate.opsForSet().randomMember(key);
}
/**
* @Description: 返回指定数量的成员
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:28
*/
public List<Object> sRandomMember(String key, int count) {
if (null == key) {
return null;
}
return redisTemplate.opsForSet().randomMembers(key, count);
}
/**
* @Description: 随机删除一个member并返回
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:28
*/
public Object sPop(String key) {
if (null == key) {
return null;
}
return redisTemplate.opsForSet().pop(key);
}
/**
* @Description: 获取所有member
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:30
*/
public Set<Object> sMembers(String key) {
if (null == key) {
return null;
}
return redisTemplate.opsForSet().members(key);
}
/**
* @Description: 从与Key关联的Set中删除参数中指定的成员，不存在的参数成员将被忽略，
* 如果该Key并不存在，将视为空Set处理。返回从Set中实际移除的成员数量，如果没有则返回0
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:30
*/
public Long sRem(String key, Object... members) {
if (null == key) {
return 0L;
}
return redisTemplate.opsForSet().remove(key, members);
}
/**
* @Description: 将一个集合中的元素移动到另外一个集合中去
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:31
*/
public Boolean sMove(String srckey, String dstkey, Object member) {
if (null == srckey || null == dstkey) {
return false;
}
return redisTemplate.opsForSet().move(srckey, member, dstkey);
}
/**
* @Description: 获取两个集合的并集
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:31
*/
public Set<Object> sUnion(String key, String otherKeys) {
if (null == key || otherKeys == null) {
return null;
}
return redisTemplate.opsForSet().union(key, otherKeys);
}
//**********Sorted Set 数据类型********************
/**
* @Description: 添加参数中指定的所有成员及其分数到指定key的Sorted Set中，在该命令中我们可以指定多组score/member作为参数。
* 如果在添加时参数中的某一成员已经存在，该命令将更新此成员的分数为新值，同时再将该成员基于新值重新排序。
* 如果键不存在，该命令将为该键创建一个新的Sorted Set Value，并将score/member对插入其中。
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:32
*/
public Boolean zAdd(String key, double score, Object member) {
if (null == key) {
return false;
}
return redisTemplate.opsForZSet().add(key, member, score);
}
/**
* @Description: 该命令将移除参数中指定的成员，其中不存在的成员将被忽略。
* 如果与该Key关联的Value不是Sorted Set，相应的错误信息将被返回。 如果操作成功则返回实际被删除的成员数量
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:32
*/
public Long zRem(String key, Object... members) {
if (null == key || null == members) {
return 0L;
}
return redisTemplate.opsForZSet().remove(key, members);
}
/**
* @Description: 返回Sorted Set中的成员数量，如果该Key不存在，返回0。
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:33
*/
public Long zCard(String key) {
if (null == key) {
return 0L;
}
return redisTemplate.opsForZSet().size(key);
}
/**
* @Description: 该命令将为指定Key中的指定成员增加指定的分数。如果成员不存在，该命令将添加该成员并假设其初始分数为0，
* 此后再将其分数加上increment。如果Key不存在，该命令将创建该Key及其关联的Sorted Set，
* 并包含参数指定的成员，其分数为increment参数。如果与该Key关联的不是Sorted Set类型，
* 相关的错误信息将被返回。如果不报错则以串形式表示的新分数。
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:34
*/
public Double zIncrby(String key, double score, Object member) {
if (null == key) {
throw new IllegalArgumentException("zIncrby key 不能为空");
}
return redisTemplate.opsForZSet().incrementScore(key, member, score);
}
/**
* @Description: 该命令用于获取分数(score)在min和max之间的成员数量。
* （min=<score<=max）如果加上了“(”着表明是开区间例如zcount key (min max 则 表示（min<score=<max）
* 同理zcount key min (max 则表明(min=<score<max) 返回指定返回数量。
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:37
*/
public Long zCount(String key, double min, double max) {
if (null == key) {
return 0L;
}
return redisTemplate.opsForZSet().count(key, min, max);
}
/**
* @Description: Sorted Set中的成员都是按照分数从低到高的顺序存储，该命令将返回参数中指定成员的位置值，
* 其中0表示第一个成员，它是Sorted Set中分数最低的成员。 如果该成员存在，则返回它的位置索引值。否则返回nil。
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:37
*/
public Long zRank(String key, Object member) {
if (null == key) {
return null;
}
return redisTemplate.opsForZSet().rank(key, member);
}
/**
* @Description: 如果该成员存在，以字符串的形式返回其分数，否则返回null
* @Param:
* @return:
* @Author: MiZiMi
* @Date: 2020/4/28 18:37
*/
public Double zScore(String key, Object member) {
if (null == key) {
return null;
}
return redisTemplate.opsForZSet().score(key, member);
}
/**
* @Description: 该命令返回顺序在参数start和stop指定范围内的成员，这里start和stop参数都是0-based，即0表示第一个成员，-1表示最后
* 一个成员。如果start大于该Sorted
* Set中的最大索引值，或start > stop，此时一个空集合将被返回。如果stop大于最大索引值，
* 该命令将返回从start到集合的最后一个成员。如果命令中带有可选参数WITHSCORES选项，
* 该命令在返回的结果中将包含每个成员的分数值，如value1,score1,value2,score2...。
* @Param: [key, min, max]
* @return: java.util.Set<java.lang.Object>
* @Author: MiZiMi
* @Date: 2020/4/28 18:38
*/
public Set<Object> zRange(String key, long min, long max) {
if (null == key) {
return null;
}
return redisTemplate.opsForZSet().range(key, min, max);
}
/**
* @Description: 该命令的功能和ZRANGE基本相同，唯一的差别在于该命令是通过反向排序获取指定位置的成员，
* 即从高到低的顺序。如果成员具有相同的分数，则按降序字典顺序排序。
* @Param: [key, start, end]
* @return: java.util.Set<java.lang.Object>
* @Author: MiZiMi
* @Date: 2020/4/28 18:38
*/
public Set<Object> zReverseRange(String key, long start, long end) {
if (null == key) {
return null;
}
return redisTemplate.opsForZSet().reverseRange(key, start, end);
}
/**
* @Description: 该命令将返回分数在min和max之间的所有成员，即满足表达式min <= score <= max的成员，
* 其中返回的成员是按照其分数从低到高的顺序返回，如果成员具有相同的分数，
* 则按成员的字典顺序返回。可选参数LIMIT用于限制返回成员的数量范围。
* 可选参数offset表示从符合条件的第offset个成员开始返回，同时返回count个成员。
* 可选参数WITHSCORES的含义参照ZRANGE中该选项的说明。*最后需要说明的是参数中min和max的规则可参照命令ZCOUNT。
* @Param: [key, min, max]
* @return: java.util.Set<java.lang.Object>
* @Author: MiZiMi
* @Date: 2020/4/28 18:39
*/
public Set<Object> zRangeByScore(String key, double min, double max) {
if (null == key) {
return null;
}
return redisTemplate.opsForZSet().rangeByScore(key, min, max);
}
/**
* @Description: 该命令除了排序方式是基于从高到低的分数排序之外，其它功能和参数含义均与ZRANGEBYSCORE相同。
* 需要注意的是该命令中的min和max参数的顺序和ZRANGEBYSCORE命令是相反的。
* @Param: [key, min, max]
* @return: java.util.Set<java.lang.Object>
* @Author: MiZiMi
* @Date: 2020/4/28 18:39
*/
public Set<Object> zReverseRangeByScore(String key, double min, double max) {
if (null == key) {
return null;
}
return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
}
}