Redis caching tool class, worth owning~

Still for redis Are you worried about the cached tool class , Here is a careful summary for you redis Various tool classes of cache , Very comprehensive , Come and see ~

@Component
public class RedisUtil {
    

    @Autowired
    private RedisTemplate redisTemplate;

    /** *  Specify cache expiration time  * * @param key  key  * @param time  Time ( second ) * @return */
    public boolean expire(String key, long time) {
    
        try {
    
            if (time > 0) {
    
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  according to key  Get expiration time  * * @param key  key   Not for null * @return  Time ( second )  return 0 Stands for permanent validity  */
    public long getExpire(String key) {
    
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /** *  Judge key Whether there is  * * @param key  key  * @return true  There is  false non-existent  */
    public boolean hasKey(String key) {
    
        try {
    
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  Delete cache  * * @param key  You can pass a value   Or more  */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
    
        if (key != null && key.length > 0) {
    
            if (key.length == 1) {
    
                redisTemplate.delete(key[0]);
            } else {
    
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================

    /** *  Normal cache fetch  * * @param key  key  * @return  value  */
    public Object get(String key) {
    
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /** *  Normal cache put in  * * @param key  key  * @param value  value  * @return true success  false Failure  */
    public boolean set(String key, Object value) {
    
        try {
    
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }

    }

    /** *  The normal cache is put in and set the time  * * @param key  key  * @param value  value  * @param time  Time ( second ) time Be greater than 0  If time Less than or equal to 0  Will be set indefinitely  * @return true success  false  Failure  */
    public boolean set(String key, Object value, long time) {
    
        try {
    
            if (time > 0) {
    
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
    
                set(key, value);
            }
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  Increasing  * * @param key  key  * @param delta  How much more should I add ( Greater than 0) * @return */
    public long incr(String key, long delta) {
    
        if (delta < 0) {
    
            throw new RuntimeException(" The increment factor must be greater than 0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /** *  Decline  * * @param key  key  * @param delta  To cut it down a few ( Less than 0) * @return */
    public long decr(String key, long delta) {
    
        if (delta < 0) {
    
            throw new RuntimeException(" The decline factor must be greater than 0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //================================Map=================================

    /** * HashGet * * @param key  key   Not for null * @param item  term   Not for null * @return  value  */
    public Object hget(String key, String item) {
    
        return redisTemplate.opsForHash().get(key, item);
    }

    /** *  obtain hashKey All the corresponding key values  * * @param key  key  * @return  Corresponding multiple key values  */
    public Map<Object, Object> hmget(String key) {
    
        return redisTemplate.opsForHash().entries(key);
    }

    /** * HashSet * * @param key  key  * @param map  Corresponding to multiple key values  * @return true  success  false  Failure  */
    public boolean hmset(String key, Map<String, Object> map) {
    
        try {
    
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** * HashSet  And set the time  * * @param key  key  * @param map  Corresponding to multiple key values  * @param time  Time ( second ) * @return true success  false Failure  */
    public boolean hmset(String key, Map<String, Object> map, long time) {
    
        try {
    
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
    
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  To a piece of hash Put data in the table , If it doesn't exist, it will create  * * @param key  key  * @param item  term  * @param value  value  * @return true  success  false Failure  */
    public boolean hset(String key, String item, Object value) {
    
        try {
    
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  To a piece of hash Put data in the table , If it doesn't exist, it will create  * * @param key  key  * @param item  term  * @param value  value  * @param time  Time ( second )  Be careful : If there is already hash Watch has time , This will replace the original time  * @return true  success  false Failure  */
    public boolean hset(String key, String item, Object value, long time) {
    
        try {
    
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
    
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  Delete hash The values in the table  * * @param key  key   Not for null * @param item  term   Can make multiple   Not for null */
    public void hdel(String key, Object... item) {
    
        redisTemplate.opsForHash().delete(key, item);
    }

    /** *  Judge hash Whether there is a value of this item in the table  * * @param key  key   Not for null * @param item  term   Not for null * @return true  There is  false non-existent  */
    public boolean hHasKey(String key, String item) {
    
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /** * hash Increasing   If it doesn't exist , It creates a   And return the added value to  * * @param key  key  * @param item  term  * @param by  How much more should I add ( Greater than 0) * @return */
    public double hincr(String key, String item, double by) {
    
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /** * hash Decline  * * @param key  key  * @param item  term  * @param by  Remember less ( Less than 0) * @return */
    public double hdecr(String key, String item, double by) {
    
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    //============================set=============================

    /** *  according to key obtain Set All the values in  * * @param key  key  * @return */
    public Set<Object> sGet(String key) {
    
        try {
    
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
    
            e.printStackTrace();
            return null;
        }
    }

    /** *  according to value From a set Query in , Whether there is  * * @param key  key  * @param value  value  * @return true  There is  false non-existent  */
    public boolean sHasKey(String key, Object value) {
    
        try {
    
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  Put data into set cache  * * @param key  key  * @param values  value   It can be more than one  * @return  The number of successes  */
    public long sSet(String key, Object... values) {
    
        try {
    
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    /** *  take set Data is put into the cache  * * @param key  key  * @param time  Time ( second ) * @param values  value   It can be more than one  * @return  The number of successes  */
    public long sSetAndTime(String key, long time, Object... values) {
    
        try {
    
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) expire(key, time);
            return count;
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    /** *  obtain set The length of the cache  * * @param key  key  * @return */
    public long sGetSetSize(String key) {
    
        try {
    
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    /** *  The removal value is value Of  * * @param key  key  * @param values  value   It can be more than one  * @return  Number of removed  */
    public long setRemove(String key, Object... values) {
    
        try {
    
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /** *  obtain list The contents of the cache  * * @param key  key  * @param start  Start  * @param end  end  0  To  -1 For all values  * @return */
    public List<Object> lGet(String key, long start, long end) {
    
        try {
    
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
    
            e.printStackTrace();
            return null;
        }
    }

    /** *  obtain list The length of the cache  * * @param key  key  * @return */
    public long lGetListSize(String key) {
    
        try {
    
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    /** *  Through the index   obtain list The value in  * * @param key  key  * @param index  Indexes  index>=0 when , 0  Header ,1  The second element , By analogy ;index<0 when ,-1, Tail ,-2 The next to last element , By analogy  * @return */
    public Object lGetIndex(String key, long index) {
    
        try {
    
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
    
            e.printStackTrace();
            return null;
        }
    }

    /** *  take list Put into cache  * * @param key  key  * @param value  value  * @return */
    public boolean lSet(String key, Object value) {
    
        try {
    
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  take list Put into cache  * * @param key  key  * @param value  value  * @param time  Time ( second ) * @return */
    public boolean lSet(String key, Object value, long time) {
    
        try {
    
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  take list Put into cache  * * @param key  key  * @param value  value  * @return */
    public boolean lSet(String key, List<Object> value) {
    
        try {
    
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  take list Put into cache  * * @param key  key  * @param value  value  * @param time  Time ( second ) * @return */
    public boolean lSet(String key, List<Object> value, long time) {
    
        try {
    
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  Modify according to the index list A piece of data in  * * @param key  key  * @param index  Indexes  * @param value  value  * @return */
    public boolean lUpdateIndex(String key, long index, Object value) {
    
        try {
    
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /** *  remove N The values are value * * @param key  key  * @param count  How many removed  * @param value  value  * @return  Number of removed  */
    public long lRemove(String key, long count, Object value) {
    
        try {
    
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    //================ Ordered set  sort set===================
    /** *  Orderly set Additive elements  * * @param key * @param value * @param score * @return */
    public boolean zSet(String key, Object value, double score) {
    
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    public long batchZSet(String key, Set<ZSetOperations.TypedTuple> typles) {
    
        return redisTemplate.opsForZSet().add(key, typles);
    }

    public void zIncrementScore(String key, Object value, long delta) {
    
        redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    public void zUnionAndStore(String key, Collection otherKeys, String destKey) {
    
        redisTemplate.opsForZSet().unionAndStore(key, otherKeys, destKey);
    }

    /** *  obtain zset Number  * @param key * @param value * @return */
    public long getZsetScore(String key, Object value) {
    
        Double score = redisTemplate.opsForZSet().score(key, value);
        if(score==null){
    
            return 0;
        }else{
    
            return score.longValue();
        }
    }

    /** *  Get ordered set  key  Member of the  member  Ranking  . *  The members of the ordered set press  score  The value is decreasing  ( From big to small )  Sort . * @param key * @param start * @param end * @return */
    public Set<ZSetOperations.TypedTuple> getZSetRank(String key, long start, long end) {
    
        return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
    }

}