redis对应Java操作

最新推荐文章于 2023-05-04 13:50:24 发布

souldomain

最新推荐文章于 2023-05-04 13:50:24 发布

阅读量638

点赞数 1

分类专栏： JAVA学习 redis 文章标签： redis java

本文链接：https://blog.csdn.net/qq_34434565/article/details/120000499

版权

JAVA学习同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

redis

7 篇文章 0 订阅

订阅专栏

Redis基础操作

链接: http://doc.redisfans.com/ 【Redis 命令参考】.

Java命令基于spring-boot-starter-data-redis的RedisTemplate。

1.KEY（键）

若无特殊说明，Java方法基于redisTemplate。

命令	Java方法	描述
DEL	delete(key/keys)	删除指定key/keys，实例：redisTemplate.delete(key)
EXISTS	hasKey(key)	检查给定 key 是否存在
EXPIRE	expire(key)	为给定 key 设置生存时间
EXPIREAT	expireAt(key)	EXPIREAT 的作用和 EXPIRE 类似，指定截止日期
KEYS	keys(pattern)	查找所有符合给定模式 pattern 的 key。
PERSIST	persist(key)	移除给定 key 的生存时间
RENAME	rename(key)	RENAME key newkey
RENAMENX	renameIfAbsent(key)	当且仅当 newkey 不存在时，将 key 改名为 newkey 。

  String key = "key", key1 = "key1";
  // 删除给定的一个或多个 key 。
  redisTemplate.delete(key);
  redisTemplate.delete(new String[]{key, key1});
  // 检查给定 key 是否存在
  redisTemplate.hasKey(key);
  // 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
  redisTemplate.expire(key, 100, TimeUnit.SECONDS);
  // EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。指定截止日期
  Date date = new Date();
  redisTemplate.expireAt(key, date);
  // 查找所有符合给定模式 pattern 的 key。特殊符号用 \ 隔开
  // KEYS 的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，如果你需要从一个数据集中查找特定的 key ，
  // 你最好还是用 Redis 的集合结构(set)来代替。
  String pattern = "*";
  redisTemplate.keys(pattern);
  // 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
  redisTemplate.persist(key);
  // RENAME key newkey
  redisTemplate.rename(key, key1);
  // 当且仅当 newkey 不存在时，将 key 改名为 newkey 。
  redisTemplate.renameIfAbsent(key, key1);

2. String（字符串）

若无特殊说明，Java方法基于redisTemplate.opsForValue()。

命令	Java操作	描述
SET	set(key, value)	将字符串值 value 关联到 key
GET	get(key)	返回 key 所关联的字符串值
INCR	increment(key)	将 key 中储存的数字值增一
DECR	decrement(key)	将 key 中储存的数字值减一
MSET	multiSet(map)	同时设置一个或多个 key-value 对
MGET	multiGet(keys)	返回所有(一个或多个)给定 key 的值
APPEND	append(key,append)	APPEND 命令将 value 追加到 key 原来的值的末尾

 String key = "key", key1 = "key1";
 ValueOperations operations = redisTemplate.opsForValue();
 // 将字符串值 value 关联到 key 。
 operations.set(key, "testValue");
 // 返回 key 所关联的字符串值。
 // 如果 key 不存在那么返回特殊值 nil 。
 //假如 key 储存的值不是字符串类型，返回一个错误，因为 GET 只能用于处理字符串值。
 Object obj = operations.get(key);
 // 将 key 中储存的数字值增一。
 // 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
 //如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
 //本操作的值限制在 64 位(bit)有符号数字表示之内。
 // 因为redis是单线程，所该操作具有原子性，适用模式：计数器、限速器、
 operations.increment(key1);
 // 将 key 所储存的值加上增量 increment
 operations.increment(key1, 100L);
 // 将 key 中储存的数字值减一。
 //如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
 //如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
 //本操作的值限制在 64 位(bit)有符号数字表示之内。
 operations.decrement(key1);
 // 将 key 所储存的值减去减量 decrement 。
 operations.decrement(key1, 99L);
 //同时设置一个或多个 key-value 对。
 //如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。
 //MSET 是一个原子性(atomic)操作，所有给定 key 都会在同一时间内被设置，某些给定 key 被更新而另一些给定 key 没有改变的情况，不可能发生。
 Map<String, Object> map = new HashMap<>();
 map.put(key, "testValue2");
 map.put(key1, 300L);
 operations.multiSet(map);
 // operations.multiSetIfAbsent(map); // 互斥
 // 返回所有(一个或多个)给定 key 的值。
 //如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。因此，该命令永不失败。
 List<String> keys = new ArrayList<>();
 keys.add(key);
 keys.add(key1);
 List list = operations.multiGet(keys);
 // 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
 //如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
 operations.append(key, " appendvalue");

3. Hash（哈希表）

若无特殊说明，Java方法基于redisTemplate.opsForHash()。

命令	Java方法	描述
HSET	put(object, key, value)	将哈希表 key 中的域 field 的值设为 value
HGET	get(object, key)	返回哈希表 key 中给定域 field 的值。
HKEYS	keys(object)	返回哈希表 key 中的所有域。
HVALS	values(object)	返回哈希表 key 中所有域的值
HGETALL	entries(object)	返回哈希表 key 中，所有的域和值
HEXISTS	hasKey(object, key)	查看哈希表 key 中，给定域 field 是否存在

  HashOperations hashOperations = redisTemplate.opsForHash();
  // 将哈希表 key 中的域 field 的值设为 value 。
  //如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
  //如果域 field 已经存在于哈希表中，旧值将被覆盖。
  String object = "Object", hashKey1 = "hashKey1", hashKey2 = "hashKey2", hashValue1 = "hashValue1", hashValue2 = "hashValue2";
  hashOperations.put(object, hashKey1, hashValue1);
  hashOperations.put(object, hashKey2, hashValue2);
  // 返回哈希表 key 中给定域 field 的值。
  Object result = hashOperations.get(object, hashKey1);
  // 返回哈希表 key 中的所有域。
  Set set = hashOperations.keys(object);
  //返回哈希表 key 中所有域的值
  List list = hashOperations.values(object);
  // 返回哈希表 key 中，所有的域和值。
  //在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
  Map map = hashOperations.entries(object);
  // 查看哈希表 key 中，给定域 field 是否存在
  hashOperations.hasKey(object, hashKey1);

4. List（列表）

若无特殊说明，Java方法基于redisTemplate.opsForList()。

命令	Java方法	描述
LPUSH	leftPush(key, value)	将一个或多个值 value 插入到列表 key 的表头
LPOP	leftPop(key)	移除并返回列表 key 的头元素
RPUSH	rightPush(key, value)	将一个或多个值 value 插入到列表 key 的表尾
RPOP	rightPop(key)	移除并返回列表 key 的尾元素

  ListOperations listOperations = redisTemplate.opsForList();
  //将一个或多个值 value 插入到列表 key 的表头
  String key = "listKey", value1 = "value1", value2 = "value2", value3 = "value3";
  // 向集合最左边添加元素
  listOperations.leftPush(key, value1);
  // 把最后一个参数值放到指定集合的第一个出现中间参数的前面，如果中间参数值存在的话，否则不添加
  listOperations.leftPush(key, value1, value2);
  // 移除并返回列表 key 的头元素
  Object result = listOperations.leftPop(key);
  //  在等待的时间里移除集合中最左边的元素，如果超过等待的时间仍没有元素则退出
  result = listOperations.leftPop(key, 1, TimeUnit.SECONDS);
  // 将一个或多个值 value 插入到列表 key 的表尾(最右边)
  listOperations.rightPush(key, value3);
  // 把最后一个参数值放到指定集合的最后一个出现中间参数的后面，如果中间参数值存在的话，否则不添加
  listOperations.rightPush(key, value3, value2);
  // 移除并返回列表 key 的尾元素
  result = listOperations.rightPop(key);
  // 在等待的时间里移除集合中最右边的元素，如果超过等待的时间仍没有元素则退出
  result = listOperations.rightPop(key, 1, TimeUnit.SECONDS);

5. Set（集合）

若无特殊说明，Java方法基于redisTemplate.opsForSet()。

命令	Java方法	描述
SADD	add(key,values)	将一个或多个 member 元素加入到集合 key 当中
SPOP	pop(key)	移除并返回集合中的一个随机元素
SRANDMEMBER	randomMember(key)	返回集合中的一个随机元素
SDIFF	difference(keys)	返回一个集合的全部成员，该集合是所有给定集合之间的差集
SINTER	intersect(keys)	返回一个集合的全部成员，该集合是所有给定集合的交集
SMOVE	move(key, value1, key2)	将 member 元素从 source 集合移动到 destination 集合
SUNION	union(key, key2)	返回一个集合的全部成员，该集合是所有给定集合的并集
SREM	remove(key, value1))	移除集合 key 中的一个或多个 member 元素

SetOperations setOperations = redisTemplate.opsForSet();
   String key = "setKey", key2 = "setKey2", value1 = "value1", value2 = "value2", value3 = "value3";
   //将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
   //假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
   //当 key 不是集合类型时，返回一个错误。
   setOperations.add(key, value1, value2);
   setOperations.add(key2, value2, value3);
   // 移除并返回集合中的一个随机元素
//        setOperations.pop(key);
   // 返回集合中的一个随机元素
   setOperations.randomMember(key);
   //返回一个集合的全部成员，该集合是所有给定集合之间的差集。
   //不存在的 key 被视为空集。
   List<String> keys = new ArrayList<>();
   keys.add(key);
   keys.add(key2);
   Set set = setOperations.difference(keys);
//        set = setOperations.difference(key, key2);
   // 但它将结果保存到 destination 集合，而不是简单地返回结果集
//        setOperations.differenceAndStore(key, key2, "newKey");
   // 返回一个集合的全部成员，该集合是所有给定集合的交集。
   //不存在的 key 被视为空集。
   //当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。
   set = setOperations.intersect(keys);
   // 但它将结果保存到 destination 集合，而不是简单地返回结果集
//        setOperations.intersectAndStore(key, key2, "newKey");
   // 将 member 元素从 source 集合移动到 destination 集合。
   //SMOVE 是原子性操作。
   //如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。
   //当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。
   //当 source 或 destination 不是集合类型时，返回一个错误。
//        setOperations.move(key, value1, key2);
   // 返回一个集合的全部成员，该集合是所有给定集合的并集。
   //不存在的 key 被视为空集。
   setOperations.union(key, key2);
   // 但它将结果保存到 destination 集合，而不是简单地返回结果集
//        setOperations.unionAndStore(key, key2, "newKey");
// 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
//当 key 不是集合类型，返回一个错误。
  setOperations.remove(key, value1);

6. SortedSet（有序集合）

若无特殊说明，Java方法基于redisTemplate.opsForZSet()。

命令	Java方法	描述
ZADD	add(key,value,score)	将一个或多个 member 元素及其 score 值加入到有序集 key 当中
ZREM	remove(key,value)	移除有序集 key 中的一个或多个成员
ZCARD	zCard(key)	返回有序集 key 对应的成员总数
ZCOUNT	count(key, score1, score2)	返回有序集 key 中，score 值在 min 和 max 之间成员数量
ZRANGE	range(key, index1, index2)	返回有序集 key 中，指定区间内的成员
ZRANGEBYSCORE	rangeByScore(key, score1, score2)	返回有序集 key 中，所有 score 值区间内（包含）的成员
ZREVRANGE	reverseRange(key, index1 , index2)	与ZRANGE排序规则相反
ZREVRANGEBYSCORE	reverseRangeByScore(key, score1, score2)	与ZRANGEBYSCORE排序规则相反
ZINCRBY	incrementScore(key, value, increment)	为有序集 key 的成员 member 的 score 值加上增量 increment

  ZSetOperations zSetOperations = redisTemplate.opsForZSet();
  String key = "zSetKey", key2 = "zSetKey2", value1 = "value1", value2 = "value2", value3 = "value3";
  // 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
  //如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
  //score 值可以是整数值或双精度浮点数。
  //如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
  //当 key 存在但不是有序集类型时，返回一个错误。
  zSetOperations.add(key, value1, 100);
  zSetOperations.add(key, value2, 200);
  zSetOperations.add(key, value3, 100);
  // 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
  //当 key 存在但不是有序集类型时，返回一个错误。
//        zSetOperations.remove(key, value1);
  // 返回有序集 key 的基数，即有序集的值的个数
  long l = zSetOperations.zCard(key);
  // 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量
  l = zSetOperations.count(key, 100, 300);
  // 返回有序集 key 中，指定区间(下标)内的成员。
  //其中成员的位置按 score 值递增(从小到大)来排序。
  //具有相同 score 值的成员按字典序(lexicographical order )来排列。
  Set set = zSetOperations.range(key, 0, 3);
  // zSetOperations.rangeByScore(key, 100, 200);

  // 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
  //排名以 0 为底，也就是说， score 值最大的成员排名为 0 。
  set = zSetOperations.reverseRange(key, 0 , 3);
  // set = zSetOperations.reverseRangeByScore(key, 100, 200);

  // 计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。
  //默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。
  //
  //WEIGHTS
  //使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。
  //如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。
  //
  //AGGREGATE
  //使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。
  //默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。
  // zSetOperations.unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate)

  // 计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。
  //默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.
  // zSetOperationsintersectAndStore(K key, Collection<K> otherKeys, K destKey, RedisZSetCommands.Aggregate aggregate)

  // 为有序集 key 的成员 member 的 score 值加上增量 increment 。
  //可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
  //当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
  //当 key 不是有序集类型时，返回一个错误。
  //score 值可以是整数值或双精度浮点数。
  zSetOperations.incrementScore(key, value1, 50);

souldomain

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
redis对应Java操作

Redis基础操作链接: http://doc.redisfans.com/ 【Redis 命令参考】.Java命令基于spring-boot-starter-data-redis的RedisTemplate。1.KEY（键）若无特殊说明，Java方法基于redisTemplate。命令Java方法描述DELdelete(key/keys)删除指定key/keys，实例：redisTemplate.delete(key)EXISTShasKey(key)
复制链接

扫一扫