RedisTemplate 常用工具封装

@Component
@Slf4j
public class RedisUtils {
    @Autowired
    private RedisTemplate redisTemplate;

    public boolean hashKey(String key) {
        return redisTemplate.hasKey(key);
    }

    public <T> T get(String key) {
        RedisTemplate<String, T> tRedisTemplate = (RedisTemplate<String, T>) redisTemplate;
        return tRedisTemplate.opsForValue().get(key);

    }

    /**
     * 存入信息带过期时间
     *
     * @param key
     * @param value
     * @param time
     * @param <T>
     * @return
     */
    public <T> boolean set(String key, T value, long time, TimeUnit timeUnit) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, timeUnit);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error("Redis Set Err:{}", e);
            return false;
        }
    }

    /**
     * 存入信息 泛型
     *
     * @param key
     * @param t
     * @param <T>
     * @return
     */
    public <T> boolean set(String key, T t) {
        try {
            redisTemplate.opsForValue().set(key, t);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("Redis Set Err:{}", e);
            return false;
        }
    }

    /**
     * 删除
     *
     * @param key
     * @return
     */
    public boolean del(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 设置Map值
     *
     * @param key
     * @param mapKey
     * @param v
     * @param <T>
     * @return
     */
    public <T> boolean put(String key, String mapKey, T v) {
        try {
            redisTemplate.opsForHash().put(key, mapKey, v);
            return true;
        } catch (Exception e) {
            log.error("Redis Hash Put Err:{}", e);
            return false;
        }
    }

    /**
     * 删除map中的key
     *
     * @param key
     * @param mapKey
     * @return
     */
    public long mapDel(String key, String mapKey) {
        return redisTemplate.opsForHash().delete(key, mapKey);
    }

    /**
     * put 一个Map
     *
     * @param key
     * @param map
     * @param <T>
     * @return
     */
    public <T> boolean putAll(String key, Map<String, T> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            log.error("Redis Hash Put All Err:{}", e);
            return false;
        }
    }

    /**
     * 获取map对象
     *
     * @param key
     * @param <T>
     * @return
     */
    public <T> Map<String, T> entries(String key) {
        Map<String, T> data = redisTemplate.opsForHash().entries(key);
        if (null == data) {
            data = new HashMap<>(16);
        }
        return data;
    }

    /**
     * 获取map中的所有对象
     *
     * @param key
     * @param <T>
     * @return
     */
    public <T> List<T> getMapValues(String key) {
        List<T> list = new ArrayList<>();
        try {
            list = redisTemplate.opsForHash().values(key);
            return list;
        } catch (Exception e) {
            log.warn("检查到当前key缓存异常：{}-{}",key,e.getMessage());
            Set<String> keys=redisTemplate.opsForHash().keys(key);
            redisTemplate.opsForHash().delete(key,keys.toArray());
        }
        return list;
    }

    /**
     * 获取map中的值
     *
     * @param key
     * @param mapKey
     * @param <T>
     * @return
     */
    public <T> T getMapValueByKey(String key, String mapKey) {
        return (T) redisTemplate.opsForHash().get(key, mapKey);
    }

    /**
     * 批量回去
     *
     * @param key
     * @param mapKey
     * @param <T>
     * @return
     */
    public <T> T getMapValueByKeys(String key, Set<String> mapKey) {
        return (T) redisTemplate.opsForHash().multiGet(key, mapKey);
    }


    public <T> void addSetValue(String key, T value) {
        redisTemplate.opsForSet().add(key, value);
    }

    public <T> void addSetValues(String key, String[] values) {
        redisTemplate.opsForSet().add(key, values);
    }

    public <T> void delSetValue(String key, T value) {
        redisTemplate.opsForSet().remove(key, value);
    }

    public <T> Set<T> getSetValue(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    public <T> boolean hasSetValue(String key, T value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }