Redis数据类型操作命令和Spring Boot对应方法_springbootredissort命令

Redis数据类型操作命令和Spring Boot对应方法

Redis是一个基于键值对的存储系统，支持多种数据结构。下面是Redis中的几种常见类型及其对应的操作命令以及在Spring Boot 操作Redis所需的方法。

1.字符串类型(string)

字符串是Redis中最为基本的数据类型之一，也是能够储存任何格式的值，如 png 图片或 JSON 数据等等。

常用命令

• 设置指定 key 的值
  set key value

  public void set(String key, Object value) {
          redisTemplate.opsForValue().set(key, value);
     }
  1
  2
  3

• 获取指定 key 的值

  get key

  public Object get(String key) {
          return redisTemplate.opsForValue().get(key);
      }
  1
  2
  3

• 批量获取指定 key 的值

  mget key1 [key2..]

    public List<Object> strlen(String... key) {
        	 List<Object> result = redisTemplate.opsForValue().multiGet(Arrays.asList(key,key2));
         	 return result;
      }
  
  1
  2
  3
  4
  5

• 删除指定 key 的值

  del key

  public void del(String... key) {
          if (key != null && key.length > 0) {
              if (key.length == 1) {
                  redisTemplate.delete(key[0]);
              } else {
                  // 批量删除
                  redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
              }
          }
      }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

• 返回指定键的字符串长度

  strlen key

  public Long strlen(String key) {
          return redisTemplate.opsForValue().size(key);
      }
  1
  2
  3

• 将键存储的数字减一

  decr key

  public Long decr(String key) {
          return redisTemplate.opsForValue().decrement(key);
      }
  1
  2
  3

• 将键存储的数字加一

  incr key

  public Long incr(String key) {
          return redisTemplate.opsForValue().increment(key);
      }
  1
  2
  3

2. 列表类型(list)

列表 (list) 是强大的工具，它可以允许你执行范围访问并且（从两端）添加和弹出元素。

常用命令:

• 从队列左边入队一个元素

  lpush key element

  public void lpush(String key, Object value) {
      redisTemplate.opsForList().leftPush(key, value);
  }
  1
  2
  3

• 从队列右边入队一个元素

  rpush key element

  public void rpush(String key, Object value) {
      redisTemplate.opsForList().rightPush(key, value);
  }
  1
  2
  3

• 从队列左边弹出/删除一个元素

  lpop key

  public Object lpop(String key) {
      return redisTemplate.opsForList().leftPop(key);
  }
  1
  2
  3

• 从队列右边弹出/删除一个元素
  rpop key

  public Object rpop(String key) {
      return redisTemplate.opsForList().rightPop(key);
  }
  1
  2
  3

• 获取指定范围内的所有元素, start 和 end 都是从0开始的索引值
  lrange key start end

  public List<Object> lrange(String key, int start, int stop) {
      return redisTemplate.opsForList().range(key, start, stop);
  }
  1
  2
  3

• 获取指定 key 中的元素个数
  llen key

  public long llen(String key) {
      return redisTemplate.opsForList().size(key);
  }
  1
  2
  3

3.哈希类型(hash)

哈希表 (hash) 就像一个关联数组，其中字符串类型的字段和值之间存在映射关系。

常用命令：

• 哈希表设置值
  hset key field value

  public void hset(String key, String field, Object value) {
      redisTemplate.opsForHash().put(key, field, value);
  }
  1
  2
  3

• 获取哈希表中指定字段的值
  hget key field

  public Object hget(String key, String field) {
      return redisTemplate.opsForHash().get(key, field);
  }
  1
  2
  3

• 获取哈希表所有的字段和值
  hgetall key

  public Map<Object, Object> hgetAll(String key) {
      return redisTemplate.opsForHash().entries(key);
  }
  1
  2
  3

• 删除哈希表指定字段的值
  hdel key field

  public void hdel(String key, String... fields) {
      redisTemplate.opsForHash().delete(key, (Object) fields);
  }
  1
  2
  3

• ​ 获取多个field的值

  hmget key field1 [field2..]

  public List<Object> multiHget(String key, List<Object> fields) {
      return redisTemplate.opsForHash().multiGet(key, fields);
  }
  1
  2
  3

4.集合类型(set)

SET 类型是一组无序的字符串结构。这组非重复的字符串称作成员(member)。

常用命令：

• set添加元素
  sadd key member

  public long sadd(String key, Object... values) {
      return redisTemplate.opsForSet().add(key, values);
  }
  1
  2
  3

• 查询集合中的所有元素
  smembers key

  public Set<Object> smembers(String key) {
      return redisTemplate.opsForSet().members(key);
  }
  1
  2
  3

• 返回集合中的元素个数
  scard key

  public long scard(String key) {
      return redisTemplate.opsForSet().size(key);
  }
  1
  2
  3

• 删除集合中指定元素
  srem key member

   public long srem (String key, Object... values) {
          try {
              Long count = redisTemplate.opsForSet().remove(key, values);
              return count;
          } catch (Exception e) {
              e.printStackTrace();
              return 0;
          }
      }
  1
  2
  3
  4
  5
  6
  7
  8
  9