使用redisTemplete简单封装的一个通用操作类

清疚 2022-06-13 10:13 166阅读 0赞

import org.springframework.dao.DataAccessException;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.RedisSerializer;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Set;
    
    /** * Redis操作类 */ public class RedisManager {
        /** * 过期时间，默认30分钟 */ private Long expireTime = 1000 * 60 * 30L;
    
        /** * Redis模版 */ private RedisTemplate<Serializable, Serializable> redisTemplate;
    
        public void setRedisTemplate(RedisTemplate<Serializable, Serializable> redisTemplate) {
            this.redisTemplate = redisTemplate;
        }
    
        public void setExpireTime(long expireTime) {
            this.expireTime = expireTime;
        }
    
        private RedisSerializer<Object> getKeySerializer() {
            return (RedisSerializer<Object>) redisTemplate.getKeySerializer();
        }
    
        private RedisSerializer<Object> getValueSerializer() {
            return (RedisSerializer<Object>) redisTemplate.getValueSerializer();
        }
    
        private RedisSerializer<Object> getHashKeySerializer() {
            return (RedisSerializer<Object>) redisTemplate.getHashKeySerializer();
        }
    
        private RedisSerializer<Object> getHashValueSerializer() {
            return (RedisSerializer<Object>) redisTemplate.getHashValueSerializer();
        }
    
        private byte[] getKeyBytes(Object key) {
            return getKeySerializer().serialize(key);
        }
    
        private byte[] getHashKeyBytes(Object key) {
            return getHashKeySerializer().serialize(key);
        }
    
        private byte[] getValueBytes(Object value) {
            return getValueSerializer().serialize(value);
        }
    
        private byte[] getHashValueBytes(Object value) {
            return getHashValueSerializer().serialize(value);
        }
    
        private <T> T deserializeValue(byte[] bytes) {
            return (T) getValueSerializer().deserialize(bytes);
        }
    
        private <T> T deserializeHashValue(byte[] bytes) {
            return (T) getHashValueSerializer().deserialize(bytes);
        }
    
        /** * 添加缓存数据（给定key已存在，进行覆盖） * * @param key * @param value * @throws DataAccessException */ public void set(final Object key, final Object value) throws DataAccessException {
            redisTemplate.execute(new RedisCallback<Void>() {
                @Override
                public Void doInRedis(RedisConnection connection)
                        throws DataAccessException {
                    connection.set(getKeyBytes(key), getValueBytes(value));
                    return null;
                }
            });
        }
    
        /** * 添加缓存数据（给定key已存在，不进行覆盖，直接返回false） * * @param key * @param value * @return 操作成功返回true，否则返回false * @throws DataAccessException */ public boolean setNX(final Object key, final Object value) throws DataAccessException {
            boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.setNX(getKeyBytes(key), getValueBytes(value));
                }
            });
            return result;
        }
    
        /** * 添加缓存数据，设定缓存失效时间 * * @param key * @param value * @param expireSeconds 过期时间，单位 秒 * @throws DataAccessException */ public void setEx(final Object key, final Object value, final long expireSeconds) throws DataAccessException {
            redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.setEx(getKeyBytes(key), expireSeconds, getValueBytes(value));
                    return true;
                }
            });
        }
    
        /** * 添加缓存数据，设定默认缓存失效时间 * * @param key * @param value * @throws DataAccessException */ public void setEx(Object key, Object value) throws DataAccessException {
            setEx(key, value, expireTime);
        }
    
        /** * 获取key对应value * * @param key * @return * @throws DataAccessException */ public <T> T get(final Object key) throws DataAccessException {
            byte[] result = redisTemplate.execute(new RedisCallback<byte[]>() {
                @Override
                public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.get(getKeyBytes(key));
                }
            });
            if (result == null) {
                return null;
            }
            return deserializeValue(result);
        }
    
        public boolean hSet(final Object key, final Object field, final Object value) {
            boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.hSet(getKeyBytes(key), getHashKeyBytes(field), getHashValueBytes(value));
                }
            });
            return result;
        }
    
        public <T> T hGet(final Object key, final Object field) throws DataAccessException {
            byte[] result = redisTemplate.execute(new RedisCallback<byte[]>() {
                @Override
                public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.hGet(getKeyBytes(key), getHashKeyBytes(field));
                }
            });
            if (result == null) {
                return null;
            }
            return deserializeHashValue(result);
        }
    
        /** * 设置超时时间 * * @param key * @param seconds * @return */ public boolean expire(final Object key, final long seconds) {
            boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.expire(getKeyBytes(key), seconds);
                }
            });
    
            return result;
        }
    
        /** * 删除指定key数据 * * @param key * @return 返回操作影响记录数 */ public long del(final Object key) {
            if (key == null) {
                return 0l;
            }
            Long delNum = redisTemplate.execute(new RedisCallback<Long>() {
                @Override
                public Long doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.del(getKeyBytes(key));
                }
            });
            return delNum;
        }
    
        /** * 用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略 * * @param key 哈希表对应的键 * @param filed 哈希表中要删除的键 * @return */ public Long hdel(final Object key, final Object... filed) {
            if (key == null) {
                return 0l;
            }
            final byte[] keys = getKeyBytes(key);
            if (keys == null || keys.length == 0) {
                return 0L;
            }
            Long delNum = redisTemplate.execute(new RedisCallback<Long>() {
                @Override
                public Long doInRedis(RedisConnection connection) throws DataAccessException {
                    List<byte[]> fieldList = new ArrayList<byte[]>();
                    for (Object f : filed) {
                        if (f != null) {
                            byte[] hfs = getHashKeyBytes(f);
                            if (hfs != null && hfs.length > 0) {
                                fieldList.add(hfs);
                            }
                        }
                    }
    
                    if (fieldList.size() == 0) {
                        return 0L;
                    }
    
                    byte[][] bytes = new byte[0][];
                    return connection.hDel(keys, fieldList.toArray(bytes));
                }
            });
            return delNum;
        }
    
        public Set<byte[]> keys(final Object key) {
            if (key == null) {
                return null;
            }
            Set<byte[]> bytesSet = redisTemplate.execute(new RedisCallback<Set<byte[]>>() {
                @Override
                public Set<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.keys(getKeyBytes(key));
                }
            });
    
            return bytesSet;
        }
    
        public void flushDb() {
            redisTemplate.execute(new RedisCallback<Void>() {
                @Override
                public Void doInRedis(RedisConnection redisConnection) throws DataAccessException {
                    redisConnection.flushDb();
                    return null;
                }
            });
        }
    
        /** * size */ public Long dbSize() {
            Long dbSize = redisTemplate.execute(new RedisCallback<Long>() {
                @Override
                public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                    return redisConnection.dbSize();
                }
            });
            return dbSize;
        }
    }