RedisTemplate实例

旧城等待， 2021-10-18 09:44 388阅读 0赞

@Component
    public class RedisUtils
    {
        /**
         * 日志
         */
        private static final Logger LOGGER = LoggerFactory.getLogger(RedisUtils.class);
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        /**
         * <写入缓存>
         *
         * @param key   key
         * @param value value
         * @return 写入是否成功
         * @throws
         */
        public boolean set(String key, Object value)
        {
            boolean result = false;
            try
            {
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                result = true;
            }
            catch (Exception e)
            {
                LOGGER.error("", e);
            }
            return result;
        }
    
        /**
         * <写入缓存设置时效时间>
         *
         * @param key        key
         * @param value      value
         * @param expireTime expireTime
         * @return 写入是否成功
         * @throws
         */
        public boolean set(String key, Object value, Long expireTime)
        {
            boolean result = false;
            try
            {
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
                result = true;
            }
            catch (Exception e)
            {
                LOGGER.error("", e);
            }
            return result;
        }
    
        /**
         * <获取redis中的所有键值对>
         *
         * @return 结果
         * @throws
         */
        public Map<String, Object> getAll()
        {
            Map<String, Object> key2ValueMap = new HashMap<>();
            Set<String> keys = redisTemplate.keys("*");
            if (!CollectionUtils.isEmpty(keys))
            {
                for (String key : keys)
                {
                    if (this.exists(key))
                    {
                        key2ValueMap.put(key, this.get(key));
                    }
                }
            }
    
            return key2ValueMap;
        }
    
        /**
         * <删除redis中所有内容>
         *
         * @throws
         */
        public void removeAll()
        {
            try
            {
                Set<String> keys = redisTemplate.keys("*");
                redisTemplate.delete(keys);
            }
            catch (Exception e)
            {
                LOGGER.error("remove catch exception. cause: ", e);
                return;
            }
        }
    
        /**
         * <批量删除对应的value>
         *
         * @param keys keys
         * @throws
         */
        public void remove(String... keys)
        {
            for (String key : keys)
            {
                remove(key);
            }
        }
    
        /**
         * <批量删除key>
         *
         * @param pattern pattern
         * @throws
         */
        public void removePattern(String pattern)
        {
            Set<Serializable> keys = redisTemplate.keys(pattern);
            if (keys.size() > 0)
            {
                redisTemplate.delete(keys);
            }
        }
    
        /**
         * <删除对应的value>
         *
         * @param key key
         * @throws
         */
        public void remove(String key)
        {
            if (exists(key))
            {
                redisTemplate.delete(key);
            }
        }
    
        /**
         * <判断缓存中是否有对应的value>
         *
         * @param key key
         * @return 是否存在
         * @throws
         */
        public boolean exists(String key)
        {
            return redisTemplate.hasKey(key);
        }
    
        /**
         * <读取缓存>
         *
         * @param key key
         * @return 结果
         * @throws
         */
        public Object get(String key)
        {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            return operations.get(key);
        }
    
        /**
         * <哈希添加>
         *
         * @param key     key
         * @param hashKey hashKey
         * @param value   value
         * @throws
         */
        public void hmSet(String key, Object hashKey, Object value)
        {
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            hash.put(key, hashKey, value);
        }
    
        /**
         * <哈希获取数据>
         *
         * @param key     key
         * @param hashKey hashKey
         * @return 结果
         * @throws
         */
        public Object hmGet(String key, Object hashKey)
        {
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            return hash.get(key, hashKey);
        }
    
        /**
         * <列表添加>
         *
         * @param k k
         * @param v v
         * @throws
         */
        public void lPush(String k, Object v)
        {
            ListOperations<String, Object> list = redisTemplate.opsForList();
            list.rightPush(k, v);
        }
    
        /**
         * <列表获取>
         *
         * @param k  k
         * @param l  l
         * @param l1 l1
         * @return 结果
         * @throws
         */
        public List<Object> lRange(String k, long l, long l1)
        {
            ListOperations<String, Object> list = redisTemplate.opsForList();
            return list.range(k, l, l1);
        }
    
        /**
         * <集合添加>
         *
         * @param key   key
         * @param value value
         * @throws
         */
        public void add(String key, Object value)
        {
            SetOperations<String, Object> set = redisTemplate.opsForSet();
            set.add(key, value);
        }
    
        /**
         * <集合获取>
         *
         * @param key key
         * @return 结果
         * @throws
         */
        public Set<Object> setMembers(String key)
        {
            SetOperations<String, Object> set = redisTemplate.opsForSet();
            return set.members(key);
        }
    
        /**
         * <有序集合添加>
         *
         * @param key    key
         * @param value  value
         * @param scoure scoure
         * @throws
         */
        public void zAdd(String key, Object value, double scoure)
        {
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            zset.add(key, value, scoure);
        }
    
        /**
         * <有序集合获取>
         *
         * @param key     key
         * @param scoure  scoure
         * @param scoure1 scoure1
         * @return 结果
         * @throws
         */
        public Set<Object> rangeByScore(String key, double scoure, double scoure1)
        {
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            return zset.rangeByScore(key, scoure, scoure1);
        }
    }