您的当前位置：首页正文

springboot整合使用redis工具类

来源：欧得旅游网

springboot整合使用redis工具类

引入依赖

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>

配置redis

yml文件配置redis连接相关内容

spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    timeout: 30000
    jedis:
      pool:
        max-active: 20
        max-idle: 10
        min-idle: 5

config文件配置

@Configuration
public class RedisConfig {

    /**
     * 自定义 RedisTemplate 对象
     *
     * @param redisConnectionFactory redis连接
     * @return RedisTemplate
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        template.setConnectionFactory(redisConnectionFactory);
        //自定义Jackson序列化配置
        Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jsonRedisSerializer.setObjectMapper(objectMapper);

        //key使用String的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也是用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value的key使用jackson的序列化方式
        template.setValueSerializer(jsonRedisSerializer);
        //hash的value也是用jackson的序列化方式
        template.setHashValueSerializer(jsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 注入封装RedisTemplate 给RedisUtil提供操作类
     *
     * @param redisTemplate 模板
     * @return 工具类
     */
    @Bean(name = "redisUtil")
    public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
        RedisUtil redisUtil = new RedisUtil();
        redisUtil.setRedisTemplate(redisTemplate);
        return redisUtil;
    }
}

redis工具类

public class RedisUtil {

    private RedisTemplate<String, Object> redisTemplate;

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * [common] 指定key有效时长(s)
     *
     * @param key  键
     * @param time 时间(秒)
     * @return 成功与否
     */
    public Boolean expire(String key, long time) {
        if (time > 0) {
            return redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
        return Boolean.TRUE;
    }

    /**
     * [common] 获取key剩余过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) -2：key不存在，-1：永久有效，没有过期时间
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * [common] 验证对应key是否存在
     *
     * @param key 键
     * @return 存在与否
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * [common] 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public void delete(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(Arrays.asList(key));
            }
        }
    }

    /**
     * [common] 修改key名称
     *
     * @param oldKey 旧名称
     * @param newKey 新名称
     */
    public void rename(String oldKey, String newKey) {
        redisTemplate.rename(oldKey, newKey);
    }

    /**
     * [STRING] 缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object getStr(String key) {
        return key == null ? null : (String) redisTemplate.opsForValue().get(key);
    }

    /**
     * [String] 存入缓存
     *
     * @param key   键
     * @param value 值
     */
    public void setStr(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * [STRING] 存入缓存并设置超时时长
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 不设置过期时间
     */
    public void setStr(String key, String value, long time) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            setStr(key, value);
        }
    }

    /**
     * [STRING] 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return 操作后结果值
     */
    public Long incrStr(String key, long delta) {
        // Incr 命令将 key 中储存的数字值增一,key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * [STRING] 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return 操作后结果
     */
    public Long decrStr(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * [STRING] 判断添加key及value，如果key存则返回false无效操作，否则添加并返回true
     *
     * @param key   键
     * @param value 值
     * @return 成功与否
     */
    public Boolean setIfAbsentStr(String key, String value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     * [LIST] 获取list缓存的内容
     *
     * @param key   键
     * @param start 起始位
     * @param end   结束位 -1时为最后一个元素位置，（0，-1）返回所有
     * @return 返回结果
     */
    public List<Object> getList(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * [LIST] 获key list所有数据
     *
     * @param key 键
     * @return 结果
     */
    public List<Object> getListAll(String key) {
        return getList(key, 0, -1);
    }

    /**
     * [LIST] 获取list的长度size值
     *
     * @param key 键
     * @return size值
     */
    public Long getListSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

    /**
     * [LIST] 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引
     * @return 结果,  超出索引范围返回null
     */
    public Object lGetByIndex(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }

    /**
     * [LIST] 设置指定索引处指定key的value(覆盖旧值)
     * 若索引值超出范围，异常
     *
     * @param key   键
     * @param value 值
     * @param index 索引位置
     */
    public void lSetByIndex(String key, String value, long index) {
        redisTemplate.opsForList().set(key, index, value);
    }

    /**
     * [LIST] 向指定list的队列头部添加value
     *
     * @param key   键
     * @param value 值，可多个
     * @return 插入数
     */
    public Long leftPushList(String key, String... value) {
        return redisTemplate.opsForList().leftPushAll(key, value);
    }

    /**
     * [LIST] 向指定list的队列尾部添加value
     *
     * @param key   键
     * @param value 值，可多个
     * @return 插入数
     */
    public Long rightPushList(String key, String... value) {
        return redisTemplate.opsForList().rightPushAll(key, value);
    }

    /**
     * [LIST] 移除并返回列表中存储在key处的第一个元素
     *
     * @param key 键
     * @return 结果值
     */
    public Object leftPopList(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    /**
     * [LIST] 删除并返回列表中存储在key处的最后一个元素
     *
     * @param key 键
     * @return 结果值
     */
    public Object rightPopList(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    /**
     * [LIST] 修剪列表的关键元素之间的开始和结束,包含结束位
     *
     * @param key   键
     * @param start 起始
     * @param end   结束
     */
    public void trimList(String key, long start, long end) {
        redisTemplate.opsForList().trim(key, start, end);
    }

    /**
     * [LIST] 删除指定key集合中值等于value的元素
     *
     * @param key   键
     * @param count count=0, 删除所有值等于value的元素
     *              count>0, 从头部开始删除指定数的值等于value的元素
     *              count<0, 从尾部开始删除指定数的值等于value的元素
     * @param value 删除值
     */
    public void lRemove(String key, long count, String value) {
        redisTemplate.opsForList().remove(key, count, value);
    }

    /**
     * [SET] 向指定key(set)中添加元素
     *
     * @param key   键
     * @param value 值，可多个
     * @return 成功数
     */
    public Long addSet(String key, String... value) {
        return redisTemplate.opsForSet().add(key, value);
    }

    /**
     * [SET] 获取指定(key)集合中的所有元素
     *
     * @param key 键
     * @return 结果
     */
    public Set<Object> getSet(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * [SET] 判断指定set集合是否包含value(包含返回true,不包含返回false)
     *
     * @param key   键
     * @param value 值
     * @return 包含与否
     */
    public Boolean isSetMember(String key, String value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * [SET] 获取指定key(集合)的元素个数
     *
     * @param key 键
     * @return set size值
     */
    public Long getSetSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    /**
     * [SET] 移除指定key(set)的元素(单个、多个)
     *
     * @param key   键
     * @param value 移除值
     * @return 移除数
     */
    public Long removeSet(String key, String... value) {
        return redisTemplate.opsForSet().remove(key, value);
    }

    /**
     * [SET] 从set key获取计数随机元素。
     *
     * @param key   键
     * @param count 个数
     * @return 结果
     */
    public List<Object> randomSetMembers(String key, long count) {
        return redisTemplate.opsForSet().randomMembers(key, count);
    }

    /**
     * [ZSET] 在key处为一个排序的集合添加值，如果它已经存在，则更新它的分数
     * 有序集合是按照元素的score值由小到大进行排列
     *
     * @param key   键
     * @param value 值
     * @param score 分数
     * @return 成功与否
     */
    public Boolean addZSet(String key, String value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * [ZSET] 删除指定key对应的value
     *
     * @param key   键
     * @param value value可以为多个值
     * @return 删除数
     */
    public Long removeZSet(String key, String... value) {
        return redisTemplate.opsForZSet().remove(key, value);
    }

    /**
     * [ZSET] 增加指定key(zset)元素value的score值，并返回增加后的值
     *
     * @param key   键
     * @param value 值
     * @param delta 改变值
     * @return 改变后的值
     */
    public Double incrementZSetScore(String key, String value, double delta) {
        return redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    /**
     * [ZSET] 获取指定key(zset)元素在集合的排名
     * score由小到大显示
     *
     * @param key   键
     * @param value 值
     * @return 排名下标
     */
    public Long rankZSet(String key, String value) {
        return redisTemplate.opsForZSet().rank(key, value);
    }

    /**
     * [ZSET] 获取指定集合中给定范围的元素
     * score由小到大显示
     *
     * @param key   键
     * @param start 起始位
     * @param end   结束位
     * @return 结果集
     */
    public Set<Object> rangeZSet(String key, long start, long end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }

    /**
     * [ZSET] 获取指定zset的大小
     *
     * @param key 键
     * @return size
     */
    public Long getZSetSize(String key) {
        return redisTemplate.opsForZSet().size(key);
    }

    /**
     * [ZSET] 获取集合中key、value元素对应的score值
     *
     * @param key   键
     * @param value 值
     * @return score值
     */
    public Double getZSetScore(String key, String value) {
        return redisTemplate.opsForZSet().score(key, value);
    }

    /**
     * [HASH] 获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null
     *
     * @param key     键
     * @param hashKey map键
     * @return 结果
     */
    public Object getHashValue(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * [HASH] 单个添加key-value
     *
     * @param key     键
     * @param hashKey map键
     * @param value   结果
     */
    public void putHashValue(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * [HASH] 批量添加key-value
     *
     * @param key 键
     * @param map map
     */
    public void putHashAll(String key, Map<String, Object> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * [HASH] 仅当hashKey不存在时才添加
     *
     * @param key     键
     * @param hashKey map键
     * @param value   值
     * @return 新增成功与否
     */
    public Boolean putHashIfAbsent(String key, String hashKey, Object value) {
        return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
    }

    /**
     * [HASH] 获取变量中的键值对
     *
     * @param key 键
     * @return map
     */
    public Map<Object, Object> entriesHash(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * [HASH] 删除指定hash中一个或者多个键
     *
     * @param key      键
     * @param hashKeys map 键，可多个
     * @return 删除数
     */
    public Long deleteHash(String key, String... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * [HASH] 验证指定key map中是否存在对hashKey
     *
     * @param key     键
     * @param hashKey map键
     * @return 存在与否
     */
    public Boolean hasKeyHash(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * [HASH] 获取指定map所有的键
     *
     * @param key 键
     * @return keys
     */
    public Set<Object> getHashKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    /**
     * [HASH] 获取map中所有的值
     *
     * @param key 键
     * @return values
     */
    public List<Object> getHashValues(String key) {
        return redisTemplate.opsForHash().values(key);
    }

    /**
     * [HASH] 获取map的size
     *
     * @param key 键
     * @return size
     */
    public Long getHashSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }
}