redis工具類

package com.xxx.common.redis;

import com.xxx.base.util.CommonUtil;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
import org.springframework.stereotype.Repository;

@Repository("redisDao")
public class RedisDao {
    @Autowired
    private StringRedisTemplate redisTemplate;
    private static Logger logger = LoggerFactory.getLogger(RedisDao.class);

    public RedisDao() {
    }

    public <T> boolean set(String key, T value) {
        boolean result = false;

        try {
            String str = CommonUtil.beanToString(value);
            ValueOperations<String, String> valueOperations = this.redisTemplate.opsForValue();
            valueOperations.set(key, str);
            result = true;
        } catch (Exception var6) {
            logger.error("redis set error key={},value={}", new Object[]{key, value, var6});
        }

        return result;
    }

    public <T> boolean set(String key, T value, Integer timeout) {
        boolean result = false;
        String str = CommonUtil.beanToString(value);

        try {
            ValueOperations<String, String> valueOperations = this.redisTemplate.opsForValue();
            valueOperations.set(key, str, timeout.longValue(), TimeUnit.SECONDS);
            result = true;
        } catch (Exception var7) {
            logger.error("redis set error key={},value={},timeout={}", new Object[]{key, str, timeout, var7});
        }

        return result;
    }

    public <T> boolean set(String key, T value, Integer timeout, TimeUnit unit) {
        String str = CommonUtil.beanToString(value);

        try {
            ValueOperations<String, String> valueOperations = this.redisTemplate.opsForValue();
            valueOperations.set(key, str, timeout.longValue(), unit);
            return true;
        } catch (Exception var7) {
            logger.error("redis set error key={},value={},timeout={},unit={}", new Object[]{key, str, timeout, unit, var7});
            return false;
        }
    }

    public <T> T get(String key, Class<T> clazz) {
        String result = null;

        try {
            ValueOperations<String, String> valueOperations = this.redisTemplate.opsForValue();
            result = (String)valueOperations.get(key);
        } catch (Exception var5) {
            logger.error("redis get error key={}", key, var5);
        }

        T t = CommonUtil.stringToBean(result, clazz);
        return t;
    }

    public boolean del(String key) {
        boolean result = false;

        try {
            this.redisTemplate.delete(key);
            result = true;
        } catch (Exception var4) {
            logger.error("redis del error key={}", key, var4);
        }

        return result;
    }

    public boolean delCollection(Set<String> keys) {
        boolean result = false;

        try {
            this.redisTemplate.delete(keys);
            result = true;
        } catch (Exception var4) {
            logger.error("redis delCollection error key={}", keys.toString(), var4);
        }

        return result;
    }

    public boolean hasKey(String key) {
        boolean result = false;

        try {
            result = this.redisTemplate.hasKey(key);
        } catch (Exception var4) {
            logger.error("redis hasKey error key = {}", key, var4);
        }

        return result;
    }

    public long increment(String key, Integer delta) {
        try {
            ValueOperations<String, String> valueOperations = this.redisTemplate.opsForValue();
            return valueOperations.increment(key, delta.longValue());
        } catch (Exception var4) {
            logger.error("redis increment error key = {}, delta = {}", new Object[]{key, delta, var4});
            return 0L;
        }
    }

    public long increment(String key, Integer delta, Integer timeout) {
        try {
            boolean hasKey = false;
            if (!this.hasKey(key)) {
                hasKey = true;
            }

            long value = this.increment(key, delta);
            if (hasKey) {
                this.expire(key, timeout);
            }

            return value;
        } catch (Exception var7) {
            logger.error("redis increment error key = {}, delta = {}", new Object[]{key, delta, var7});
            return 0L;
        }
    }

    public boolean expire(String key, Integer timeout) {
        boolean result = false;

        try {
            this.redisTemplate.expire(key, timeout.longValue(), TimeUnit.SECONDS);
            result = true;
        } catch (Exception var5) {
            logger.error("redis expire error key = {}", key, var5);
        }

        return result;
    }

    public boolean expire(String key, Integer timeout, TimeUnit timeUnit) {
        boolean result = false;

        try {
            this.redisTemplate.expire(key, timeout.longValue(), timeUnit);
            result = true;
        } catch (Exception var6) {
            logger.error("redis expire error key = {}", key, var6);
        }

        return result;
    }

    public long ttl(String key) {
        try {
            long time = this.redisTemplate.getExpire(key, TimeUnit.SECONDS);
            return time;
        } catch (Exception var4) {
            logger.error("redis expire error key = {}", key, var4);
            return 0L;
        }
    }

    public boolean putAll(String key, Map map) {
        boolean result = false;

        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            options.putAll(key, map);
            result = true;
        } catch (Exception var5) {
            logger.error("redis putAll error key={},map={}", new Object[]{key, map, var5});
        }

        return result;
    }

    public boolean putAll(String key, Map map, Integer timeout) {
        boolean result = false;

        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            options.putAll(key, map);
            this.redisTemplate.expire(key, timeout.longValue(), TimeUnit.SECONDS);
            result = true;
        } catch (Exception var6) {
            logger.error("redis putAll error key={},map={}", new Object[]{key, map, var6});
        }

        return result;
    }

    public boolean put(String key, String hashKey, String hashValue) {
        boolean result = false;

        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            options.put(key, hashKey, hashValue);
            result = true;
        } catch (Exception var6) {
            logger.error("redis put error key={},hashKey={},hashValue={}", new Object[]{key, hashKey, hashValue, var6});
        }

        return result;
    }

    public boolean hasKey(String key, String hashKey) {
        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            return options.hasKey(key, hashKey);
        } catch (Exception var4) {
            logger.error("redis hasKey error key={},hashKey={}", new Object[]{key, hashKey, var4});
            return false;
        }
    }

    public String getHashValue(String key, String hashKey) {
        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            return (String)options.get(key, hashKey);
        } catch (Exception var4) {
            logger.error("redis get error key={},hashKey={}", new Object[]{key, hashKey, var4});
            return null;
        }
    }

    public List<String> multiGet(String key, Collection<String> fields) {
        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            return options.multiGet(key, fields);
        } catch (Exception var4) {
            logger.error("redis multiGet error key={},hashKey={}", new Object[]{key, fields, var4});
            return null;
        }
    }

    public long delete(String key, String... hashKeys) {
        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            return options.delete(key, hashKeys);
        } catch (Exception var4) {
            logger.error("redis delete error key={},hashKeys={}", new Object[]{key, hashKeys, var4});
            return 0L;
        }
    }

    public long increment(String key, String hashKey, Integer delta) {
        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            return options.increment(key, hashKey, delta.longValue());
        } catch (Exception var5) {
            logger.error("redis delete error key={},hashKey={},delta={}", new Object[]{key, hashKey, delta, var5});
            return 0L;
        }
    }

    public Set<String> keys(String key) {
        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            return this.redisTemplate.keys(key);
        } catch (Exception var3) {
            logger.error("redis keys error key={}", key, var3);
            return null;
        }
    }

    public Map<String, String> entries(String key) {
        try {
            HashOperations<String, String, String> options = this.redisTemplate.opsForHash();
            return options.entries(key);
        } catch (Exception var3) {
            logger.error("redis keys error key={}", key, var3);
            return null;
        }
    }

    public long sAdd(String key, Integer time, String... values) {
        try {
            SetOperations<String, String> setOperations = this.redisTemplate.opsForSet();
            long n = setOperations.add(key, values);
            if (time != null) {
                this.expire(key, time);
            }

            return n;
        } catch (Exception var7) {
            logger.error("redis set add error ", var7);
            return 0L;
        }
    }

    public boolean sIsMember(String key, String value) {
        try {
            SetOperations<String, String> setOperations = this.redisTemplate.opsForSet();
            return setOperations.isMember(key, value);
        } catch (InvalidDataAccessApiUsageException var4) {
            this.del(key);
        } catch (Exception var5) {
            logger.error("redis set sisMember error", var5);
        }

        return false;
    }

    public long sRem(String key, String... hashKeys) {
        try {
            SetOperations<String, String> setOperations = this.redisTemplate.opsForSet();
            return setOperations.remove(key, hashKeys);
        } catch (Exception var4) {
            logger.error("redis set sRem error", var4);
            return 0L;
        }
    }

    public long sCard(String key) {
        try {
            SetOperations<String, String> setOperations = this.redisTemplate.opsForSet();
            long n = setOperations.size(key);
            return n;
        } catch (Exception var5) {
            logger.error("redis set sSize error ", var5);
            return 0L;
        }
    }

    public Set<String> members(String key) {
        Set set = null;

        try {
            SetOperations<String, String> setOperations = this.redisTemplate.opsForSet();
            set = setOperations.members(key);
            return set;
        } catch (InvalidDataAccessApiUsageException var4) {
            this.del(key);
        } catch (Exception var5) {
            logger.error("redis members sSize error ", var5);
        }

        return set;
    }

    public boolean zAdd(String key, String value, double score) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            return zSetOperations.add(key, value, score);
        } catch (Exception var6) {
            logger.error("redis zset zadd error e:{}", var6);
            return false;
        }
    }

    public boolean zRem(String key, String... value) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            long row = zSetOperations.remove(key, value);
            return row > 0L;
        } catch (Exception var6) {
            logger.error("redis zset remove error e:{}", var6);
            return false;
        }
    }

    public long zRank(String key, String value) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            return zSetOperations.rank(key, value) + 1L;
        } catch (Exception var4) {
            logger.error("redis zset zRank error e:{}", var4);
            return 0L;
        }
    }

    public long zRevRank(String key, String value) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            Long res = zSetOperations.reverseRank(key, value);
            return null == res ? 0L : res + 1L;
        } catch (Exception var5) {
            logger.error("redis zset zRevRank error e:{}", var5);
            return 0L;
        }
    }

    public long zCard(String key) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            return zSetOperations.zCard(key);
        } catch (Exception var3) {
            logger.error("redis zset zCard error e:{}", var3);
            return 0L;
        }
    }

    public double zIncrby(String key, String value, double delta) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            return zSetOperations.incrementScore(key, value, delta);
        } catch (Exception var6) {
            logger.error("redis zset zCard error e:{}", var6);
            return 0.0D;
        }
    }

    public double zIncrby(String key, String value, double delta, Long secend) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            double d = zSetOperations.incrementScore(key, value, delta);
            this.redisTemplate.expire(key, secend, TimeUnit.SECONDS);
        } catch (Exception var9) {
            logger.error("redis zset zCard error e:{}", var9);
        }

        return 0.0D;
    }

    public Set<String> zRange(String key, Integer start, Integer end) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            return zSetOperations.range(key, start.longValue(), end.longValue());
        } catch (Exception var5) {
            logger.error("redis zset zRange error e:{}", var5);
            return new HashSet();
        }
    }

    public Map<String, Double> zRangeWithScores(String key, Integer start, Integer end) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            Set<TypedTuple<String>> set = zSetOperations.rangeWithScores(key, start.longValue(), end.longValue());
            Map<String, Double> idAndScores = new HashMap();
            Iterator var7 = set.iterator();

            while(var7.hasNext()) {
                TypedTuple<String> z = (TypedTuple)var7.next();
                idAndScores.put(z.getValue(), z.getScore());
            }

            return idAndScores;
        } catch (Exception var9) {
            logger.error("redis zset zRange error e:{}", var9);
            return new HashMap();
        }
    }

    public Set<String> zRevrange(String key, Integer start, Integer end) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            return zSetOperations.reverseRange(key, start.longValue(), end.longValue());
        } catch (Exception var5) {
            logger.error("redis zset zRange error e:{}", var5);
            return new HashSet();
        }
    }

    public double zScore(String key, String value) {
        try {
            ZSetOperations<String, String> zSetOperations = this.redisTemplate.opsForZSet();
            Double db = zSetOperations.score(key, value);
            return db == null ? 0.0D : db;
        } catch (Exception var5) {
            logger.error("redis zset zscore error e:{}", var5);
            return 0.0D;
        }
    }

    public long leftPush(String key, Object object) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            long n = listOperations.leftPush(key, object);
            return n;
        } catch (Exception var6) {
            logger.error("redis leftPush  error e:{}", var6);
            return 0L;
        }
    }

    public long rightPush(String key, Object object) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            long n = listOperations.rightPush(key, object);
            return n;
        } catch (Exception var6) {
            logger.error("redis leftPush  error e:{}", var6);
            return 0L;
        }
    }

    public Object rightPop(String key) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            Object o = listOperations.rightPop(key);
            return o;
        } catch (Exception var4) {
            logger.error("redis leftPush  error e:{}", var4);
            return null;
        }
    }

    public Object leftPop(String key) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            Object o = listOperations.leftPop(key);
            return o;
        } catch (Exception var4) {
            logger.error("redis leftPop  error e:{}", var4);
            return null;
        }
    }

    public Object getFromList(String key, Integer index) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            Object o = listOperations.index(key, index.longValue());
            return o;
        } catch (Exception var5) {
            logger.error("redis getFromList  error e:{}", var5);
            return null;
        }
    }

    public List<Object> range(String key, Integer start, Integer end) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            List<Object> list = listOperations.range(key, start.longValue(), end.longValue());
            return list;
        } catch (Exception var6) {
            logger.error("redis range  error e:{}", var6);
            return null;
        }
    }

    public List<Object> range(String key) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            List<Object> list = listOperations.range(key, 0L, -1L);
            return list;
        } catch (Exception var4) {
            logger.error("redis range  error e:{}", var4);
            return null;
        }
    }

    public Long remove(String key, String itme) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            Long removeNum = listOperations.remove(key, 0L, itme);
            return removeNum;
        } catch (Exception var5) {
            logger.error("redis range  error e:{}", var5);
            return 0L;
        }
    }

    public Long size(String key) {
        try {
            ListOperations listOperations = this.redisTemplate.opsForList();
            long n = listOperations.size(key);
            return n;
        } catch (Exception var5) {
            logger.error("redis size  error e:{}", var5);
            return null;
        }
    }

    public Set<String> getKeysByLike(String cachePrefix) {
        return this.redisTemplate.keys(cachePrefix);
    }

    public DataType getKeysType(String key) {
        return this.redisTemplate.type(key);
    }
}