Redis中常用的两个操作工具类

我不是女神ヾ 2022-05-23 07:08 191阅读 0赞

Redis是时下最流行的NoSql数据库，可以用来作为数据库，消息中间件，缓存。而使用最广泛的还是用Redis做缓存。日常学习的话最好在本地安装Redis服务器，不会安装的小伙伴请参考这篇博客：[Windows下搭建Redis服务器][Windows_Redis]。

这两个工具类是现在的项目中用到的，已经封装好了，因为是通用的，所以贴出来跟大家分享一下。

## 1.CacheFetchUtils增强工具类 ##

package com.csdn.myboot.utils;
    
    import com.alibaba.fastjson.JSON;
    import org.apache.commons.collections4.CollectionUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import java.util.Date;
    import java.util.List;
    import java.util.function.Supplier;
    
    /**
     * @author haozz
     * @date 2018/5/29 15:29
     * @description
     */
    public class CacheFetchUtils {
        private static final Logger logger= LoggerFactory.getLogger(CacheFetchUtils.class);
    
        public CacheFetchUtils() {
        }
    
        public static <T> T fromRedis(RedisOperations redisOperations, String redisKey, Class<T> clazz, Supplier<T> dbFunc, Object... object) {
            T result = redisOperations.getVal(redisKey, clazz);
            if(result == null) {
                result = dbFunc.get();
                if(result == null) {
                    logger.error("fetch " + clazz + " error, redisKey: " + redisKey);
                    return null;
                }
                valSerialize(redisOperations,redisKey,result,object);
            }
            return result;
        }
    
        public static <T> List<T> fromRedisList(RedisOperations redisOperations, String redisKey, Class<T> clazz, Supplier<List> dbFunc,Object... object) {
            List<T> result = JSON.parseArray(redisOperations.getVal(redisKey),clazz);
            if(CollectionUtils.isEmpty(result)) {
                result = dbFunc.get();
                if(result == null) {
                    logger.error("fetch " + clazz + " error, redisKey: " + redisKey);
                    return null;
                }
                valSerialize(redisOperations,redisKey,result,object);
            }
            return result;
        }
    
        private static void valSerialize(RedisOperations redisOperations,String redisKey, Object result,Object... object){
            Object[] objects= object;
            if(objects!=null && objects.length>0){
                Object obj= objects[0];
                if(obj instanceof Date){
                    redisOperations.putValExpireAt(redisKey, result, (Date) obj);
                }else {
                    Long expireTime= Long.valueOf(obj.toString());
                    if(expireTime==0){
                        return;
                    }
                    redisOperations.putVal(redisKey, result,expireTime);
                }
            }else{
                redisOperations.putVal(redisKey, result);
            }
        }
    }

这个类中引入了日志类Logger，包含一个无参的构造方法，以及三个方法。需要注意的是，其中用到RedisOperation类是下面这个封装好好的工具类，而不是org.springframework.data.redis.core.RedisOperations这个源码类。在后面的文章中我们会对其余方法做详细的解释。欢迎查看：[SpringBoot整合Redis之进阶篇][SpringBoot_Redis]。

### 2.RedisOperations工具类： ###

package com.csdn.myboot.utils;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.parser.Feature;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import org.apache.commons.compress.utils.CharsetNames;
    import org.apache.poi.ss.formula.functions.T;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.dao.DataAccessException;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.core.BoundHashOperations;
    import org.springframework.data.redis.core.BoundValueOperations;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.StringRedisTemplate;
    
    import java.io.UnsupportedEncodingException;
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    /**
     * @author haozz
     * @date 2018/5/29 15:29
     * @description
     */
    public class RedisOperations {
    
        private Logger logger = LoggerFactory.getLogger(RedisOperations.class);
    
        private final StringRedisTemplate redisTemplate;
    
        public RedisOperations(StringRedisTemplate redisTemplate) {
            this.redisTemplate = redisTemplate;
        }
    
        private BoundValueOperations<String, String> boundOptions(String key) {
            return this.redisTemplate.boundValueOps(key);
        }
    
        public <T> List<T> getMultiVal(String keyPattern, Class<T> clazz) {
            return this.getMultiVal(this.keySet(keyPattern), clazz);
        }
    
        public <T> List<T> getMultiVal(Collection<String> keys, Class<T> clazz) {
            ArrayList result = new ArrayList();
            if (null != keys && !keys.isEmpty()) {
                byte[][] rawKeys = new byte[keys.size()][];
                int counter = 0;
    
                String key;
                for (Iterator rawValues = keys.iterator(); rawValues.hasNext(); rawKeys[counter++] = key.getBytes()) {
                    key = (String) rawValues.next();
                }
                List var9 = this.redisTemplate.execute((connection) ->
                {
                    return connection.mGet(rawKeys);
                }, true);
                Iterator var10 = var9.iterator();
    
                while (var10.hasNext()) {
                    byte[] bytes = (byte[]) var10.next();
                    if(bytes!=null && bytes.length>0){
                        if(clazz==String.class){
                            try {
                                result.add(new String(bytes,CharsetNames.UTF_8));
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }else {
                            result.add(JSON.parseObject(bytes, clazz));
                        }
                    }
                }
                return result;
            }
            else {
                return result;
            }
        }
    
        public <V> void putVal(String key, V value, long expireSeconds) {
            BoundValueOperations operation = this.boundOptions(key);
            if (operation != null) {
                operation.set(JSON.toJSONString(value, new SerializerFeature[0]));
                operation.expire(expireSeconds, TimeUnit.SECONDS);
            }
        }
    
        public <V> void putVal(String key, V value) {
            this.boundOptions(key).set(JSON.toJSONString(value));
        }
    
        public <V> void putValExpireAt(String key, V value, Date date) {
            BoundValueOperations operation = this.boundOptions(key);
            if (operation != null) {
                operation.set(JSON.toJSONString(value, new SerializerFeature[0]));
                operation.expireAt(date);
            }
        }
    
        public <T> T getVal(String key, Class<T> clazz) {
            return this.redisTemplate.execute((connection) ->
            {
                byte[] bytes = connection.get(key.getBytes());
                return null != bytes ? JSON.parseObject(bytes, clazz, new Feature[0]) : null;
            }, true);
        }
    
        public String getVal(String key) {
            return this.redisTemplate.execute((connection) ->
            {
                byte[] bytes = connection.get(key.getBytes());
                try {
                    return null != bytes ? new String(bytes, CharsetNames.UTF_8) : null;
                }
                catch (UnsupportedEncodingException e) {
                    logger.error("UnsupportedEncodingException:{}" + e);
                }
                return null;
            }, true);
        }
    
        public Set<String> allKeys(String key){
            Set<String> set = keySet(key + ":*");
            set.add(key);
            return set;
        }
    
        public Set<String> keySet(String pattern) {
            try {
                return this.redisTemplate.keys(pattern);
            }
            catch (Exception var3) {
                throw new RuntimeException("redis service error: {}", var3);
            }
        }
    
        public boolean addKeyExpire(String key, long delta) {
            Long newExpire = this.redisTemplate.getExpire(key, TimeUnit.SECONDS);
            return this.redisTemplate.expire(key, newExpire.longValue() + delta, TimeUnit.SECONDS).booleanValue();
        }
    
        public void clearKey(String... keys) {
            this.clearKey(Arrays.asList(keys));
        }
    
        public void clearKey(Collection<String> keys) {
            try {
                this.redisTemplate.delete(keys);
            }
            catch (Exception var3) {
                throw new RuntimeException("redis service error: {}", var3);
            }
        }
    
        public void clearKeyPattern(String key) {
            Set<String> set = keySet(key + ":*");
            set.add(key);
            this.clearKey(set);
        }
    
        public T get(String tableName, String key, Class<T> clazz) {
            try {
                return JSON.parseObject(hashOps(tableName).get(key).toString(), clazz);
            }
            catch (Exception e) {
                logger.error("get{}:{} error.", tableName, key, e);
            }
            return null;
        }
    
        public void put(String tableName, String key, Object value) {
            try {
                hashOps(tableName).put(key, value);
            }
            catch (Exception e) {
                logger.error("put{}:{}:{} error.", tableName, key, value, e);
            }
        }
    
        private BoundHashOperations hashOps(String tableName) {
            return redisTemplate.boundHashOps(tableName);
        }
    
        public StringRedisTemplate getRedisTemplate() {
            return redisTemplate;
        }
    
        public Object memory() {
    
            return redisTemplate.execute(new RedisCallback()
            {
                @Override
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
    //        connection.bgSave(); // 生成快照
                    return connection.info("memory");
                }
            });
        }
    
        /**
         * 存储REDIS队列 顺序存储
         * channel：对列的名称
         * message：消息内容
         * return:消息的存放位置（list中的位置）
         */
        public Long leftPush(String channel, Message message) {
            return redisTemplate.opsForList().leftPush(channel, JSON.toJSONString(message));
        }
    
        /**
         * 存储REDIS队列 顺序存储
         * channel：对列的名称
         * message：消息内容
         * return:消息的内容
         * 弹出最左边的元素，弹出之后该值在列表中将不复存在
         */
        public Message leftPop(String channel) {
            String message = redisTemplate.opsForList().rightPop(channel);
            if (StringUtils.isEmpty(message)) {
                return null;
            }
            Message parseObject = JSON.parseObject(message, Message.class);
            return parseObject;
        }
    
        /**
         * @param channel
         * @return 查看队列中的数据
         * @since 2018年1月12日
         * @see
         */
        public List<String> rangeList(String channel) {
            return redisTemplate.opsForList().range(channel, 0, -1);
    
        }
    
        public Long listSize(String channel) {
            return redisTemplate.opsForList().size(channel);
    
        }
    
    }

在这个类中有注入了StringRedisTemplate类，对于redis的操作基本都是这个类完成的。leftPush、leftPop方法是用于Redis消息队列的，这里可以将其注掉，其余方法在后面的文章中会做详细的解释。欢迎查看：[SpringBoot整合Redis之进阶篇][SpringBoot_Redis]。

[Windows_Redis]: https://blog.csdn.net/e62ces0iem/article/details/73477182
[SpringBoot_Redis]: https://blog.csdn.net/hz_940611/article/details/80848050