Radis的封装方法

一、什么是Redis

Redis是一个开源的基于内存的键值对数据库，它的主要特征和作用包括：

1、基于内存，读写速度极快，可以处理大量读写请求。

2、支持多种数据结构，如字符串、哈希、列表、集合、有序集合等，具有丰富的数据表示能力。 3、支持主从复制，提供数据冗余和故障恢复能力。

4、支持持久化，可以将内存数据保存到磁盘中。

5、支持事务，可以一次执行多个命令。

6、丰富的功能，可用于缓存、消息队列等场景。

主要应用场景包括：

1、缓存常见的使用场景，比如缓存查询结果、热点数据等，大大降低数据库负载。

2、处理大量的读写请求，比如访问统计、消息队列等。

3、排行榜、计数器等功能的实现。

4、pub/sub消息订阅。

5、QUE计划任务

6、分布式锁等。

综上，Redis是一个性能极高的内存数据库，支持丰富数据结构，提供持久化、事务等功能，非常适合缓存、消息队列等场景，被广泛应用于各种大型系统中。它的高性能、丰富功能使其成为非关系型数据库的重要选择之一。

二.Redis的封装方法

@Component
public class RedisUtil {

    /**
     * 如果使用 @Autowired 注解完成自动装配 那么
     * RedisTemplate要么不指定泛型,要么泛型 为<Stirng,String> 或者<Object,Object>
     * 如果你使用其他类型的 比如RedisTemplate<String,Object>
     * 那么请使用 @Resource 注解
     * */
    @Resource
    private RedisTemplate<String,Object> redisTemplate;

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 缓存value
     *
     * @param key -
     * @param value -
     * @param time -
     * @return -
     */
    public boolean cacheValue(String key, Object value, long time) {
        try {
            ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
            valueOperations.set(key, value);
            if (time > 0) {
                // 如果有设置超时时间的话
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Throwable e) {
            logger.error("缓存[" + key + "]失败, value[" + value + "] " + e.getMessage());
        }
        return false;
    }

    /**
     * 缓存value，没有设置超时时间
     *
     * @param key -
     * @param value -
     * @return -
     */
    public boolean cacheValue(String key, Object value) {
        return cacheValue(key, value, -1);
    }

    /**
     * 缓存value
     * @param hkey
     * @param key
     * @param value
     * @return
     */
    public boolean cacheHashValue(String hkey,String key , Object value) {
        redisTemplate.opsForHash().put(hkey, key, value);
        return true;
    }


    /**
     * Cursor是用于对元素集合（例如键或哈希中的成员）进行迭代操作的机制。
     * Cursor主要用于像SCAN这样的命令，允许以增量方式遍历大量数据集，而不会阻塞服务器。
     * @param hkey
     * @return
     */
    public Cursor<Map.Entry<Object, Object>> getHashValue(String hkey){
        return redisTemplate.opsForHash().scan(hkey, ScanOptions.NONE);
    }

    /**
     * 移除
     * @param hkey
     * @param key
     * @return
     */
    public boolean removeHashKey(String hkey,String key){
        try {
            redisTemplate.opsForHash().delete(hkey, key);
            return true;
        } catch (Throwable e) {
            logger.error("移除缓存时失败hkey里的key[" + hkey +key+ "]", "err[" + e.getMessage() + "]");
        }

        return false;
    }


    /**
     * Set缓存数据
     * @param key
     * @param value
     * @return
     */
    public Long cacheSetValue(String key,Object value ){
//        如果 value 成员已经是集合 key 的成员，那么 add 方法不会添加这个成员，返回值为 0。
//        如果 value 成员不是集合 key 的成员，并成功添加到集合中，返回值为 1。
        return redisTemplate.opsForSet().add(key, value);
    }

    /**
     * 获取Set里的值
     * @param key
     * @return
     */
    public Set<Object> getSetValue(String key){
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 移除key里的某个值
     * @param key
     * @param value
     * @return
     */
    public boolean removeSetValue(String key,Object value){
        redisTemplate.opsForSet().remove(key, value);
        return true;
    }
    /**
     * 移除key
     * @param key
     * @param
     * @return
     */
    public boolean removeSetKey(String key){
        redisTemplate.delete(key);
        return true;
    }

    /**
     * sIsMember命令 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sIsMember(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * sInter命令 获取key1与key2的交集
     *
     * @param key1 键
     * @param key2 键
     * @return 交集
     */
    public Set<Object> sinter(String key1, String key2) {
        try {
            return redisTemplate.opsForSet().intersect(key1, key2);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }







    /**
     * 判断缓存是否存在
     *
     * @param key
     * @return
     */
    public boolean containsKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Throwable e) {
            logger.error("判断缓存是否存在时失败key[" + key + "]", "err[" + e.getMessage() + "]");
        }
        return false;
    }

    /**
     * 根据key，获取缓存
     *
     * @param key -
     * @return -
     */
    public Object getValue(String key) {
        try {
            ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
            return valueOperations.get(key);
        } catch (Throwable e) {
            logger.error("获取缓存时失败key[" + key + "]", "err[" + e.getMessage() + "]");
        }
        return null;
    }

    /**
     * 移除缓存
     *
     * @param key -
     * @return -
     */
    public boolean removeValue(String key) {
        try {
            redisTemplate.delete(key);
            return true;
        } catch (Throwable e) {
            logger.error("移除缓存时失败key[" + key + "]", "err[" + e.getMessage() + "]");
        }
        return false;
    }

    /**
     * 根据前缀移除所有以传入前缀开头的key-value
     *
     * @param pattern -
     * @return -
     */
    public boolean removeKeys(String pattern) {
        try {
            Set<String> keySet = redisTemplate.keys(pattern + "*");
            redisTemplate.delete(keySet);
            return true;
        } catch (Throwable e) {
            logger.error("移除key[" + pattern + "]前缀的缓存时失败", "err[" + e.getMessage() + "]");
        }
        return false;
    }

}