5 Redis通用命令

[5 通用命令](#5 通用命令)

[5.1 key相关](#5.1 key相关)

[5.1.1 命令](#5.1.1 命令)

[5.1.2 方法](#5.1.2 方法)

[5.2 服务器相关](#5.2 服务器相关)

[5.2.1 命令](#5.2.1 命令)

5 通用命令

5.1 key相关

5.1.1 命令

key的生存时间
Redis在实际使用过程中更多的用作缓存，然而缓存的数据一般都是需要设置生存时间的，即：到期后数据销毁。

设置key的生存时间
（单位：秒）key在seconds秒后会自动删除

EXPIRE key seconds

查看key剩余的生存时间

TTL key

返回正数：剩余过期时间（秒）；
返回-1：key 存在但无过期时间（永久有效）；
返回-2：key 不存在。

清除生存时间
即让key 永久有效

PERSIST key

生存时间设置单位为：毫秒
1秒等于1000毫秒

PEXPIRE key milliseconds

返回满足给定pattern 的所有key

keys

|------|---------------------------------|--------------|-----------------|-------------------------------------------|
| 符号 | 含义 | 通俗解释 | 实例 | 匹配结果（假设存在 key：name、name1、name2、user_name） |
| * | 匹配 任意个任意字符 （0 个 / 1 个 / 多个） | 像 "万能匹配"，能兜底 | keys name* | 匹配 name、name1、name2（以 name 开头的所有 key） |
| ? | 匹配 1 个任意字符 | 精准占 1 个位置 | keys name? | 匹配 name1、name2（name 后必须跟 1 个字符），不匹配 name |
| \[\] | 匹配 括号内的 1 个字符 | 限定范围，只选 1 个 | keys name $12$ | 只匹配 name1、name2，不匹配 name3/name |

检查指定 key 是否存在

exists

1在，0不在。

删除指定 key

del

重命名 key

rename <旧 key> < 新 key>

查看 key 对应值的数据类型

type

5.1.2 方法

通用 Key 操作

|----------|----------------------------------------------------------|---------------------------------------------------------|
| Redis 命令 | StringRedisTemplate 核心方法 | 功能说明 |
| keys | stringRedisTemplate.keys(pattern) | 通配符匹配所有 key，返回 Set（支持 *、?、\[\] 通配符） |
| exists | stringRedisTemplate.hasKey(key) | 检查指定 key 是否存在，返回 Boolean（存在 = true / 不存在 = false） |
| del | stringRedisTemplate.delete(key) | 删除指定 key，返回 Boolean（成功 = true / 失败 = false） |
| ttl | stringRedisTemplate.getExpire(key) | 查看 key 剩余过期时间（秒），返回 Long（-2 = 不存在 /-1 = 永久 / 正数 = 剩余秒数） |
| setex | opsForValue().set(key, value, timeout, TimeUnit.SECONDS) | 设置 key 值并指定过期时间（秒级），替代原生 setex 命令 |
| rename | stringRedisTemplate.rename(oldKey, newKey) | 重命名 key，建议先通过 hasKey 判断 key 是否存在 |
| get | opsForValue().get(key) | 获取指定 key 的字符串值，返回 String（key 不存在则返回 null） |

总结
通用 Key 操作：stringRedisTemplate.xxx()（如 keys/hasKey/delete/rename/getExpire）；

代码

package com.qcby.springbootredis;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
仅适配SpringBoot 2.7.6的Redis测试类
修复asc()方法找不到的问题，可直接运行*/@SpringBootTestpublic class RedisOtherTest {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
public void testOther() throws InterruptedException {
try {
// 1. keys通配符匹配
Set allKeys = stringRedisTemplate.keys("*");
System.out.println("当前库所有key：" + allKeys);
Set nameKeys = stringRedisTemplate.keys("*name");
System.out.println("以name结尾的key：" + nameKeys);

复制代码

  // 2. 删除key
  Boolean delResult = stringRedisTemplate.delete("sanmdde");
  System.out.println("删除sanmdde结果：" + (delResult ? 1 : 0));

  // 3. 查看key剩余过期时间
  Long ttl = stringRedisTemplate.getExpire("sname");
  System.out.println("sname的剩余有效时间（秒）：" + (ttl == -2 ? "key不存在" : ttl));

  // 4. 设置key过期时间
  stringRedisTemplate.opsForValue().set("timekey", "min", 10, TimeUnit.SECONDS);

  // 睡眠5秒后查看剩余时间
  Thread.sleep(5000);
  Long ttlAfterSleep = stringRedisTemplate.getExpire("timekey");
  System.out.println("睡眠5秒后timekey剩余时间：" + ttlAfterSleep);

  // 重新设置过期时间为8秒
  stringRedisTemplate.opsForValue().set("timekey", "min", 8, TimeUnit.SECONDS);
  Long newTtl = stringRedisTemplate.getExpire("timekey");
  System.out.println("重新设置后timekey剩余时间：" + newTtl);

  // 5. 检查key是否存在
  Boolean exists = stringRedisTemplate.hasKey("key");
  System.out.println("key是否存在：" + exists);

  // 6. 重命名key（先判断key是否存在，避免报错）
  if (stringRedisTemplate.hasKey("timekey")) {
      stringRedisTemplate.rename("timekey", "time");
      System.out.println("重命名timekey为time成功");
  } else {
      System.out.println("timekey不存在，跳过重命名");
  }

  // 验证重命名结果
  String timekeyValue = stringRedisTemplate.opsForValue().get("timekey");
  System.out.println("timekey的值（重命名后应为null）：" + timekeyValue);
  String timeValue = stringRedisTemplate.opsForValue().get("time");
  System.out.println("time的值：" + timeValue);

} catch (Exception e) {
e.printStackTrace();
}

}
}

5.2 服务器相关

5.2.1 命令

测试Redis连接是否存活

ping

正常连接：ping → 返回PONG
服务停止：ping → 报错Connection refused

在命令行打印指定内容

echo <要打印的内容>

<要打印的内容>为字符串，支持中文 / 英文，无需引号（加引号也可）

切换 Redis 数据库（编号 0~15）

select <数据库编号>

关闭当前 Redis 客户端连接

quit

返回当前数据库中 key 的总数

dbsize

获取 Redis 服务器的信息 / 统计数据

info [可选参数]

无参数：返回所有服务器信息；

带参数：info （如info memory/info replication）

$可选参数$ 就是下面注解的内容（如Server、Clients、Memory）。

复制代码

127.0.0.1:6379[1]> info
# Server
redis_version:5.0.14
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:cf85ac5209079a37
redis_mode:standalone
os:Linux 3.10.0-957.21.3.el7.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
atomicvar_api:atomic-builtin
gcc_version:4.8.5
process_id:3406
run_id:38f6bfb401869329f4ce45505b99ebce25a9bcfd
tcp_port:6379
uptime_in_seconds:79482
uptime_in_days:0
hz:10
configured_hz:10
lru_clock:9445961
executable:/usr/local/redis/./bin/redis-server
config_file:/usr/local/redis/./conf/redis.conf

# Clients
connected_clients:1
client_recent_max_input_buffer:2
client_recent_max_output_buffer:0
blocked_clients:0

# Memory
used_memory:854944
used_memory_human:834.91K
used_memory_rss:2699264
used_memory_rss_human:2.57M
used_memory_peak:895432
used_memory_peak_human:874.45K
used_memory_peak_perc:95.48%
used_memory_overhead:841438
used_memory_startup:791496
used_memory_dataset:13506
used_memory_dataset_perc:21.29%
allocator_allocated:866704
allocator_active:1069056
allocator_resident:3809280
total_system_memory:1842106368
total_system_memory_human:1.72G
used_memory_lua:37888
used_memory_lua_human:37.00K
used_memory_scripts:0
used_memory_scripts_human:0B
number_of_cached_scripts:0
maxmemory:0
maxmemory_human:0B
maxmemory_policy:noeviction
allocator_frag_ratio:1.23
allocator_frag_bytes:202352
allocator_rss_ratio:3.56
allocator_rss_bytes:2740224
rss_overhead_ratio:0.71
rss_overhead_bytes:-1110016
mem_fragmentation_ratio:3.32
mem_fragmentation_bytes:1886576
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_clients_slaves:0
mem_clients_normal:49694
mem_aof_buffer:0
mem_allocator:jemalloc-5.1.0
active_defrag_running:0
lazyfree_pending_objects:0

# Persistence
loading:0
rdb_changes_since_last_save:0
rdb_bgsave_in_progress:0
rdb_last_save_time:1771051450
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:0
rdb_current_bgsave_time_sec:-1
rdb_last_cow_size:167936
aof_enabled:0
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_last_write_status:ok
aof_last_cow_size:0

# Stats
total_connections_received:32
total_commands_processed:41
instantaneous_ops_per_sec:0
total_net_input_bytes:4783
total_net_output_bytes:5320
instantaneous_input_kbps:0.00
instantaneous_output_kbps:0.00
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:3
expired_stale_perc:0.00
expired_time_cap_reached_count:0
evicted_keys:0
keyspace_hits:9
keyspace_misses:8
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:232
migrate_cached_sockets:0
slave_expires_tracked_keys:0
active_defrag_hits:0
active_defrag_misses:0
active_defrag_key_hits:0
active_defrag_key_misses:0

# Replication
role:master
connected_slaves:0
master_replid:bad35de76342378f8e85b493522aa930b8f56a2a
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

# CPU
used_cpu_sys:24.745930
used_cpu_user:50.547060
used_cpu_sys_children:0.002152
used_cpu_user_children:0.000985

# Cluster
cluster_enabled:0

# Keyspace
db0:keys=2,expires=0,avg_ttl=0
db1:keys=1,expires=0,avg_ttl=0

删除当前选中数据库的所有 key

flushdb

删除所有数据库的所有 key

flushall