Redis - Redis 工具类 - 《Java 开发常用代码》

RedisCommonUtil

/**
 * RedisCommon 工具类
 */
@Component
public class RedisCommonUtil {
    @Autowired
    protected RedisTemplate<String, Object> redisTemplate;
    /**
     * 指定缓存失效时间（expire key seconds）
     *
     * @param key     建
     * @param timeout 失效时间（单位：秒，小于等于0 表示 永久有效）
     */
    public void expire(String key, long timeout) {
        try {
            if (timeout > 0) {
                redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
            }
        } catch (Exception e) {
            throw new RuntimeException("指定缓存失效时间 异常：", e);
        }
    }
    /**
     * 取 key键 的失效时间（ttl key）
     *
     * @param key 键
     * @return 失效时间（单位：秒）
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
    /**
     * 判断 key键 是否存在（exists key）
     *
     * @param key 键
     * @return 存在：true；不存在：false
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 删除key键数组的缓存（del key）
     *
     * @param keys 要删除缓存的key键 数组
     */
    public void del(String... keys) {
        if(null != keys && keys.length > 0){
            redisTemplate.delete(CollectionUtils.arrayToList(keys));
        }
    }
    /**
     * 按照 key值前缀 批量删除 缓存
     *
     * @param prex key值前缀
     */
    public void delByPrex(String prex) {
        Set<String> keys = redisTemplate.keys(prex);
        if (!CollectionUtils.isEmpty(keys)) {
            redisTemplate.delete(keys);
        }
    }
}

RedisStringUtil

/**
 * Redis String操作工具类
 */
@Component
public class RedisStringUtil extends RedisCommonUtil {
    /**
     * 获取key键对应的值（GET key）
     * @param key 键
     * @return
     */
    public Object get(String key){
        if(null == key)
            return null;
        return redisTemplate.opsForValue().get(key);
    }
    /**
     * 新增一个字符串类型的值,key是键，value是值（SET key value）
     * @param key 键
     * @param value 值
     */
    public void set(String key, Object value){
        try{
            redisTemplate.opsForValue().set(key, value);
        } catch (Exception e){
            throw new RuntimeException("放入缓存 异常：", e);
        }
    }
    /**
     * 放入缓存并设置失效时间（setex key seconds value）
     * @param key 键
     * @param value 值
     * @param timeout 失效时间（单位：秒，小于等于0 表示 永久有效）
     */
    public void set(String key, Object value, long timeout){
        set(key, value);
        expire(key, timeout);
    }
    /**
     * 在原有的值基础上新增字符串到末尾（append key value）
     * @param key 键
     * @param value 新增的字符串
     */
    public void append(String key, String value){
        redisTemplate.opsForValue().append(key, value);
    }
    /**
     * 截取key键对应值得字符串，从开始下标位置到结束下标位置(包含)的字符串（getrange key start end）
     * @param key 键
     * @param start 开始下标位置
     * @param end 结束下标的位置
     * @return 从开始下标位置到结束下标位置(包含)的字符串
     */
    public String get(String key, long start, long end){
        return redisTemplate.opsForValue().get(key, start, end);
    }
    /**
     * 获取原来key键对应的值并重新赋新值（getset key value）
     * @param key 键
     * @param value 新值
     * @return 旧值（原来key键对应的值）
     */
    public Object getAndSet(String key, Object value){
        return redisTemplate.opsForValue().getAndSet(key, value);
    }
    /**
     * 获取指定key键对应值的长度（strlen key）
     * @param key 键
     * @return 返回对应值的长度
     */
    public long size(String key){
        return redisTemplate.opsForValue().size(key);
    }
    /**
     * 将存储在key键上的数字按指定的值 增加（incrby key number）
     * @param key 键
     * @param delta 指定的增加数字
     * @return 返回增加后的值（key键不存在，则在执行操作之前将其设置为0）
     */
    public long incrby(String key, long delta){
        return redisTemplate.opsForValue().increment(key, delta);
    }
    /**
     * 将存储在key键上的数字按指定的值 减少（incrby key number）
     * @param key 键
     * @param delta 指定的减少数字
     * @return 返回减少后的值（key键不存在，则在执行操作之前将其设置为0）
     */
    public long decrby(String key, long delta){
        return redisTemplate.opsForValue().increment(key, -delta);
    }
    /**
     * 如果键不存在则新增,存在则不改变已经有的值（setnx key value）
     * @param key 键
     * @param value 值
     * @return key键不存在，返回ture；存在返回false
     */
    public boolean setIfAbsent(String key, Object value){
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }
    /**
     * 一次多个键设置它们的值（mset key1 value1 key2 value2 ..）
     * @param keyValueMap key为键，value为值
     */
    public void multiSet(Map<String, Object> keyValueMap){
        redisTemplate.opsForValue().multiSet(keyValueMap);
    }
    /**
     * 根据键数组取出对应的value值（mget key1 key2 ..）
     * @param keys 键数组
     * @return
     */
    public List<?> multiGet(String ...keys){
        return redisTemplate.opsForValue().multiGet(CollectionUtils.arrayToList(keys));
    }
}

RedisListUtil

@Component
public class RedisListUtil<T> extends RedisCommonUtil {
    /**
     * 根据 索引获取 list缓存值
     *
     * @param key   键
     * @param start 开始索引（下标从0开始）
     * @param end   偏移量（-1，则遍历全部数据）
     * @return
     */
    public List<T> range(String key, long start, long end) {
        return (List<T>) redisTemplate.opsForList().range(key, start, end);
    }
    /**
     * 获取 List缓存的长度
     *
     * @param key 键
     * @return
     */
    public long size(String key) {
        return redisTemplate.opsForList().size(key);
    }
    /**
     * 获取 key键 对应集合中 index索引的值
     *
     * @param key   键
     * @param index 索引
     * @return key键 对应集合中 index索引的值
     */
    public T index(String key, long index) {
        return (T) redisTemplate.opsForList().index(key, index);
    }
    /**
     * 将 value值放入 key对应的List集合 尾部
     *
     * @param key   键
     * @param value 值
     */
    public void rightPush(String key, Object value) {
        redisTemplate.opsForList().rightPush(key, value);
    }
    /**
     * 将 value值数组放入 key对应的List集合 尾部
     *
     * @param key    键
     * @param values 值数组
     */
    public void rightPush(String key, T... values) {
        redisTemplate.opsForList().rightPushAll(key, values);
    }
    /**
     * 将 value值放入 key对应的List集合 头部
     *
     * @param key   键
     * @param value 值
     */
    public void leftPush(String key, T value) {
        redisTemplate.opsForList().leftPush(key, value);
    }
    /**
     * 将 value值数组放入 key对应的List集合 头部
     *
     * @param key    键
     * @param values 值数组
     */
    public void leftPush(String key, T... values) {
        redisTemplate.opsForList().leftPushAll(key, values);
    }
    /**
     * 修改 key键对应的List集合中 索引为index的值
     *
     * @param key   键
     * @param index 索引
     * @param value 要更改的值
     */
    public void setIndex(String key, long index, T value) {
        redisTemplate.opsForList().set(key, index, value);
    }
}

RedisHashUtil

@Component
public class RedisHashUtil<HK, HV> extends RedisCommonUtil {
    /**
     * 将hash表中放入数据,如果不存在将创建（hset key item value）
     *
     * @param key   redis key
     * @param item  hash key
     * @param value hash value
     */
    public void hset(String key, HK item, HV value) {
        redisTemplate.opsForHash().put(key, item, value);
    }
    /**
     * 将hash表中放入数据,如果不存在将创建，设置失效时间（hset key item value；expire key timeout）
     * <pre>
     *     失效时间说明：
     *      1、设置的失效时间是针对整个 redis key，并非是只能 当前的 hash key；
     *      2、如果已存在的 hash表有时间，这里将会替换原有的时间
     * </pre>
     *
     * @param key     redis key
     * @param item    hash key
     * @param value   hash value
     * @param timeout 失效时间（单位：秒，小于等于0 表示 永久有效）
     */
    public void hset(String key, HK item, HV value, long timeout) {
        redisTemplate.opsForHash().put(key, item, value);
        // 设置 key 失效时间
        expire(key, timeout);
    }
    /**
     * 将 map 表中放入数据,如果不存在将创建（hmset key item1 value1 item2 value2 item3 value3 ...）
     *
     * @param key  redis key
     * @param hash map 表中放入数据
     */
    public void hmSet(String key, Map<HK, HV> hash) {
        redisTemplate.opsForHash().putAll(key, hash);
    }
    /**
     * 将 map 表中放入数据,如果不存在将创建，设置失效时间（hmset key item1 value1 item2 value2 item3 value3 ...；expire key timeout）
     *
     * @param key     redis key
     * @param hash    map 表中放入数据
     * @param timeout 失效时间（单位：秒，小于等于0 表示 永久有效）
     */
    public void hmSet(String key, Map<HK, HV> hash, long timeout) {
        redisTemplate.opsForHash().putAll(key, hash);
        // 设置 key 失效时间
        expire(key, timeout);
    }
    /**
     * 判断是否存在 hash item（hexists key item）
     *
     * @param key  redis key
     * @param item hash item
     * @return 存在返回true，不存在返回 false
     */
    public boolean hasKey(String key, HK item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }
    /**
     * 获取 hash item 对应的 value（hget key num）
     *
     * @param key  redis key
     * @param item hash item
     * @return item 对应的 value
     */
    public HV hget(String key, HK item) {
        return (HV) redisTemplate.opsForHash().get(key, item);
    }
    /**
     * 获取 key 对应的 hash 数据（hgetall key）
     *
     * @param key redis key
     * @return 对应的 hash 数据
     */
    public Map<HK, HV> hmGet(String key) {
        return (Map<HK, HV>) redisTemplate.opsForHash().entries(key);
    }
    /**
     * 删除 hash item 对应的项（hdel key item）
     *
     * @param key  redis key
     * @param item hash item
     * @return 返回删除个数
     */
    public long hdel(String key, HK... item) {
        if (null != item && item.length > 0) {
            return redisTemplate.opsForHash().delete(key, item);
        }
        return 0;
    }
    /**
     * 递增，如果不存在,就会创建一个 并把新增后的值返回（hincrby key item by）
     *
     * @param key  redis key
     * @param item hash item
     * @param by   递增量
     * @return 自增后的数量
     */
    public long hincr(String key, HK item, long by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }
    /**
     * 递减，如果不存在,就会创建一个 并把递减后的值返回（hincrby key item by）
     *
     * @param key  redis key
     * @param item hash item
     * @param by   递减量
     * @return 递减后的数量
     */
    public long hdecr(String key, HK item, long by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }
    /**
     * 获取 key 对应的 hash item 集合（hkeys key）
     *
     * @param key redis key
     * @return hash item 集合
     */
    public Set<HK> hItemKeys(String key) {
        return (Set<HK>) redisTemplate.opsForHash().keys(key);
    }
    /**
     * 获取 key 对应的 hash value 集合（hvals key）
     *
     * @param key redis key
     * @return hash value 集合
     */
    public List<HV> hItemValues(String key) {
        return (List<HV>) redisTemplate.opsForHash().values(key);
    }
    /**
     * 获取 key 对应的 hash 中元素个数（hlen key）
     *
     * @param key
     * @return hash 中元素个数
     */
    public long hSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }
}

RedisSetUtil

@Component
public class RedisSetUtil<T> extends RedisCommonUtil {
    /**
     * 获取 key键 对应的 Set集合
     * @param key 键
     * @return key键 对应的 Set集合
     */
    public Set<T> members(String key){
        return (Set<T>) redisTemplate.opsForSet().members(key);
    }
    /**
     * 查找 key键 对应的Set集合中 是否包含value值
     * @param key 键
     * @param value 值
     * @return 包含：true；不包含：false
     */
    public boolean isMember(String key, Object value){
        return redisTemplate.opsForSet().isMember(key, value);
    }
    /**
     * 将数据放在 Set缓存
     * @param key 键
     * @param values 值数组
     * @return 成功个数
     */
    public long addSet(String key, Object ...values){
        return redisTemplate.opsForSet().add(key, values);
    }
    /**
     * 将数据放在 Set缓存，并设置 失效时间
     * @param key 键
     * @param values 值数组
     * @param timeout 失效时间（单位：秒，小于等于0 表示 永久有效）
     * @return
     */
    public long addSet(String key, T []values, long timeout){
        long count = redisTemplate.opsForSet().add(key, values);
        expire(key, timeout);
        return count;
    }
    /**
     * 获取 key键 对应的Set集合的长度
     * @param key 键
     * @return
     */
    public long size(String key){
        return redisTemplate.opsForSet().size(key);
    }
    /**
     * 移除 key键 对应的Set集合中 value数组
     * @param key 键
     * @param values 要移除的值数组
     * @return 移除成功的个数
     */
    public long remove(String key, T ...values){
        return redisTemplate.opsForSet().remove(key, values);
    }
}