Redishelp

 /**
  * @author yanming.zhang
  * @date 2019/1/25 21:15
  */
 @Component
 public class RedisHelp {

     @Autowired

     private RedisTemplate redisTemplate;

     /**
      * 切换redis数据库
      * @param i  0-15
      * @return
      */
     public boolean changeDatabase(int i) {
         boolean result = false;
         try {
             LettuceConnectionFactory lettuceConnectionFactory = (LettuceConnectionFactory)redisTemplate.getConnectionFactory();
             lettuceConnectionFactory.setDatabase(i);
             result = true;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return result;
     }
     /**
      * 写入缓存
      * @param key
      * @param value
      * @return
      */
     public boolean set(final String key, Object value) {
         boolean result = false;
         try {
             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
             operations.set(key, value);
             result = true;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return result;
     }
     /**
      * 写入缓存设置时效时间
      * @param key
      * @param value
      * @return
      */
     public boolean set(final String key, Object value, Long expireTime) {
         boolean result = false;
         try {
             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
             operations.set(key, value,expireTime, TimeUnit.SECONDS);
             result = true;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return result;
     }
     /**
      * 重新设置时效时间
      * @param key
      * @param expireTime
      * @return
      */
     public boolean setExpire(final String key,Long expireTime){
         boolean result = false;
         try {
             redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
             result = true;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return result;
     }
     /**
      * 批量删除对应的value
      * @param keys
      */
     public void remove(String... keys) {
         for (String key : keys) {
             remove(key);
         }
     }

     /**
      * 批量删除key
      * @param pattern
      */
     public void removePattern(String pattern) {
         Set<Serializable> keys = redisTemplate.keys(pattern);
         if (keys.size() > 0){
             redisTemplate.delete(keys);
         }
     }
     /**
      * 删除对应的value
      * @param key
      */
     public void remove(String key) {
         if (exists(key)) {
             redisTemplate.delete(key);
         }
     }
     /**
      * 判断缓存中是否有对应的value
      * @param key
      * @return
      */
     public boolean exists(String key) {
         if(key==null){
             return false;
         }
         return redisTemplate.hasKey(key);
     }
     /**
      * 读取缓存
      * @param key
      * @return
      */
     public Object get(String key) {
         Object result = null;
         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
         result = operations.get(key);
         return result;
     }
     /**
      * 哈希 添加
      * @param key
      * @param hashKey
      * @param value
      */
     public void hmSet(String key, Object hashKey, Object value){
         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
         hash.put(key,hashKey,value);
     }

     /**
      * 哈希获取数据
      * @param key
      * @param hashKey
      * @return
      */
     public Object hmGet(String key, Object hashKey){
         HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
         return hash.get(key,hashKey);
     }

     /**
      * 列表添加
      * @param k
      * @param v
      */
     public void lPush(String k,Object v){
         ListOperations<String, Object> list = redisTemplate.opsForList();
         list.rightPush(k,v);
     }

     /**
      * 列表获取
      * @param k
      * @param l
      * @param l1
      * @return
      */
     public List<Object> lRange(String k, long l, long l1){
         ListOperations<String, Object> list = redisTemplate.opsForList();
         return list.range(k,l,l1);
     }

     /**
      * 无序，不重复集合添加
      * @param key
      * @param value
      */
     public void add(String key,Object value){
         SetOperations<String, Object> set = redisTemplate.opsForSet();
         set.add(key,value);
     }
     /**
      * 无序，删除指定集合中的指定元素
      * @param s
      */
     public void pop(String s,String o){
         SetOperations<String, Object> set = redisTemplate.opsForSet();
         set.remove(s,o);

     }

     /**
      *无序，不重复 集合获取
      * @param key
      * @return
      */
     public Set<Object> getMembers(String key){
         SetOperations<String, Object> set = redisTemplate.opsForSet();
         return set.members(key);
     }

     /**
      * 有序，不重复集合添加
      * @param key
      * @param value
      * @param scoure
      */
     public void zAdd(String key,Object value,double scoure){
         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
         zset.add(key,value,scoure);
     }

     /**
      * 有序，不重复集合获取
      * @param key
      * @param scoure
      * @param scoure1
      * @return
      */
     public Set<Object> rangeByScore(String key,double scoure,double scoure1){
         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
         return zset.rangeByScore(key, scoure, scoure1);
     }
     @PostConstruct
     private void init() {
         redisTemplate.setKeySerializer(new StringRedisSerializer());
         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
         redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
         redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
     }
 }