redisTemplate.opsForValue()【redis普通缓存类型使用配置】

dreaming9420

已于 2022-04-14 19:34:23 修改

阅读量5.5k

点赞数 1

于 2021-12-01 21:24:17 首次发布

本文链接：https://blog.youkuaiyun.com/dreaming9420/article/details/121664808

版权

redis 专栏收录该内容

9 篇文章

订阅专栏

set(String key, Object value)

	/**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

set(String key, Object value, long time)

	/**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) 如果 time 小于等于0将设置无限期
     * @return true 成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

setIfAbsent(String key, Object value)

	/**
     * 如果该 key 已经存在，则不改变其值，不存在则将该 key 放入缓存
     *
     * @param key   键
     * @param value 值
     * @return 如果该 key 存在就返回 false,如果该 key不存在就返回 ture
     */
    public boolean setIfAbsent(String key, Object value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

setIfAbsentExpire(String key, Object value, long expire)

	/**
     * 如果该 key 已经存在，则不改变其值，不存在则将该 key 放入缓存并设置过期时间
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间
     * @return 如果该 key 存在就返回 false,如果该 key不存在就返回 ture
     */
    public boolean setIfAbsentExpire(String key, Object value, long expire) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, expire, TimeUnit.SECONDS);
    }

get(String key)

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

hasKey(String key)

 	/**
     * 判断 key 是否存在
     *
     * @param key 键
     * @return true 存在 false 不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

expire(String key, long time)

	/**
     * 设置缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return 是否设置成功, 如果该 key 不存在，不会自动将该 key 放入缓存，但仍然返回 true
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

getExpire(String key)

 	/**
     * 根据 key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回-1为永久有效,-2表示不存在该 key
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

delete(String… key)

	/**
     * 删除 key
     *
     * @param key 键
     * @return 被删除的 key 的数量,不包括本来就不存在的 key
     */
    public Long delete(String... key) {
        if (key == null || key.length < 1) {
            return 0L;
        }
        return redisTemplate.delete(Arrays.asList(key));
    }

incr(String key, long delta)

	 /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几
     * @return 增加后的 key 的值
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

decr(String key, long delta)

	/**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几
     * @return 减少后的 key 的值
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

Set keys

	/**
     * 获取所有的 key
     *
     * @return 所有的 key
     */
    public Set<String> keys() {
        return redisTemplate.keys("*");
    }

type(String key)

 	/**
     * 获取 Key 的类型
     *
     * @param key 键
     * @return Key 的类型
     */
    public String type(String key) {
        DataType dataType = redisTemplate.type(key);
        assert dataType != null;
        return dataType.code();
    }