Redis入门

发表于 更新于 分类于 > > 本文字数： 6k 阅读时长 ≈ 20 分钟

概述

  • Redis（Remote Dictionary Server，远程字典服务）是一个开源的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。它支持多种类型的数据结构，如字符串（strings）、列表（lists）、集合（sets）、有序集合（sorted sets）、哈希表（hashes）、位图（bitmaps）、超日志（hyperloglogs）以及地理空间（geospatial）索引半径查询。
  • Redis 通常用于需要快速响应且数据集不是非常大（能够适合存储在内存中）的场景。例如，Web 应用中的会话缓存、数据库查询缓存、任务队列等场景中，Redis可以提供快速的数据访问功能。此外，Redis还支持发布/订阅（pub/sub）模式，广泛应用于消息传递系统。

Redis 特点

  1. 基于内存操作：Redis将所有数据保存在内存中，这意呹着它能够提供非常快速的读写速度。
  2. 支持多种数据结构：Redis不仅支持简单的键值对，还支持更复杂的数据结构，例如列表（lists）、集合（sets）、有序集合（zsets）、哈希表（hashes）、位图（bitmaps）、超日志（hyperloglogs）和地理空间（geospatial）索引。
  3. 数据持久化：尽管Redis是一个内存数据库，但它提供了RDB（Redis Database）和AOF（Append Only File）两种持久化机制，以保护数据不因进程退出或硬件故障而丢失。
  4. 原子性操作：Redis的所有操作都是原子性的，这意味着要么全部执行，要么全部不执行，保证了操作的完整性。
  5. 高度配置性：Redis提供了丰富的配置选项，允许用户在性能和持久性之间进行权衡。
  6. 发布/订阅模式：Redis支持发布/订阅消息系统，允许客户端之间通过频道进行消息传递。
  7. 高可用和自动分区：通过Redis Sentinel进行高可用性配置，以及通过Redis Cluster实现自动分区。
  8. 广泛的语言支持：支持多种编程语言的客户端库，如JavaScript、Java、Python、PHP、Ruby、C#等。
  9. 事务支持：Redis通过MULTI、EXEC、WATCH等命令提供事务功能，可以将多个命令打包，然后一次性、顺序地执行。
  10. Lua脚本：Redis支持使用Lua语言编写脚本，可以在Redis服务器上原子性地执行一系列命令。
  11. 安全性：支持基于角色的访问控制（RBAC）、SSL加密通信以及密码认证，保障数据安全。
  12. 简单且实用的设计：Redis的设计十分简单，易于安装和使用。同时它的指令集合也很实用，能够满足多种不同场景的需求。

Redis 安装

  • 在 Ubuntu 等基于 Debian 的系统上

    1
    2
    sudo apt-get update
    sudo apt-get install redis-server

  • 在 Red Hat、CentOS 等基于 RPM 的系统上

    1
    sudo yum install redis

    或者使用 dnf：

    1
    sudo dnf install redis

如果你使用的是 Homebrew，可以通过以下命令安装：

1
brew install redis
  • Windows 官方不直接支持 Redis，但 Microsoft 维护了一个 Windows 版本的 Redis，可以从 GitHub 上下载编译好的 .exe 文件来运行。
  • 另外，可以使用 WSL（Windows Subsystem for Linux）在 Windows 上运行 Linux 版本的 Redis。

  • 如果想要从源代码安装最新版本的 Redis，可以按照以下步骤操作：

    1
    2
    3
    4
    wget http://download.redis.io/redis-stable.tar.gz
    tar -xvzf redis-stable.tar.gz
    cd redis-stable
    make

  • 编译完成后，可以使用以下命令进行测试：

    1
    make test

  • 如果一切正常，可以继续安装：

    1
    sudo make install

  • 安装后，你可以运行 redis-server 来启动 Redis 服务器，使用 redis-cli 来启动一个 Redis 命令行客户端。

Redis 连接

  1. 打开命令行界面（在 Windows 上可能是命令提示符或 PowerShell，在 Unix-like 系统上是终端）。
  2. 输入 redis-cli 命令并按回车键。如果 Redis 服务器运行在同一台机器上，并且使用的是默认的 6379 端口，你通常不需要提供任何额外的参数。
  3. 如果 Redis 服务器运行在不同的主机上或使用了不同的端口，你需要指定地址和端口，例如：
    1
    redis-cli -h <hostname> -p <port>
    其中 <hostname> 是运行 Redis 服务器的机器的 IP 地址或主机名，<port> 是 Redis 服务器监听的端口号。
  4. 成功连接到 Redis 服务器后，你可以尝试运行一个简单的命令来测试连接，例如：
    1
    ping
    如果服务器运行正常，你将看到一个 PONG 的响应。
  5. 你也可以尝试设置一个键值对来进一步测试：
    1
    2
    set mykey "Hello"
    get mykey
    这将设置键 mykey 的值为 Hello，然后使用 get 命令来检索并显示这个值。
  6. 测试完成后，可以输入 exit 来关闭 redis-cli。

Redis 密码

  • 设置密码

    1. 找到 Redis 配置文件 redis.conf。默认情况下，它可能位于 /etc/redis/ 或者你安装 Redis 的目录中。
    2. 打开 redis.conf 文件，在文本编辑器中找到 # requirepass foobared 这一行。
    3. 取消这一行的注释，并将 foobared 替换为你想设置的密码。例如：
      1
      requirepass mySecurePassword
      确保选择一个强密码来增强安全性。
    4. 保存配置文件，并重启 Redis 服务使更改生效。重启 Redis 服务的方法取决于你的操作系统和 Redis 的安装方式，通常可以通过以下命令之一来完成：
      1
      sudo systemctl restart redis-server
      或
      1
      sudo service redis-server restart

  • 通过密码连接

    • 使用密码连接 Redis，你可以使用带有 -a 选项的 redis-cli 命令附上你的密码。例如：
      1
      redis-cli -a mySecurePassword
    • 如果你连接的是远程服务器或者不同的端口，你还需要指定主机和端口：
      1
      redis-cli -h <hostname> -p <port> -a mySecurePassword
      替换 <hostname> 和 <port> 为实际的服务器地址和端口号。
    • 一旦连接成功，你就可以像平常一样执行 Redis 命令了。如果密码错误，Redis 将不允许执行任何命令，并返回一个错误。
    • 安全提示：将密码直接写在命令行中可能不安全，因为它可能被保存在命令行历史中。为了提高安全性，考虑以下几点：
      • 使用配置文件中的密码设置，而不是命令行参数。
      • 推荐使用 redis-cli 的交互模式，然后使用 AUTH 命令进行认证：
        1
        2
        redis-cli
        127.0.0.1:6379> AUTH mySecurePassword
      • 确保你的 Redis 服务器不对外暴露，特别是不要直接暴露在公网上。使用网络防火墙和其他安全措施保护你的Redis 服务。

Redis 命令

  • 通用命令

    • SELECT: 用于切换到指定的数据库，数据库索引号用整数来表示。Redis 服务器默认提供了 16 个逻辑数据库，索引号从 0 到 15。
    • INFO: 用于获取 Redis 服务器的各种信息和统计数据。
    • SAVE: 用于同步地将 Redis 的数据保存到磁盘的 dump.rdb 文件中。
    • BGSAVE: 用于在后台异步地将 Redis 的数据保存到磁盘的 dump.rdb 文件中，不会阻塞客户端的命令执行。
    • COMMAND: 获取所有命令的详细信息。
    • KEYS pattern: 查找所有符合给定模式的键。
    • EXISTS key: 检查给定键是否存在。
    • DEL key: 删除一个键。
    • EXPIRE key seconds: 设置键的过期时间。
    • TTL key: 查看键的剩余过期时间。
    • FLUSHDB: 删除当前数据库的所有键。
    • FLUSHALL: 删除所有数据库的所有键。

  • 字符串(String)

    在Redis中，字符串（String）是最基本的数据类型，也是键值存储系统中的基础。字符串可以包含任何数据，包括二进制数据，并且可用于存储一个值或一些复杂的结构如JSON、序列化的对象等。下面是一个关于字符串操作的简表说明：

    命令 使用描述 示例
    SET 设置指定键的值 SET mykey value
    GET 获取指定键的值 GET mykey
    DEL 删除一个或多个键 DEL mykey
    INCR 将键的整数值增加1 INCR counter
    DECR 将键的整数值减少1 DECR counter
    INCRBY 将键的整数值按指定数值增加 INCRBY counter 10
    DECRBY 将键的整数值按指定数值减少 DECRBY counter 10
    APPEND 将值追加到键的现有值的末尾 APPEND mykey " World"
    STRLEN 获取指定键的值的长度 STRLEN mykey
    MSET 同时设置一个或多个键-值对 MSET key1 "Hello" key2 "World"
    MGET 同时获取一个或多个键的值 MGET key1 key2
    SETEX 设置键的值，并设置过期时间（秒） SETEX mykey 60 "value"
    SETNX 只有在键不存在时，才对键进行设置操作 SETNX mykey "value"
    GETSET 将给定键的值设为新值，并返回键的旧值 GETSET mykey "new value"
    • 这些命令构成了Redis字符串操作的基础。利用这些基本命令，你可以在Redis中执行各种字符串相关的操作，从简单的数据缓存到更复杂的计数器和状态标志等功能。
    • 务必注意，每个Redis键都有一个最大值大小限制，它是512MB。这意味着，一个Redis字符串可以保持的内容大小最多为512MB。这个限制对于大多数用例来说是足够的。

  • 列表(List)

    Redis列表是简单的字符串列表，按照插入顺序排序。它是一个双向链表，支持在两端（头部和尾部）快速地进行插入和删除操作。下面是关于Redis列表操作的一个简表说明：

    命令 使用描述 示例
    LPUSH 将一个或多个值插入到列表头部 LPUSH mylist "world"
    RPUSH 将一个或多个值插入到列表尾部 RPUSH mylist "hello"
    LPOP 移除并返回列表头部的元素 LPOP mylist
    RPOP 移除并返回列表尾部的元素 RPOP mylist
    LLEN 获取列表长度 LLEN mylist
    LRANGE 获取列表指定范围内的元素 LRANGE mylist 0 -1
    LINDEX 通过索引获取列表中的元素 LINDEX mylist 0
    LSET 通过索引设置列表元素的值 LSET mylist 0 "new value"
    LINSERT 在列表的元素前或后插入元素 LINSERT mylist BEFORE "world" "there"
    LREM 删除列表中等于指定值的元素 LREM mylist 0 "hello"
    LTRIM 修剪到指定范围的清单 LTRIM mylist 1 -1
    RPOPLPUSH 移除列表的最后一个元素，将其追加到另一个列表 RPOPLPUSH mylist1 mylist2
    BLPOP 阻塞式移除并获取列表的第一个元素 BLPOP mylist 0
    BRPOP 阻塞式移除并获取列表的最后一个元素 BRPOP mylist 0
    BRPOPLPUSH 阻塞式从一个列表中弹出一个值，将其推入另一个列表 BRPOPLPUSH mylist1 mylist2 0
    • 这些列表操作允许你在进行各种场景下的列表处理，如消息队列、栈、双向队列等。LPUSH 和 RPUSH 命令使得你可以从两端向列表中添加数据，而 LPOP 和 RPOP 则允许你从列表的两端删除元素。LRANGE 和 LINDEX 可以用来检索列表中的元素，而 LSET 和 LTRIM 则用来修改列表的内容。也可以通过 LREM 来删除指定的元素。
    • 记住，对于大列表，如那些包含数以万计或更多元素的列表，某些操作可能会很慢，比如 LINDEX，LINSERT，LSET，这些命令的复杂度是O(n)，其中n为到达指定位置的距离。而像 LPUSH 和 RPOP 这类操作则是O(1)。

  • 集合(Set)

    Redis集合是由字符串组成的无序收集，并且集合中的每个成员都是唯一的。Redis提供了丰富的操作来管理集合类型的数据。以下是一些常用的Redis集合操作命令：

    命令 使用描述 示例
    SADD 向集合添加一个或多个成员 SADD myset "Hello"
    SMEMBERS 获取集合中的所有成员 SMEMBERS myset
    SISMEMBER 判断成员元素是否是集合的成员 SISMEMBER myset "Hello"
    SCARD 获取集合的成员数 SCARD myset
    SREM 移除集合中一个或多个成员 SREM myset "Hello"
    SPOP 移除并返回集合中的一个随机元素 SPOP myset
    SRANDMEMBER 返回集合中的一个或多个随机数 SRANDMEMBER myset
    SINTER 返回所有给定集合的交集 SINTER myset1 myset2
    SUNION 返回所有给定集合的并集 SUNION myset1 myset2
    SDIFF 返回给定所有集合的差集 SDIFF myset1 myset2
    SINTERSTORE 对给定集合进行交集并存储在新的集合中 SINTERSTORE myset1 myset2
    SUNIONSTORE 对给定集合进行并集并存储在新的集合中 SUNIONSTORE myset1 myset2
    SDIFFSTORE 对给定集合进行差集并存储在新的集合中 SDIFFSTORE myset1 myset2
    SMOVE 将成员从一个集合移动到另一个集合 SMOVE myset1 myset2 "Hello"
    • 这些命令覆盖了集合的基本操作，包括添加、删除元素，成员的查询，以及集合间的运算等。由于集合是无序的，所以你不能像列表那样为集合中的元素指定特定的位置。集合很适合用于存储不重复的数据集，比如标签、投票、会话、访问者唯一ID等。
    • Redis集合操作大多是O(1)的时间复杂度（例如SADD、SISMEMBER、SPOP等），这意味着这些操作的性能是非常高的，即使是在包含大量元素的集合中也是如此。但是，类似SMEMBERS和SUNION这些可能返回大量数据的命令在大集合上使用时可能会比较慢，需要谨慎使用。

  • 有序集合(Sorted Set)

    Redis有序集合（sorted sets）是集合数据结构的一种扩展，它不仅存储了成员（member），而且还为每个成员关联了一个分数（score）。这使得有序集合成员可以按照分数进行快速、非降序的访问。有序集合对于需要按照一定顺序访问元素的场景（比如排名、优先队列等）非常有用。

    命令 使用描述 示例
    ZADD 向有序集合添加成员，或者更新已存在成员的分数 ZADD myzset 1 "one"
    ZSCORE 获取有序集合成员的分数 ZSCORE myzset "one"
    ZRANGE 按照分数值增序返回有序集合指定区间内的成员 ZRANGE myzset 0 -1
    ZREVRANGE 按照分数值降序返回有序集合指定区间内的成员 ZREVRANGE myzset 0 -1
    ZRANGEBYSCORE 返回有序集合中指定分数区间的成员列表 ZRANGEBYSCORE myzset min max
    ZREVRANGEBYSCORE 返回有序集合中指定分数区间的成员列表，按分数值递减 ZREVRANGEBYSCORE myzset max min
    ZREM 移除有序集合中的一个或多个成员 ZREM myzset "one"
    ZINCRBY 增加有序集合成员的分数 ZINCRBY myzset 2 "one"
    ZCARD 获取有序集合的成员数 ZCARD myzset
    ZCOUNT 计算在有序集合中指定分数区间的成员数量 ZCOUNT myzset min max
    ZLEXCOUNT 在有序集合中计算指定字典区间内成员数量 ZLEXCOUNT myzset "["min" "["max"
    ZRANK 返回有序集合中指定成员的索引 ZRANK myzset "one"
    ZREVRANK 返回有序集合中指定成员的逆序索引 ZREVRANK myzset "one"
    ZREM 删除有序集合中的一个或多个成员 ZREM myzset "one"
    ZREMRANGEBYRANK 移除有序集合中给定的排名区间的所有成员 ZREMRANGEBYRANK myzset 0 1
    ZREMRANGEBYSCORE 移除有序集合中给定的分数区间的所有成员 ZREMRANGEBYSCORE myzset min max
    ZUNIONSTORE / ZINTERSTORE 计算多个有序集合的并集或交集，并存储到新的集合 ZUNIONSTORE out 2 zset1 zset2 WEIGHTS 2 3
    • 这些命令为你提供了处理有序集合的一切必要工具，从添加、移除元素到获取成员的排名、分数，以及执行范围查询和集合间的运算。使用有序集合可以有效地解决排序和排名问题。例如，你可以使用有序集合来存储游戏中玩家的分数并轻松地实现排名系统。
    • 请注意，尽管有序集合的操作提供了高性能的行为（例如ZADD、ZREM、ZSCORE是O(log(N))时间复杂度，其中N是有序集合中的元素数量），但如果你返回大量的元素（如ZRANGE、ZRANGEBYSCORE），操作的时间和空间复杂度仍然可能随返回的元素数量增长。因此，在大数据集上使用这些操作时，应该小心使用，以免对性能产生影响。

  • 哈希(Hash)

    Redis 的哈希类型适合存储对象，在这种类型中，可以存储键值对（field-value）。它是字符串字段和字符串值之间的映射表。哈希特别适合用于存储对象和能够让你只获取或设置对象的某些字段的场景。

    命令 使用描述 示例
    HSET 设置哈希表字段的字符串值 HSET myhash field1 "Hello"
    HGET 获取存储在哈希表中指定字段的值 HGET myhash field1
    HMSET 同时将多个 field-value (字段-值)对设置到哈希表中 HMSET myhash field1 "Hello" field2 "World"
    HMGET 获取所有给定字段的值 HMGET myhash field1 field2
    HINCRBY 为哈希表中的字段值加上指定增量值 HINCRBY myhash field 2
    HDEL 删除一个或多个哈希表字段 HDEL myhash field1
    HEXISTS 查看哈希表的指定字段是否存在 HEXISTS myhash field1
    HKEYS 获取哈希表中的所有字段 HKEYS myhash
    HVALS 获取哈希表中的所有值 HVALS myhash
    HGETALL 获取在哈希表中的所有字段和值 HGETALL myhash
    HLEN 获取哈希表中字段的数量 HLEN myhash
    HSTRLEN 获取哈希表中字段值的字符串长度 HSTRLEN myhash field1
    HINCRBYFLOAT 为哈希表中的字段值加上指定浮点数增量值 HINCRBYFLOAT myhash field 0.5
    HSCAN 迭代哈希表中的键值对 HSCAN myhash 0
    • 哈希类型的命令几乎涵盖了对象的所有基本操作，包括创建、读取、更新和删除。HSET 和 HGET 是最基础的设置和获取单个字段的命令，而 HMSET 和 HMGET 允许一次性设置和获取多个字段。HINCRBY 和 HINCRBYFLOAT 命令可以用来对字段的数值进行自增操作。
    • Redis 哈希的命令大多是 O(1) 的时间复杂度（比如 HSET, HGET, HDEL, HEXISTS），而 HGETALL 和 HMGET 的复杂度则是 O(n)，n 是被请求字段的数量。
    • 请注意，虽然设置和获取单个字段的命令非常快，但如果尝试一次性获取或设置大量的字段，那么这些操作的性能会受到影响，尤其是当这些字段包含大量数据时。此外，哈希表在存储和访问数据时相比字符串类型会有更多的内存开销，但是它们在存储对象属性时更为灵活和高效。

Python 操作 Redis

  • 简介

    要在 Python 中操作 Redis，您需要使用一个名为 redis-py 的客户端库。这个库提供了一个简单的接口来与 Redis 数据库进行交互。

  • 安装

    1
    pip install redis

  • 连接到 Redis

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    import redis

    # 配置 Redis 连接，自动解码响应为字符串
    r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

    # 设置键值对
    r.set('greeting', 'Hello, World!')

    # 获取键值对
    print(r.get('greeting'))  # 输出: Hello, World!

    # 使用哈希表存储和检索用户数据
    user_id = "user:1000"
    user_data = {
        "name": "Alice",
        "email": "alice@example.com",
        "age": 30
    }

    # 使用 hmset (在 redis-py 版本 3.5.0 中已废弃，改为 hset) 设置多个哈希字段
    r.hset(user_id, mapping=user_data)

    # 获取哈希表中的单个字段
    print(r.hget(user_id, "name"))  # 输出: Alice

    # 获取整个哈希表
    # 输出: {'name': 'Alice', 'email': 'alice@example.com', 'age': '30'}
    print(r.hgetall(user_id))

    # 列表操作，从左侧推入多个值
    r.lpush('numbers', 1, 2, 3)

    # 从列表右侧弹出一个值
    print(r.rpop('numbers'))  # 输出: 1

    # 集合操作，添加多个元素
    r.sadd('fruits', 'apple', 'banana', 'cherry')

    # 检查元素是否在集合中
    print(r.sismember('fruits', 'banana'))  # 输出: True

    # 获取集合所有元素
    print(r.smembers('fruits'))  # 输出: {'cherry', 'banana', 'apple'}

    # 有序集合，添加元素与分数
    r.zadd('scores', {'Alice': 50, 'Bob': 30, 'Charlie': 70})

    # 获取有序集合的成员和它们的分数
    # 输出: [('Bob', 30.0), ('Alice', 50.0), ('Charlie', 70.0)]
    print(r.zrange('scores', 0, -1, withscores=True))

    # 清空当前数据库
    r.flushdb()

    • 这个例子包括了连接到 Redis、设置和获取键值对、操作哈希表、列表、集合和有序集合，以及最后清空数据库的操作。请注意，这里使用了 flushdb()，它会删除当前数据库中的所有键，这个操作在生产环境中需要慎重使用。
    • 确保你有一个正在运行的 Redis 服务器，并且根据你的配置可能需要调整连接参数（例如 host, port, db）。在运行示例代码之前，请确保 Python 环境中安装了 redis-py 库。

  • 连接池

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    import redis

    # 创建连接池
    pool = redis.ConnectionPool(host='localhost', port=6379, db=0, decode_responses=True)

    # 使用连接池创建 Redis 对象
    r = redis.Redis(connection_pool=pool)

    # 设置键值对
    r.set('language', 'Python')

    # 获取键值对
    print(r.get('language'))  # 输出: Python

    # 其他操作，可以重复使用上面创建的连接
    # ...

    # 当不再需要使用连接池时（例如，程序结束时），可以关闭连接池
    # 通常情况下，不需要手动关闭，因为连接池会在需要时自动创建和关闭连接
    # pool.disconnect()

    • 在这个示例中，我们首先创建了一个连接池，指定了 Redis 服务器的主机、端口和数据库。然后，我们通过传递这个连接池对象来创建一个 Redis 实例。这个实例会自动从连接池中获取连接来执行操作。
    • 连接池 ConnectionPool 的参数可以根据你的需要进行调整，例如，你可以设置最大连接数，以及连接超时时间等。
    • 注意，在大多数场景下，你不需要手动关闭连接池，因为当连接池不再被引用且所有连接都已关闭时，它会被自动销毁。如果你需要在程序的某个时刻关闭所有连接，可以调用 pool.disconnect() 方法。

  • 使用管道 (pipeline)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    import redis

    # 创建 Redis 连接
    r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

    # 创建管道对象
    pipe = r.pipeline()

    # 将多个命令打包到管道中
    pipe.set('author', 'Hemingway')
    pipe.get('author')
    pipe.incr('books_count')
    pipe.incr('books_count')
    pipe.decr('books_count')

    # 执行管道中的所有命令
    # execute() 返回一个包含每个命令结果的列表
    results = pipe.execute()

    # 输出结果
    print(results)  # 输出: [True, 'Hemingway', 1, 2, 1]，对应每一条命令的返回值

    # 如果你需要在异常情况下自动重试命令，可以使用事务功能
    # 管道的事务通过将多个命令打包在 MULTI/EXEC 块中来使用
    # MULTI/EXEC 可以保证命令序列的原子性执行
    pipe.multi()
    pipe.set('novel', 'For Whom the Bell Tolls')
    pipe.get('novel')
    pipe.incr('chapters_count')
    results = pipe.execute()

    # 输出事务结果
    print(results)  # 输出对应命令的返回值

    • 在这个示例中，我们首先创建了一个普通的管道，并在其中添加了多个命令。当我们调用 execute() 方法时，所有的命令都被发送到 Redis 服务器上执行，然后返回一个列表，该列表包含了管道中每个命令的结果。
    • 在使用管道时，你还可以选择使用事务，这通过在管道上调用 multi() 方法实现。这样可以保证在 MULTI 和 EXEC 命令之间的所有命令要么全部执行成功，要么全部不执行。
    • 请注意，当使用管道时，直到调用 execute() 方法之前，不会有任何命令实际发送到 Redis 服务器。这也意味着在执行 execute() 方法之前，你不会得到任何命令的结果。

使用工具远程连接Redis

  • 修改配置文件：/etc/redis/redis.conf，bind改为0.0.0.0
  • 修改之后重启服务即可。
  • 友情链接：Redis Desktop Manager 密码：2dle
本文结束 感谢您的阅读
正在加载今日诗词....